MyBatis入门系列(18) -MyBatis四大组件之ParameterHandler源码及流程解析

红太狼 2023-10-10 13:02 11阅读 0赞

### ParameterHandler ###

在之前的分析文档中，我们了解到在创建StatementHandler时，会生成参数处理器及结果集处理器。每个StatementHandler都会包含一个ParameterHandler及ResultSetHandler。

ParameterHandler参数处理器主要是为PreparedStatement的sql语句参数动态赋值。

this.parameterHandler = this.configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
            this.resultSetHandler = this.configuration.newResultSetHandler(executor, mappedStatement, rowBounds, this.parameterHandler, resultHandler, boundSql);

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70]

### 源码分析 ###

#### SqlSource ####

SqlSource是一个接口，只有一个方法，根据参数对象获取BoundSql，它的主要功能就是从 XML文件，然后根据输入参数创建SQL将其传递到数据库执行。

BoundSql getBoundSql(Object parameterObject);

它的实现类如下所示：  
![在这里插入图片描述][6a197cf0efca44b59a7f81791f55fcd2.png]  
**DynamicSqlSource**：封装动态SQL标签解析之后的SQL语句和带有$ \{\}的SQL语句，$\{\}和动态标签中的表达式是都OGNL表达式，都是使用OGNL表达式从入参对象中获取。

**RawSqlSource**： 主要封装带有\#\{\}的SQL语句或者可直接执行的SQL语句，则使用该SqlSource来封装SQL信息。

**StaticSqlSource**： 处理静态sql，无论是静态sql，还是动态sql，最终的处理结果，都是静态sql。

**ProviderSqlSource**：处理注解Annotation形式的sql。

#### ParameterHandler接口 ####

ParameterHandler是一个接口，定义个两个方法，也只有一个实现类。比较简单。  
![在这里插入图片描述][20210628100456827.png]

ParameterHandler接口源码：

/**
     * A parameter handler sets the parameters of the {@code PreparedStatement}
     * 参数处理程序设置 {@code PreparedStatement} 的参数
     *
     * @author Clinton Begin
     */
    public interface ParameterHandler {
        
        //得到参数
        Object getParameterObject();
    
        //设置参数
        void setParameters(PreparedStatement ps)
                throws SQLException;
    
    }

#### DefaultParameterHandler ####

DefaultParameterHandler，默认的参数处理器，是 ParameterHandler接口的实现类，主要是提供了处理参数的实际逻辑。

/**
     * @author Clinton Begin
     * @author Eduardo Macarron
     *  默认参数处理器
     */
    public class DefaultParameterHandler implements ParameterHandler {
        
    
        private final TypeHandlerRegistry typeHandlerRegistry;
    
        private final MappedStatement mappedStatement;
        private final Object parameterObject;
        private final BoundSql boundSql;
        private final Configuration configuration;
    
        public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        
            this.mappedStatement = mappedStatement;
            this.configuration = mappedStatement.getConfiguration();
            this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
            this.parameterObject = parameterObject;
            this.boundSql = boundSql;
        }
    
        @Override
        public Object getParameterObject() {
        
            return parameterObject;
        }
    
        //设置参数
        @Override
        public void setParameters(PreparedStatement ps) {
        
            ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
            List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
            if (parameterMappings != null) {
        
                //设置参数
                for (int i = 0; i < parameterMappings.size(); i++) {
        
                    //循环设参数
                    ParameterMapping parameterMapping = parameterMappings.get(i);
                    //如果不是OUT，才设进去
                    if (parameterMapping.getMode() != ParameterMode.OUT) {
        
                        Object value;
                        String propertyName = parameterMapping.getProperty();
                        //若有额外的参数, 设为额外的参数
                        if (boundSql.hasAdditionalParameter(propertyName)) {
         // issue #448 ask first for additional params
                            value = boundSql.getAdditionalParameter(propertyName);
                        } else if (parameterObject == null) {
        
                            //若参数为null，直接设null
                            value = null;
                        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
        
                            //若参数有相应的TypeHandler，直接设object
                            value = parameterObject;
                        } else {
        
                            //除此以外，MetaObject.getValue反射取得值设进去
                            MetaObject metaObject = configuration.newMetaObject(parameterObject);
                            value = metaObject.getValue(propertyName);
                        }
                        TypeHandler typeHandler = parameterMapping.getTypeHandler();
                        JdbcType jdbcType = parameterMapping.getJdbcType();
                        if (value == null && jdbcType == null) {
        
                            //不同类型的set方法不同，所以委派给子类的setParameter方法
                            jdbcType = configuration.getJdbcTypeForNull();
                        }
                        try {
        
                            typeHandler.setParameter(ps, i + 1, value, jdbcType);
                        } catch (TypeException e) {
        
                            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                        } catch (SQLException e) {
        
                            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                        }
                    }
                }
            }
        }
    
    }

### 流程分析 ###

#### 1. SqlSource ####

我们知道，项目在启动时，全局Configuration对象，会加载所有的mapper接口及XML信息，并封装到mappedStatements集合中。

protected final Map<String, MappedStatement> mappedStatements;

我们又知道，MappedStatement对象封装了每个SQL语句的详细信息，并且它是一个final类型也就是说实例化之后就不允许改变。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 1]  
从上图可以看出，每个MappedStatement实例装载了很多信息，其中就封装了一个SqlSource接口的实例，SqlSource中封装了原始SQL和参数映射的关系。

StaticSqlSource源码：

public class StaticSqlSource implements SqlSource {
        
      // XML 中的SQL 信息 SELECT
      //	        *
      //        FROM
      //	        bsd_account
      //	    where
      //            bsd_account.status > ?
      private final String sql;
      // 参数映射关系 ParameterMapping{property='user.uid', mode=IN, javaType=class java.lang.Object, jdbcType=null, numericScale=null, resultMapId='null', jdbcTypeName='null', expression='null'}
      private final List<ParameterMapping> parameterMappings;
      // Configuration对象
      private final Configuration configuration;
      
      // 构造方法
      public StaticSqlSource(Configuration configuration, String sql) {
        
        this(configuration, sql, null);
      }
      // 构造方法
      public StaticSqlSource(Configuration configuration, String sql, List<ParameterMapping> parameterMappings) {
        
        this.sql = sql;
        this.parameterMappings = parameterMappings;
        this.configuration = configuration;
      }
      
      // 获取BoundSql对象
      @Override
      public BoundSql getBoundSql(Object parameterObject) {
        
        return new BoundSql(configuration, sql, parameterMappings, parameterObject);
      }
    
    }

#### 2. ParameterMapping ####

加载SqlSource时，我们可以看到还加载了ParameterMapping对象，在SqlSource使用集合来封装每个参数的映射关系。

private final List<ParameterMapping> parameterMappings;

采用\#\{var\}的形式来引用变量时，其中的变量会在解析Mapper.xml文件中的语句时就被替换为占位符“?”，同时通过ParameterMapping类记录对应的变量信息。在真正执行对应的语句时会用传递的真实参数根据ParameterMapping信息给PreparedStatement设置参数，具体可参考PreparedStatementHandler的parameterize()方法实现。

由上可知，我们每个\#\{var\}符号，都会产生一个ParameterMapping，我们先看下ParameterMapping源码：

private Configuration configuration;
      // #{}中的属性 user.uid
      private String property;
      // 参数模式 IN
      private ParameterMode mode;
      // 参数类型 java.lang.Object
      private Class<?> javaType = Object.class;
      // JdbcType 数据库数据类型
      private JdbcType jdbcType;
      private Integer numericScale;
      // 类型处理器
      private TypeHandler<?> typeHandler;
      // resultMap的ID
      private String resultMapId;
      // JDBC类型名称
      private String jdbcTypeName;
      // 表达式
      private String expression;
    }

#### 3. 初始化加载SqlSource ####

通过前面，我们可知，SqlSource加载了SQL语句及参数映射关系，执行SQL的时候，根据传入的参数，拼装参数到SQL中，进行数据库操作。

那么SqlSource具体是怎么创建，parameterMappings又是怎么构建的呢。接下来跟踪源码分析下。

SqlSource对象的构建，是在XMLStatementBuilder类中的parseStatementNode执行的。

SqlSource sqlSource = langDriver.createSqlSource(this.configuration, this.context, parameterTypeClass);

首先createSqlSource方法调用的是XMLLanguageDriver（XML语言驱动）进行解析。执行的是XMLScriptBuilder（XML 脚本生成器）的parseScriptNode解析XML节点，创建SqlSource对象。

/**
         * 解析XML及节点
         * @return SqlSource
         */
        public SqlSource parseScriptNode() {
        
            // 1. 解析动态标签, 如果有${}占位符，就会标记为isDynamic=true
            MixedSqlNode rootSqlNode = parseDynamicTags(context);
            SqlSource sqlSource = null;
            if (isDynamic) {
        
                // 2. 有${} 创建 DynamicSqlSource
                sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
            } else {
        
                // 3. 否则创建RawSqlSource 
                sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
            }
            return sqlSource;
        }

因为没有$\{\}标签，所以进入 new RawSqlSource创建SqlSource实例对象，RawSqlSource是静态SqlSource。它比 \{@link DynamicSqlSource\} 快，因为映射是在启动时计算的。

RawSqlSource的构造方法会调用SqlSourceBuilder的parse进行SqlSource实例对象的创建。

/**
       *  SqlSource构造方法
       * @param configuration Configuration
       * @param sql XML中的SQL 带占位符
       * @param parameterType 参数类型
       */
      public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
        
        // 1. 创建 SqlSource 解析器，解析器会添加Configuration、别名注册器、类型处理器
        SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
        // 2. 检查参数类型，如果没有指定，则设置为Object类型
        Class<?> clazz = parameterType == null ? Object.class : parameterType;
        // 3. SqlSource 解析器创建sqlSource
        sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<String, Object>());
      }

然后调用SqlSourceBuilder.parse方法进行处理。

/**
       * SqlSourceBuilder创建 SqlSource对象
       * @param originalSql SELECT
       * 	        *
       *         FROM
       * 	        bsd_account
       * 	    where
       *             bsd_account.status > #{user.uid}
       * @param parameterType class java.lang.Object
       * @param additionalParameters  size = 0 附加参数
       * @return
       */
      public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
        
        // 1. 创建参数隐射处理器、传入configuration、参数类型、附加参数。
        ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
        // 2. 创建#{} 占位符的通用解析器
        GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
        // 3. 通用解析器解析原始SQL，一顿操作，将#{} ，替换为？ ，
        String sql = parser.parse(originalSql);
        // 4. 最终穿件静态的SqlSource返回
        return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
      }

对\#\{\}处理就是GenericTokenParser.parse方法了，他会替换占位符为？，获取占位符中的属性，创建参数映射关系。

/** 解析占位符
         * SELECT
         * 	        *
         *         FROM
         * 	        bsd_account
         * 	    where
         *             bsd_account.status > #{user.uid}
         * @param text
         * @return
         */
        public String parse(String text) {
        
            // 1. 查看是否# { 开头
            if (text == null || text.isEmpty()) {
        
                return "";
            }
            // search open token
            int start = text.indexOf(openToken, 0);
            if (start == -1) {
        
                return text;
            }
            // 2. 原始SQL字符串转为char数组
            char[] src = text.toCharArray();
            int offset = 0;
            final StringBuilder builder = new StringBuilder();
            StringBuilder expression = null;
            while (start > -1) {
        
                if (start > 0 && src[start - 1] == '\\') {
        
                    // this open token is escaped. remove the backslash and continue.
                    builder.append(src, offset, start - offset - 1).append(openToken);
                    offset = start + openToken.length();
                } else {
        
                    // found open token. let's search close token.
                    if (expression == null) {
        
                        expression = new StringBuilder();
                    } else {
        
                        expression.setLength(0);
                    }
                    builder.append(src, offset, start - offset);
                    offset = start + openToken.length();
                    int end = text.indexOf(closeToken, offset);
                    // 3. 获取#{}中配置的属性 赋值给expression
                    while (end > -1) {
        
                        if (end > offset && src[end - 1] == '\\') {
        
                            // this close token is escaped. remove the backslash and continue.
                            expression.append(src, offset, end - offset - 1).append(closeToken);
                            offset = end + closeToken.length();
                            end = text.indexOf(closeToken, offset);
                        } else {
        
                            expression.append(src, offset, end - offset);
                            offset = end + closeToken.length();
                            break;
                        }
                    }
                    if (end == -1) {
        
                        // close token was not found.
                        builder.append(src, start, src.length - start);
                        offset = src.length;
                    } else {
        
                        // SELECT
                      //	        *
                      //        FROM
                      //	        bsd_account
                      //	    where
                      //            bsd_account.status >
                      //
                      // 4. handleToken 会添加？，处理参数映射
                        builder.append(handler.handleToken(expression.toString()));
                        offset = end + closeToken.length();
                    }
                }
                start = text.indexOf(openToken, offset);
            }
            if (offset < src.length) {
        
                builder.append(src, offset, src.length - offset);
            }
            // 5. 返回处理后的SQL
            return builder.toString();
        }

在上述parse方法中，最重要的就是handleToken方法，他用来处理\#\{\}占位符。这里调用的是SqlSourceBuilder.handleToken。

@Override
        public String handleToken(String content) {
        
          // 添加到  List<ParameterMapping>
          parameterMappings.add(buildParameterMapping(content));
          return "?";
        }

构建参数映射关系，调用的是buildParameterMapping方法。

/**
         *  创建 ParameterMapping
         * @param content user.uid => #{}
         * @return
         */
        private ParameterMapping buildParameterMapping(String content) {
        
          // 1. 创建Map  property -> user.uid  处理参数
          Map<String, String> propertiesMap = parseParameterMapping(content);
          String property = propertiesMap.get("property"); // user.uid
          Class<?> propertyType;
          // 2. 获取参数的类型 class java.lang.Object
          if (metaParameters.hasGetter(property)) {
         // issue #448 get type from additional params
            propertyType = metaParameters.getGetterType(property);
          } else if (typeHandlerRegistry.hasTypeHandler(parameterType)) {
        
            propertyType = parameterType;
          } else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) {
        
            propertyType = java.sql.ResultSet.class;
          } else if (property == null || Map.class.isAssignableFrom(parameterType)) {
        
            propertyType = Object.class;
          } else {
        
            MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());
            if (metaClass.hasGetter(property)) {
        
              propertyType = metaClass.getGetterType(property);
            } else {
        
              propertyType = Object.class;
            }
          }
          //  new ParameterMapping.Builder方法创建ParameterMapping
          //         public Builder(Configuration configuration, String property, Class<?> javaType) {
        
          //            this.parameterMapping.configuration = configuration;
          //            this.parameterMapping.property = property; user.uid
          //            this.parameterMapping.javaType = javaType;  class java.lang.Object
          //            this.parameterMapping.mode = ParameterMode.IN;  ParameterMode 参数模式，填充
          //        }
          // 3. Builder构建ParameterMapping
          ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, propertyType);
          Class<?> javaType = propertyType;
          String typeHandlerAlias = null;
          // 4. 循环  property -> user.uid
          for (Map.Entry<String, String> entry : propertiesMap.entrySet()) {
        
            String name = entry.getKey();  // property
            String value = entry.getValue(); // user.uid
            // 5. 构建属性
            if ("javaType".equals(name)) {
        
              javaType = resolveClass(value);
              builder.javaType(javaType);
            } else if ("jdbcType".equals(name)) {
        
              builder.jdbcType(resolveJdbcType(value));
            } else if ("mode".equals(name)) {
        
              builder.mode(resolveParameterMode(value));
            } else if ("numericScale".equals(name)) {
        
              builder.numericScale(Integer.valueOf(value));
            } else if ("resultMap".equals(name)) {
        
              builder.resultMapId(value);
            } else if ("typeHandler".equals(name)) {
        
              typeHandlerAlias = value;
            } else if ("jdbcTypeName".equals(name)) {
        
              builder.jdbcTypeName(value);
            } else if ("property".equals(name)) {
        
              // Do Nothing
            } else if ("expression".equals(name)) {
        
              throw new BuilderException("Expression based parameters are not supported yet");
            } else {
        
              throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content + "}.  Valid properties are " + parameterProperties);
            }
          }
          if (typeHandlerAlias != null) {
        
            builder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));
          }
          // 6. 返回 ParameterMapping{property='user.uid', mode=IN, javaType=class java.lang.Object, jdbcType=null, numericScale=null, resultMapId='null', jdbcTypeName='null', expression='null'}
          return builder.build();
        }

最终根据处理都的SQL，参数映射关系，new了一个StaticSqlSource，最终的SqlSource就构建完成了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 2]

SqlSource最后被添加到了对应的MappedStatement中，在进行SQL操作时，会直接获取到mapper方法的SqlSource进行语句参数处理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 3]

#### 4. 创建boundSql ####

执行SQL方法时，获取sqlSession，创建执行器，创建ParameterHandler，创建StatementHandler时，构造方法进入BaseStatementHandler，参数处理器、boundSql都是在构造方法中创建的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 4]

之前说过SqlSource提供了getBoundSql方法，所以boundSql的创建是由SqlSource实例对象创建的。直接调用BoundSql的构造方法，传入带？好的SQL、参数隐射关系、用户输入的参数。  
![在这里插入图片描述][baa944c552e74741aa5767790907f753.png]

可以看到BoundSql对象中封装了SQL语句执行所需要的相关信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 5]

#### 5. 创建参数处理器 ####

BaseStatementHandler构造创建了boundSql之后，就开始执行创建参数处理器了。

下一步进入Configuration对象的newParameterHandler方法，首先会调用DefaultParameterHandler的构造方法，将相关配置，SQL信息设置到对象中，返回ParameterHandler。

public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        
            this.mappedStatement = mappedStatement;
            this.configuration = mappedStatement.getConfiguration();
            this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
            this.parameterObject = parameterObject;
            this.boundSql = boundSql;
        }

![在这里插入图片描述][20210628102842726.png]  
返回后，也使用了拦截器对其进行包装处理。

parameterHandler = (ParameterHandler)this.interceptorChain.pluginAll(parameterHandler);

#### 3. 参数处理 ####

在执行器进行创建Statement时，会调用StatementHandler 处理器的parameterize方法对参数进行处理。

// 准备语句
        private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        
            Statement stmt;
            Connection connection = getConnection(statementLog);
            // 调用StatementHandler.prepare
            stmt = handler.prepare(connection, transaction.getTimeout());
            // 调用StatementHandler.parameterize
            handler.parameterize(stmt);
            return stmt;
        }

参数处理最终调用的是DefaultParameterHandler中的setParameters方法。

//设置参数
        @Override
        public void setParameters(PreparedStatement ps) {
        
            ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
            List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
            if (parameterMappings != null) {
        
                //设置参数
                for (int i = 0; i < parameterMappings.size(); i++) {
        
                    //循环设参数
                    ParameterMapping parameterMapping = parameterMappings.get(i);
                    //如果不是OUT，才设进去
                    if (parameterMapping.getMode() != ParameterMode.OUT) {
        
                        Object value;
                        String propertyName = parameterMapping.getProperty();
                        //若有额外的参数, 设为额外的参数
                        if (boundSql.hasAdditionalParameter(propertyName)) {
         // issue #448 ask first for additional params
                            value = boundSql.getAdditionalParameter(propertyName);
                        } else if (parameterObject == null) {
        
                            //若参数为null，直接设null
                            value = null;
                        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
        
                            //若参数有相应的TypeHandler，直接设object
                            value = parameterObject;
                        } else {
        
                            //除此以外，MetaObject.getValue反射取得值设进去
                            MetaObject metaObject = configuration.newMetaObject(parameterObject);
                            value = metaObject.getValue(propertyName);
                        }
                        TypeHandler typeHandler = parameterMapping.getTypeHandler();
                        JdbcType jdbcType = parameterMapping.getJdbcType();
                        if (value == null && jdbcType == null) {
        
                            //不同类型的set方法不同，所以委派给子类的setParameter方法
                            jdbcType = configuration.getJdbcTypeForNull();
                        }
                        try {
        
                            typeHandler.setParameter(ps, i + 1, value, jdbcType);
                        } catch (TypeException e) {
        
                            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                        } catch (SQLException e) {
        
                            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                        }
                    }
                }
            }
        }
    }

#### 4. 返回 ####

处理完成后，在Statement执行对象中，就生成了对应的完成SQL语句了，接下来继续执行查询，就完成了CRUD操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 6]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210628100200788.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[6a197cf0efca44b59a7f81791f55fcd2.png]: https://img-blog.csdnimg.cn/6a197cf0efca44b59a7f81791f55fcd2.png
[20210628100456827.png]: https://img-blog.csdnimg.cn/20210628100456827.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/032b305d61214b2ead400f8289d612d0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/a5aaee2344534c4e8ddbc6a010802822.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/53707ba2046c43d3a19d37a64f55fdd7.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/cce070ea08b94d20b5fa704e44b33ab2.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[baa944c552e74741aa5767790907f753.png]: https://img-blog.csdnimg.cn/baa944c552e74741aa5767790907f753.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/36cedc4d3439483bbc50c0a44edfc5a2.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[20210628102842726.png]: https://img-blog.csdnimg.cn/20210628102842726.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210628103911631.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70