彬_708c
彬_708c

Mybatis-Mapper各类标签封装类源码解析

Mybatis3.5.1源码分析

  1. Mybatis-SqlSessionFactoryBuilder，XMLConfigBuilder，XPathParser源码解析
  2. Mybatis-Configuration源码解析
  3. Mybatis-事务对象源码解析
  4. Mybatis-数据源源码解析
  5. Mybatis缓存策略源码解析
  6. Mybatis-DatabaseIdProvider源码解析
  7. Mybatis-TypeHandler源码解析
  8. Mybatis-Reflector源码解析
  9. Mybatis-ObjectFactory，ObjectWrapperFactory源码分析
  10. Mybatis-Mapper各类标签封装类源码解析
  11. Mybatis-XMLMapperBuilder,XMLStatmentBuilder源码分析
  12. Mybatis-MapperAnnotationBuilder源码分析
  13. [Mybatis-MetaObject,MetaClass源码解析]https://www.jianshu.com/p/f51fa552f30a)
  14. Mybatis-LanguageDriver源码解析
  15. Mybatis-SqlSource源码解析
  16. Mybatis-SqlNode源码解析
  17. Mybatis-KeyGenerator源码解析
  18. Mybatis-Executor源码解析
  19. Mybatis-ParameterHandler源码解析
  20. Mybatis-StatementHandler源码解析
  21. Mybatis-DefaultResultSetHandler(一)源码解析
  22. Mybatis-DefaultResultSetHandler(二)源码解析
  23. Mybatis-ResultHandler,Cursor,RowBounds 源码分析
  24. Mybatis-MapperProxy源码解析
  25. Mybatis-SqlSession源码解析
  26. Mybatis-Interceptor源码解析

ParameterMap

/**
 *    Copyright 2009-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.mapping;

import java.util.Collections;
import java.util.List;

import org.apache.ibatis.session.Configuration;

/**
 * 参数映射信息封装类，Mapper.xml的parameterMap标签
 * @author Clinton Begin
 */
public class ParameterMap {

  /**
   * ParameterMap标签的ID属性
   */
  private String id;

  /**
   * ParamterMap标签的type属性，即参数类型
   */
  private Class type;

  /**
   * ParamterMap标签的所有paramter标签，即参数的所有属性列表
   */
  private List parameterMappings;

  private ParameterMap() {
  }

  /**
   * ParameterMap的构造器
   */
  public static class Builder {
    private ParameterMap parameterMap = new ParameterMap();

    /**
     *
     * @param configuration 这个参数已经不用了，很有可能后面的版本去掉
     * @param id ParameterMap标签的ID属性
     * @param type ParamterMap标签的type属性，即参数类型
     * @param parameterMappings ParamterMap标签的所有paramter标签，即参数的所有属性列表
     */
    public Builder(Configuration configuration, String id, Class type, List parameterMappings) {
      parameterMap.id = id;
      parameterMap.type = type;
      parameterMap.parameterMappings = parameterMappings;
    }

    /**
     * 返回参数类型
     */
    public Class type() {
      return parameterMap.type;
    }

    public ParameterMap build() {
      //lock down collections 锁定集合
      /**
       *  Collections.unmodifiableList方法会将传进来的集合变成只读的集合，
       *  只要改变该集合都会抛出UnsupportedOperationException。
       *  总之，可以保证对象的list内容不被意料之外地修改，保证对象的封装性
       */
      parameterMap.parameterMappings = Collections.unmodifiableList(parameterMap.parameterMappings);
      return parameterMap;
    }
  }

  public String getId() {
    return id;
  }

  public Class getType() {
    return type;
  }

  public List getParameterMappings() {
    return parameterMappings;
  }

}

ParameterMapping

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.mapping;

import java.sql.ResultSet;

import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;

/**
 * 参数映射
 * 

 *     对应于Mapper.xml的：
 *     <parameter property="" resultMap="" javaType="" typeHandler="" jdbcType="" mode="" scale=""></parameter>
 * 

 * 

 *     参考博客：https://blog.csdn.net/L_Sail/article/details/73824674
 * 

 * @author Clinton Begin
 */
public class ParameterMapping {

  private Configuration configuration;

  /**
   * 属性名
   */
  private String property;

  /**
   * mode 属性允许你指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，
   * 参数对象属性的真实值将会被改变，就像你在获取输出参数时所期望的那样。
   * 如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR(也就是 Oracle 的 REFCURSOR)，
   * 必须指定一个 resultMap 来映射结果集到参数类型
   */
  private ParameterMode mode;

  /**
   * java类型
   */
  private Class javaType = Object.class;

  /**
   * jdbc类型
   */
  private JdbcType jdbcType;

  /**
   * 小数点后保留的位数
   */
  private Integer numericScale;

  /**
   * 类型处理器
   */
  private TypeHandler typeHandler;

  /**
   * 结果映射ID
   */
  private String resultMapId;

  /**
   * jdbc类型名， SQL 结构类型的完全限定名称
   * 

   *     作用于CallableStatement.registerOutParameter (int parameterIndex, int sqlType, String typeName)方法的
   *     typeName参数:

   *     在执行存储过程调用之前，必须显式调用 registerOutParameter 为每个 OUT 参数注册来自 java.sql.Types 的类型。
   *     对于用户定义的参数，还应该提供该参数的完全限定 SQL 类型名称，而 REF 参数则要求提供所引用类型的完全限定类型名称。
   *     不需要类型代码和类型名称信息的 JDBC 驱动程序可以忽略它。不过，为了便于移植，应用程序应该为用户定义的参数和 REF 参数提供这些值。
   * 

   */
  private String jdbcTypeName;

  /**
   * 表达式
   */
  private String expression;

  private ParameterMapping() {
  }

  public static class Builder {
    private ParameterMapping parameterMapping = new ParameterMapping();

    /**
     *
     * @param configuration mybatis的配置信息类
     * @param property 属性名
     * @param typeHandler 属性类型处理器
     */
    public Builder(Configuration configuration, String property, TypeHandler typeHandler) {
      parameterMapping.configuration = configuration;
      parameterMapping.property = property;
      parameterMapping.typeHandler = typeHandler;
      parameterMapping.mode = ParameterMode.IN;
    }

    /**
     *
     * @param configuration mybatis的配置信息类
     * @param property 属性名
     * @param javaType 属性类型
     */
    public Builder(Configuration configuration, String property, Class javaType) {
      parameterMapping.configuration = configuration;
      parameterMapping.property = property;
      parameterMapping.javaType = javaType;
      parameterMapping.mode = ParameterMode.IN;
    }

    /**
     * mode 属性允许你指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像你在获取输出参数时所期望的那样。
     * 如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR(也就是 Oracle 的 REFCURSOR)，你必须指定一个 resultMap 来映射结果集到参数类型
     */
    public Builder mode(ParameterMode mode) {
      parameterMapping.mode = mode;
      return this;
    }

    /**
     * 属性类型
     */
    public Builder javaType(Class javaType) {
      parameterMapping.javaType = javaType;
      return this;
    }

    /**
     * 属性的jdbcType
     */
    public Builder jdbcType(JdbcType jdbcType) {
      parameterMapping.jdbcType = jdbcType;
      return this;
    }

    /**
     * 参数的属性的小数点保留的位数
     */
    public Builder numericScale(Integer numericScale) {
      parameterMapping.numericScale = numericScale;
      return this;
    }

    /**
     * 参数的属性对应的结果映射ID
     */
    public Builder resultMapId(String resultMapId) {
      parameterMapping.resultMapId = resultMapId;
      return this;
    }

    /**
     * 参数的属性对应的TypeHandler
     */
    public Builder typeHandler(TypeHandler typeHandler) {
      parameterMapping.typeHandler = typeHandler;
      return this;
    }

    /**
     * 参数的属性对应的jdbcType名
     */
    public Builder jdbcTypeName(String jdbcTypeName) {
      parameterMapping.jdbcTypeName = jdbcTypeName;
      return this;
    }

    /**
     * 参数的属性正则表达式
     */
    public Builder expression(String expression) {
      parameterMapping.expression = expression;
      return this;
    }

    /**
     * 构建ParameterMapping
     * 

     *     在调用其ParameterMapping.Builder的构造方法时，就已经构建了parameterMapping。
     *     而方法时就是返回这个paramterMapping，在返回之前，会检查有没有设置TypeHandler，没有的
     *     话，会尝试根据javaType从TypeHandler注册器中获取对应javaType的TypeHandler实例.
     *     然后 检查一下业务需求所需要的属性是否缺漏,缺漏的抛出异常。如
     * 

     * 
    
     *     
  1. 如果是javaType为ResultSet的时候，需要设置resultMapId属性，因为需要根据resultMap来映射获取数据。
     *        否则抛出异常
    2. 
     *     
  2.  如果是javaType为其他类型是，必须要有对应其类型的typeHandler的实例。否则抛出异常
    3. 
     * 

     */
    public ParameterMapping build() {
      //解析获取TypeHandler实例
      resolveTypeHandler();
      // 检查一下业务需求所需要的属性是否缺漏,缺漏的抛出异常
      validate();
      return parameterMapping;
    }

    /**
     * 检查一下业务需求所需要的属性是否缺漏
     * 

     *     如果是javaType为ResultSet的时候，需要设置resultMapId属性，因为需要根据resultMap来映射获取数据。
     *     否则抛出异常
     * 

     * 

     *     如果是javaType为其他类型是，必须要有对应其类型的typeHandler的实例。否则抛出异常
     * 

     */
    private void validate() {
      //当jdbcType为JdbcType.CURSOR是，javaType就会是ResultSet
      if (ResultSet.class.equals(parameterMapping.javaType)) {
        //如果是ResultSet就必须要有resultMapId，因为需要根据resultMap来映射获取数据。
        if (parameterMapping.resultMapId == null) {
          throw new IllegalStateException("Missing resultmap in property '"
              + parameterMapping.property + "'.  "
              + "Parameters of type java.sql.ResultSet require a resultmap.");
        }
      } else {
        //javaType为其他类型时，必须要有对应其类型的typeHandler的实例。
        if (parameterMapping.typeHandler == null) {
          throw new IllegalStateException("Type handler was null on parameter mapping for property '"
            + parameterMapping.property + "'. It was either not specified and/or could not be found for the javaType ("
            + parameterMapping.javaType.getName() + ") : jdbcType (" + parameterMapping.jdbcType + ") combination.");
        }
      }
    }

    /**
     * 解析获取TypeHandler实例
     * 

     *     在typeHandler为null且有javaType的情况下才会尝试从TypeHandler注册器获取对应的TypeHandler实例
     * 

     */
    private void resolveTypeHandler() {
      if (parameterMapping.typeHandler == null && parameterMapping.javaType != null) {
        Configuration configuration = parameterMapping.configuration;
        TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        //只是获取typeHandler，没有注册
        parameterMapping.typeHandler = typeHandlerRegistry.getTypeHandler(parameterMapping.javaType, parameterMapping.jdbcType);
      }
    }

  }

  public String getProperty() {
    return property;
  }

  /**
   * Used for handling output of callable statements.
   * @return
   */
  public ParameterMode getMode() {
    return mode;
  }

  /**
   * Used for handling output of callable statements.
   * @return
   */
  public Class getJavaType() {
    return javaType;
  }

  /**
   * Used in the UnknownTypeHandler in case there is no handler for the property type.
   * @return
   */
  public JdbcType getJdbcType() {
    return jdbcType;
  }

  /**
   * Used for handling output of callable statements.
   * @return
   */
  public Integer getNumericScale() {
    return numericScale;
  }

  /**
   * Used when setting parameters to the PreparedStatement.
   * @return
   */
  public TypeHandler getTypeHandler() {
    return typeHandler;
  }

  /**
   * Used for handling output of callable statements.
   * @return
   */
  public String getResultMapId() {
    return resultMapId;
  }

  /**
   * Used for handling output of callable statements.
   * @return
   */
  public String getJdbcTypeName() {
    return jdbcTypeName;
  }

  /**
   * Not used
   * @return
   */
  public String getExpression() {
    return expression;
  }

  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder("ParameterMapping{");
    //sb.append("configuration=").append(configuration); // configuration doesn't have a useful .toString()
    sb.append("property='").append(property).append('\'');
    sb.append(", mode=").append(mode);
    sb.append(", javaType=").append(javaType);
    sb.append(", jdbcType=").append(jdbcType);
    sb.append(", numericScale=").append(numericScale);
    //sb.append(", typeHandler=").append(typeHandler); // typeHandler also doesn't have a useful .toString()
    sb.append(", resultMapId='").append(resultMapId).append('\'');
    sb.append(", jdbcTypeName='").append(jdbcTypeName).append('\'');
    sb.append(", expression='").append(expression).append('\'');
    sb.append('}');
    return sb.toString();
  }
}

ResultMap

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.mapping;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.builder.BuilderException;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.reflection.ParamNameUtil;
import org.apache.ibatis.session.Configuration;

/**
 * 结果映射信息封装类，Mapper.xml的resultMap标签信息封装类对象
 * @author Clinton Begin
 */
public class ResultMap {
  private Configuration configuration;

  /**
   * resultMap标签的Id属性
   */
  private String id;
  /**
   * resultMap标签的type属性，resultMap的java类型
   */
  private Class type;
  /**
   * 结果映射
   */
  private List resultMappings;
  /**
   * id结果映射
   */
  private List idResultMappings;
  /**
   * 构造函数结果映射,
   * 

   *     存放着带有构造函数标记ResultFlag.CONSTRUCTOR的resultMapping
   * 

   */
  private List constructorResultMappings;
  /**
   * 属性结果映射。
   * 
将没有构造函数标记ResultFalg.CONSTRUCTOR的resultMapping添加到propertyResultMapping,
   * 没有构造函数标记ResultFalg.CONSTRUCTOR的resultMapping其实可以认为就是resultMap标签
   * 下的result标签和id标签

   */
  private List propertyResultMappings;
  /**
   * 映射列
   * 

   *     {@link #resultMappings}的所有column属性集合，包括嵌套的reusltMapping的column，
   *     所保存的列是以大写形式保存
   * 

   */
  private Set mappedColumns;
  /**
   * 映射属性，存放着所有resultMapping的所有propery
   */
  private Set mappedProperties;
  /**
   * 鉴别器
   */
  private Discriminator discriminator;
  /**
   * 有嵌套映射结果，判断reusltMapping中有没有设置嵌套的 resultMap id
   */
  private boolean hasNestedResultMaps;
  /**
   * 有嵌套查询，判断reusltMapping中有没有设置select属性
   */
  private boolean hasNestedQueries;
  /**
   * 自动映射
   */
  private Boolean autoMapping;

  private ResultMap() {
  }

  public static class Builder {
    private static final Log log = LogFactory.getLog(Builder.class);

    private ResultMap resultMap = new ResultMap();

    /**
     *
     * @param configuration mybatis全局配置
     * @param id resultMap标签的ID属性
     * @param type resultMap标签的type属性，resultMap的java类型
     * @param resultMappings 结果元素映射集合
     */
    public Builder(Configuration configuration, String id, Class type, List resultMappings) {
      this(configuration, id, type, resultMappings, null);
    }

    /**
     *
     * @param configuration mybatis全局配置
     * @param id resultMap标签的ID属性
     * @param type resultMap标签的type属性，resultMap的java类型
     * @param resultMappings 结果元素映射集合
     * @param autoMapping 自动映射
     */
    public Builder(Configuration configuration, String id, Class type, List resultMappings, Boolean autoMapping) {
      resultMap.configuration = configuration;
      resultMap.id = id;
      resultMap.type = type;
      resultMap.resultMappings = resultMappings;
      resultMap.autoMapping = autoMapping;
    }

    /**
     * 鉴别器
     * @param discriminator 鉴别器
     * @return
     */
    public Builder discriminator(Discriminator discriminator) {
      resultMap.discriminator = discriminator;
      return this;
    }

    /**
     * 返回resultMap的java类型
     * @return {@link #resultMap#type}
     */
    public Class type() {
      return resultMap.type;
    }

    /**
     * 构建resultMap
     *
     */
    public ResultMap build() {
      //验证Id，Id是找到这个reusltMap的关键，不可以没有。
      if (resultMap.id == null) {
        throw new IllegalArgumentException("ResultMaps must have an id");
      }
      //给定下面属性一个空集合实例
      resultMap.mappedColumns = new HashSet<>();
      resultMap.mappedProperties = new HashSet<>();
      resultMap.idResultMappings = new ArrayList<>();
      resultMap.constructorResultMappings = new ArrayList<>();
      resultMap.propertyResultMappings = new ArrayList<>();
      //存放着带有构造函数标记的ResultMapping的property
      final List constructorArgNames = new ArrayList<>();
      for (ResultMapping resultMapping : resultMap.resultMappings) {
        //有嵌套查询标记更新
        resultMap.hasNestedQueries = resultMap.hasNestedQueries || resultMapping.getNestedQueryId() != null;
        //有嵌套ResultMap更新
        resultMap.hasNestedResultMaps = resultMap.hasNestedResultMaps || (resultMapping.getNestedResultMapId() != null && resultMapping.getResultSet() == null);
        /**
         * 将column添加到ResultMap.mappedColumn列表中，这个reusltMapping是个组合的reusltMapping，
         * 也会将组合的reusltMapping的column添加上去
         */
        final String column = resultMapping.getColumn();
        if (column != null) {
          resultMap.mappedColumns.add(column.toUpperCase(Locale.ENGLISH));
        } else if (resultMapping.isCompositeResult()) {
          for (ResultMapping compositeResultMapping : resultMapping.getComposites()) {
            final String compositeColumn = compositeResultMapping.getColumn();
            if (compositeColumn != null) {
              resultMap.mappedColumns.add(compositeColumn.toUpperCase(Locale.ENGLISH));
            }
          }
        }
        //将resultMapping的property添加到mappedProperties
        final String property = resultMapping.getProperty();
        if (property != null) {
          resultMap.mappedProperties.add(property);
        }
        //将带有构造函数标记ResultFlag.CONSTRUCTOR的resultMapping添加到constructorResultMapping
        if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
          resultMap.constructorResultMappings.add(resultMapping);
          //添加带有构造函数标记ResultFlag.CONSTRUCTOR的resultMapping的property
          if (resultMapping.getProperty() != null) {
            constructorArgNames.add(resultMapping.getProperty());
          }
        } else {
          /**
           *将没有构造函数标记ResultFalg.CONSTRUCTOR的resultMapping添加到propertyResultMapping,
           *  没有构造函数标记ResultFalg.CONSTRUCTOR的resultMapping其实可以认为就是resultMap标签
           *  下的result标签和id标签
           */
          resultMap.propertyResultMappings.add(resultMapping);
        }
        //将带有ID标记ResultFlag.ID的resultMapping添加的idResultMapping
        if (resultMapping.getFlags().contains(ResultFlag.ID)) {
          resultMap.idResultMappings.add(resultMapping);
        }
      }
      //TODO 为啥在没有获取到带有ID标记ResultFlag.ID的resultMapping时就添加所有resultMaping？
      if (resultMap.idResultMappings.isEmpty()) {
        resultMap.idResultMappings.addAll(resultMap.resultMappings);
      }

      if (!constructorArgNames.isEmpty()) {
        /**
         * 获取对应construtorArgNames的构造函数的参数名列表，这里忽略constructorArgNames的元素顺序是否和
         * 对应的构造函数的参数顺序对应，只对应他们的类型和参数名
         */
        final List actualArgNames = argNamesOfMatchingConstructor(constructorArgNames);
        /**
         * 这个异常触发条件我觉得会很容易触发的。
         * 1.在如果在mybatis-config.xml文件中设置了useActualParamName为false的时候，resultMap对应的
         * java类型的构造函数的参数又没有加上@param注解时，就会导致和constructorArgNames匹配不上。
         */
        if (actualArgNames == null) {
          throw new BuilderException("Error in result map '" + resultMap.id
              + "'. Failed to find a constructor in '"
              + resultMap.getType().getName() + "' by arg names " + constructorArgNames
              + ". There might be more info in debug log.");
        }
        //让constructorResultMapping根据构造函数的参数名列表actualArgNames进行排序。
        resultMap.constructorResultMappings.sort((o1, o2) -> {
          int paramIdx1 = actualArgNames.indexOf(o1.getProperty());
          int paramIdx2 = actualArgNames.indexOf(o2.getProperty());
          return paramIdx1 - paramIdx2;
        });
      }
      // lock down collections
      resultMap.resultMappings = Collections.unmodifiableList(resultMap.resultMappings);
      resultMap.idResultMappings = Collections.unmodifiableList(resultMap.idResultMappings);
      resultMap.constructorResultMappings = Collections.unmodifiableList(resultMap.constructorResultMappings);
      resultMap.propertyResultMappings = Collections.unmodifiableList(resultMap.propertyResultMappings);
      resultMap.mappedColumns = Collections.unmodifiableSet(resultMap.mappedColumns);
      return resultMap;
    }

    /**
     * 匹配构造函数的参数名称
     * @param constructorArgNames 带有构造函数标记的ResultMapping的property集合
     * @return 返回已经匹配验证成功的构造函数的参数名称，在匹配验证不成功的时候会返回null
     */
    private List argNamesOfMatchingConstructor(List constructorArgNames) {
      Constructor[] constructors = resultMap.type.getDeclaredConstructors();
      for (Constructor constructor : constructors) {
        Class[] paramTypes = constructor.getParameterTypes();
        if (constructorArgNames.size() == paramTypes.length) {
          List paramNames = getArgNames(constructor);
          /**
           * paramNames有可能返回args0,args1...,这个时候containsAll返回false，使得整个方法返回null。
           * 这里argTypesMatch方法并不会接收到paramNames为args0,args1...的情况，因为这里这里使用'&&',
           * 在containAll返回false的时候，是不会执行argTypesMatch方法。
           */
          if (constructorArgNames.containsAll(paramNames)
              && argTypesMatch(constructorArgNames, paramTypes, paramNames)) {
            return paramNames;
          }
        }
      }
      return null;
    }

    /**
     * 匹配构造函数的参数类型
     * @param constructorArgNames 带有构造函数标记的ResultMapping的property集合
     * @param paramTypes 构造函数的所有参数的类型
     * @param paramNames 构造函数的所有参数的参数名
     * @return 在 {@link #resultMap#constructorResultMappings} 的所有javaType与
     *    paramTypes取得的类型在类型上都相等的情况下就会返回true
     */
    private boolean argTypesMatch(final List constructorArgNames,
        Class[] paramTypes, List paramNames) {
      for (int i = 0; i < constructorArgNames.size(); i++) {
        /**
         * 从constructorArgNames获取i位置的property，再从paramNames获取property对应的位置，
         * 再从paramTypes取得该位置对应的类型
         */
        Class actualType = paramTypes[paramNames.indexOf(constructorArgNames.get(i))];
        //从构造函数ResultMapping中获取i位置的ResultMapping的javaType
        Class specifiedType = resultMap.constructorResultMappings.get(i).getJavaType();
        /**
         * 这里判断不对应的情况下是不会抛出异常，只会打印log，并返回false，之所以没有抛出异常时是因为
         * 统一交给了build方法抛出异常，这里只是简单的调用Class#equal方法，Class并没有对
         * equal方法进行重写，所以equal方法相当于'=='的判断结果，也就是说这里没有考虑到父子类的情况。
         *
         * 这里不存在因为顺序不一致而导致不相等的情况，因为actualType的通过constructorArgNames的位置获取的，
         * 而constructorArgNames和resultMap.constructorResultMappings同一个循环遍历下填充元素的，所以
         * constructorArgNames和resultMap.constructorResultMappings的元素位置是一致的。
         */
        if (!actualType.equals(specifiedType)) {
          if (log.isDebugEnabled()) {
            log.debug("While building result map '" + resultMap.id
                + "', found a constructor with arg names " + constructorArgNames
                + ", but the type of '" + constructorArgNames.get(i)
                + "' did not match. Specified: [" + specifiedType.getName() + "] Declared: ["
                + actualType.getName() + "]");
          }
          return false;
        }
      }
      return true;
    }

    /**
     * 获取构造函数的参数名
     * @param constructor {@link #type} 的构造函数
     * @return
     * 
    
     *    
  1. 尝试获取 {@code constructor} 的参数的 {@link Param} 作为参数名。
    2. 
     *    
  2. 在开启了 {@link #configuration#useActualParamName} 情况下，尝试获取 {@code constructor} 的参数名作为参数名
    3. 
     *    
  3. 最后方案:用"arg" + 参数索引作为参数名
    4. 
     * 

     */
    private List getArgNames(Constructor constructor) {
      List paramNames = new ArrayList<>();
      List actualParamNames = null;
      //获取constructor每个参数的注解
      final Annotation[][] paramAnnotations = constructor.getParameterAnnotations();
      int paramCount = paramAnnotations.length;
      for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
        String name = null;
        //找到@Param注解并把其value赋给name
        for (Annotation annotation : paramAnnotations[paramIndex]) {
          if (annotation instanceof Param) {
            name = ((Param) annotation).value();
            break;
          }
        }
        //在开启了configuration#useActualParamName情况下，会使用在构造函数的参数名赋值给name
        if (name == null && resultMap.configuration.isUseActualParamName()) {
          if (actualParamNames == null) {
            actualParamNames = ParamNameUtil.getParamNames(constructor);
          }
          //要保证构造函数的参数名数量是大于参数索引paramIndex，否则在获取参数名时会抛出异常
          if (actualParamNames.size() > paramIndex) {
            name = actualParamNames.get(paramIndex);
          }
        }
        /**
         * 1，在仍然获取不到name的情况下，会以'arg'+paramIndex 作为name
         * 2.添加到paramNames
         */
        paramNames.add(name != null ? name : "arg" + paramIndex);
      }
      return paramNames;
    }
  }

  public String getId() {
    return id;
  }

  public boolean hasNestedResultMaps() {
    return hasNestedResultMaps;
  }

  public boolean hasNestedQueries() {
    return hasNestedQueries;
  }

  public Class getType() {
    return type;
  }

  public List getResultMappings() {
    return resultMappings;
  }

  public List getConstructorResultMappings() {
    return constructorResultMappings;
  }

  public List getPropertyResultMappings() {
    return propertyResultMappings;
  }

  public List getIdResultMappings() {
    return idResultMappings;
  }

  public Set getMappedColumns() {
    return mappedColumns;
  }

  public Set getMappedProperties() {
    return mappedProperties;
  }

  public Discriminator getDiscriminator() {
    return discriminator;
  }

  public void forceNestedResultMaps() {
    hasNestedResultMaps = true;
  }

  public Boolean getAutoMapping() {
    return autoMapping;
  }

}

Discriminator

/**
 *    Copyright 2009-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.mapping;

import java.util.Collections;
import java.util.Map;

import org.apache.ibatis.session.Configuration;

/**
 * 鉴别器
 * 用于对一个查询可能出现的不同结果集做鉴别,根据具体的条件为 resultMap 动态选择返回值类型。
 * 

 *     eg:

 *     <discriminator javaType="int" column="type">

 *          <case value="1" resultType="Apple"/>

 *          <case value="2" resultType="Banana"/>

 *     <discriminator/>
 * 

 *
 * 

 *     参考博客：https://blog.csdn.net/weixin_36210698/article/details/83508113
 * 

 * @author Clinton Begin
 */
public class Discriminator {

  /**
   * ResutMap标签的属性标签封装
   */
  private ResultMapping resultMapping;
  /**
   * case标签信息封装，映射
   * 

   *     key=case标签的value属性，value=命名空间+case标签的resultMap属性(reusltMapId)，
   * 

   */
  private Map discriminatorMap;

  Discriminator() {
  }

  public static class Builder {
    private Discriminator discriminator = new Discriminator();

    public Builder(Configuration configuration, ResultMapping resultMapping, Map discriminatorMap) {
      discriminator.resultMapping = resultMapping;
      discriminator.discriminatorMap = discriminatorMap;
    }

    public Discriminator build() {
      assert discriminator.resultMapping != null;
      assert discriminator.discriminatorMap != null;
      assert !discriminator.discriminatorMap.isEmpty();
      //lock down map
      discriminator.discriminatorMap = Collections.unmodifiableMap(discriminator.discriminatorMap);
      return discriminator;
    }
  }

  public ResultMapping getResultMapping() {
    return resultMapping;
  }

  public Map getDiscriminatorMap() {
    return discriminatorMap;
  }

  public String getMapIdFor(String s) {
    return discriminatorMap.get(s);
  }

}

MappedStatement

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.mapping;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.executor.keygen.Jdbc3KeyGenerator;
import org.apache.ibatis.executor.keygen.KeyGenerator;
import org.apache.ibatis.executor.keygen.NoKeyGenerator;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.scripting.LanguageDriver;
import org.apache.ibatis.session.Configuration;

/**
 * 

 *     Mapper.xml文件的select,delete,update,insert这些DML标签的封装类
 * 

 * 

 * MappedStatement类在Mybatis框架中用于表示XML文件中一个sql语句节点，
 * 即一个、或者标签。Mybatis框架在初始化阶段会对XML配置文件进行读取
 * ，将其中的sql语句节点对象化为一个个MappedStatement对象。
 * 

 * @author Clinton Begin
 */
public final class MappedStatement {


  /**
   * 资源路径，当前项目，有可能是java文件也有可能是.xml文件
   */
  private String resource;
  /**
   * mybatis全局配置信息
   */
  private Configuration configuration;
  /**
   * 节点中的id属性加要命名空间
   */
  private String id;
  /**
   * 
select标签的fetchSize属性

   * 

   * 

   *     这是尝试影响驱动程序每次批量返回的结果行数和这个设置值相等。默认值为 unset（依赖驱动）。
   * 

   * 

   * 

   *     假设fetchSize为5，查询总记录数为100，每批5次返回给你，最后结果还是总记录数，只是提高点查询的速度而已
   * 

   * 

   * 

   *     MySQL不支持fetchSize，默认为一次性取出所有数据。所以容易导致OOM，
   *     如果是Oracle的话就是默认取出fetchSize条数据。
   *     裸露JDBC防止OOM可以调用statement的enableStreamingResults方法,
   *     MyBatis应该在<select fetchSize="-2147483648">。
   * 

   */
  private Integer fetchSize;
  /**
   * 这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。
   * 默认值为 unset（依赖驱动）。
   */
  private Integer timeout;
  /**
   * 
    
   *     
  1. STATEMENT:对应于Statement对象，有SQL注入的风险
    2. 
   *     
  2. PREPARED:PreparedStatement，预编译处理
    3. 
   *     
  3. CALLABLE:CallableStatement一般调用存储过程的时候使用
    4. 
   * 

   * 默认是PREPARED
   */
  private StatementType statementType;
  /**
   *  其实的就是{@link java.sql.ResultSet}的常量，只不过Mybatis对其常量进行封装成枚举。
   * 
    
   *     
  1. DEFAULT:依赖驱动
    2. 
   *     
  2. FORWARD_ONLY:结果集的游标只能向下滚动
    3. 
   *     
  3. SCROLL_INSENSITIVE:结果集的游标可以上下移动，当数据库变化时，当前结果集不变
    4. 
   *     
  4. SCROLL_SENSITIVE:返回可滚动的结果集，当数据库变化时，当前结果集同步改变
    5. 
   * 

   */
  private ResultSetType resultSetType;
  /**
   *  构建动态SQL
   */
  private SqlSource sqlSource;
  /**
   * 每条语句都对就一个缓存，如果有的话
   */
  private Cache cache;
  /**
   * 参数映射信息封装类，Mapper.xml的parameterMap标签
   */
  private ParameterMap parameterMap;
  /**
   * 结果映射信息封装类，Mapper.xml的resultMap标签 集合
   */
  private List resultMaps;
  /**
   * 需要刷新缓存标记
   * 

   *      如果配置了flushCacheRequired为true，则会在执行器执行之前就清空本地一级缓存，换句话说就是关闭一级缓存功能
   * 

   */
  private boolean flushCacheRequired;
  /**
   * 启用缓存标记
   */
  private boolean useCache;
  /**
   * select标签
   * 

   * 如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，
   * 就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。
   * 默认值：false。
   * 

   * 

   *     参考博客：https://blog.csdn.net/isea533/article/details/51533296?utm_source=blogxgwz9
   * 

   */
  private boolean resultOrdered;
  /**
   * SQL指令类型
   * 
    
   *     
  1. UNKNOWN:未知
    2. 
   *     
  2. INSERT:插入
    3. 
   *     
  3. UPDATE：修改
    4. 
   *     
  4. DELETE:删除
    5. 
   *     
  5. SELECT:查询
    6. 
   *     
  6. FLUSH:刷新
    7. 
   * 

   */
  private SqlCommandType sqlCommandType;
  /**
   * Key生成器
   */
  private KeyGenerator keyGenerator;
  /**
   * （仅对 insert 和 update 有用）唯一标记一个属性，
   * MyBatis 会通过 getGeneratedKeys 的返回值或者通过 insert 语句的 selectKey 子元素设置它的键值，
   * 默认：unset。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
   */
  private String[] keyProperties;
  /**
   *    （仅对 insert 和 update 有用）通过生成的键值设置表中的列名，
   *    这个设置仅在某些数据库（像 PostgreSQL）是必须的，当主键列不是表中的第一列的时候需要设置。
   *    如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表
   */
  private String[] keyColumns;
  /**
   * 有嵌套映射结果标记，这个标记除了ParamterMap里面的resultMap外还保护ParamterMap里面的resultMap的resultMap
   */
  private boolean hasNestedResultMaps;
  /**
   * DML标签中配置的databaseId属性
   */
  private String databaseId;
  /**
   * 日志对象
   */
  private Log statementLog;
  /**
   * 语言驱动，默认是 {@link org.apache.ibatis.scripting.xmltags.XMLLanguageDriver}
   */
  private LanguageDriver lang;
  /**
   * 结果集
   */
  private String[] resultSets;

  MappedStatement() {
    // constructor disabled
  }

  public static class Builder {
    /**
     * 默认对象
     */
    private MappedStatement mappedStatement = new MappedStatement();

    /**
     *
     * @param configuration mybatis全局配置信息
     * @param id 节点中的id属性加要命名空间
     * @param sqlSource 构建动态SQL
     * @param sqlCommandType  SQL指令类型
     */
    public Builder(Configuration configuration, String id, SqlSource sqlSource, SqlCommandType sqlCommandType) {
      mappedStatement.configuration = configuration;
      mappedStatement.id = id;
      mappedStatement.sqlSource = sqlSource;
      mappedStatement.statementType = StatementType.PREPARED;
      mappedStatement.resultSetType = ResultSetType.DEFAULT;
      mappedStatement.parameterMap = new ParameterMap.Builder(configuration, "defaultParameterMap", null, new ArrayList<>()).build();
      mappedStatement.resultMaps = new ArrayList<>();
      mappedStatement.sqlCommandType = sqlCommandType;
      mappedStatement.keyGenerator = configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType) ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
      String logId = id;
      //加上全局日志的前缀
      if (configuration.getLogPrefix() != null) {
        logId = configuration.getLogPrefix() + id;
      }
      mappedStatement.statementLog = LogFactory.getLog(logId);
      mappedStatement.lang = configuration.getDefaultScriptingLanguageInstance();
    }

    public Builder resource(String resource) {
      mappedStatement.resource = resource;
      return this;
    }

    public String id() {
      return mappedStatement.id;
    }

    public Builder parameterMap(ParameterMap parameterMap) {
      mappedStatement.parameterMap = parameterMap;
      return this;
    }

    public Builder resultMaps(List resultMaps) {
      mappedStatement.resultMaps = resultMaps;
      for (ResultMap resultMap : resultMaps) {
        mappedStatement.hasNestedResultMaps = mappedStatement.hasNestedResultMaps || resultMap.hasNestedResultMaps();
      }
      return this;
    }

    public Builder fetchSize(Integer fetchSize) {
      mappedStatement.fetchSize = fetchSize;
      return this;
    }

    public Builder timeout(Integer timeout) {
      mappedStatement.timeout = timeout;
      return this;
    }

    public Builder statementType(StatementType statementType) {
      mappedStatement.statementType = statementType;
      return this;
    }

    public Builder resultSetType(ResultSetType resultSetType) {
      mappedStatement.resultSetType = resultSetType == null ? ResultSetType.DEFAULT : resultSetType;
      return this;
    }

    public Builder cache(Cache cache) {
      mappedStatement.cache = cache;
      return this;
    }

    public Builder flushCacheRequired(boolean flushCacheRequired) {
      mappedStatement.flushCacheRequired = flushCacheRequired;
      return this;
    }

    public Builder useCache(boolean useCache) {
      mappedStatement.useCache = useCache;
      return this;
    }

    public Builder resultOrdered(boolean resultOrdered) {
      mappedStatement.resultOrdered = resultOrdered;
      return this;
    }

    public Builder keyGenerator(KeyGenerator keyGenerator) {
      mappedStatement.keyGenerator = keyGenerator;
      return this;
    }

    public Builder keyProperty(String keyProperty) {
      mappedStatement.keyProperties = delimitedStringToArray(keyProperty);
      return this;
    }

    public Builder keyColumn(String keyColumn) {
      mappedStatement.keyColumns = delimitedStringToArray(keyColumn);
      return this;
    }

    public Builder databaseId(String databaseId) {
      mappedStatement.databaseId = databaseId;
      return this;
    }

    public Builder lang(LanguageDriver driver) {
      mappedStatement.lang = driver;
      return this;
    }

    public Builder resultSets(String resultSet) {
      mappedStatement.resultSets = delimitedStringToArray(resultSet);
      return this;
    }

    /**
     * @deprecated Use {@link #resultSets}
     */
    @Deprecated
    public Builder resulSets(String resultSet) {
      mappedStatement.resultSets = delimitedStringToArray(resultSet);
      return this;
    }

    public MappedStatement build() {
      assert mappedStatement.configuration != null;
      assert mappedStatement.id != null;
      assert mappedStatement.sqlSource != null;
      assert mappedStatement.lang != null;
      mappedStatement.resultMaps = Collections.unmodifiableList(mappedStatement.resultMaps);
      return mappedStatement;
    }
  }

  public KeyGenerator getKeyGenerator() {
    return keyGenerator;
  }

  public SqlCommandType getSqlCommandType() {
    return sqlCommandType;
  }

  public String getResource() {
    return resource;
  }

  public Configuration getConfiguration() {
    return configuration;
  }

  public String getId() {
    return id;
  }

  public boolean hasNestedResultMaps() {
    return hasNestedResultMaps;
  }

  public Integer getFetchSize() {
    return fetchSize;
  }

  public Integer getTimeout() {
    return timeout;
  }

  public StatementType getStatementType() {
    return statementType;
  }

  public ResultSetType getResultSetType() {
    return resultSetType;
  }

  public SqlSource getSqlSource() {
    return sqlSource;
  }

  public ParameterMap getParameterMap() {
    return parameterMap;
  }

  public List getResultMaps() {
    return resultMaps;
  }

  public Cache getCache() {
    return cache;
  }

  public boolean isFlushCacheRequired() {
    return flushCacheRequired;
  }

  public boolean isUseCache() {
    return useCache;
  }

  public boolean isResultOrdered() {
    return resultOrdered;
  }

  public String getDatabaseId() {
    return databaseId;
  }

  public String[] getKeyProperties() {
    return keyProperties;
  }

  public String[] getKeyColumns() {
    return keyColumns;
  }

  public Log getStatementLog() {
    return statementLog;
  }

  public LanguageDriver getLang() {
    return lang;
  }

  public String[] getResultSets() {
    return resultSets;
  }

  /**
   * @deprecated Use {@link #getResultSets()}
   */
  @Deprecated
  public String[] getResulSets() {
    return resultSets;
  }

  /**
   * 构建BoundSql对象
   * @param parameterObject 参数对象
   * @return BoundSql对象
   */
  public BoundSql getBoundSql(Object parameterObject) {
    //获取可执行的SQL
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List parameterMappings = boundSql.getParameterMappings();
    //将参数映射加入到BoundSql，重新构建BoundSql对象
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }
    //检查是否有嵌套的resultMap
    // check for nested result maps in parameter mappings (issue #30)
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
      if (rmId != null) {
        ResultMap rm = configuration.getResultMap(rmId);
        if (rm != null) {
          hasNestedResultMaps |= rm.hasNestedResultMaps();
        }
      }
    }

    return boundSql;
  }

  private static String[] delimitedStringToArray(String in) {
    if (in == null || in.trim().length() == 0) {
      return null;
    } else {
      return in.split(",");
    }
  }

}

ResultMapping

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.mapping;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;

import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;

/**
 * resultMap 子元素映射关系
 * @author Clinton Begin
 */
public class ResultMapping {

  /**
   * mybtais全局配置
   */
  private Configuration configuration;
  /**
   * 属性名
   */
  private String property;
  /**
   * 列名
   */
  private String column;
  /**
   * 属性的java类型
   */
  private Class javaType;
  /**
   * 属性的jdbc类型
   */
  private JdbcType jdbcType;
  /**
   * 类型转换器
   */
  private TypeHandler typeHandler;
  /**
   * 嵌套的resultMapId,【命名空间+resultMapId】
   */
  private String nestedResultMapId;
  /**
   * 嵌套的selectId，【命名空间+selectId】
   */
  private String nestedQueryId;
  /**
   * 不能为空的列名
    */
  private Set notNullColumns;
  /**
   * SQL的列名前缀
   */
  private String columnPrefix;
  /**
   * 属性标记
   */
  private List flags;
  /**
   * 组合ResultMaping列表
   */
  private List composites;
  /**
   * 指定用于加载复杂类型的结果集名字。
   */
  private String resultSet;
  /**
   * 指定外键对应的列名
   */
  private String foreignColumn;
  /**
   * 是否懒加载
   */
  private boolean lazy;

  ResultMapping() {
  }

  public static class Builder {
    private ResultMapping resultMapping = new ResultMapping();

    /**
     *
     * @param configuration mybatis全局配置信息
     * @param property 属性名
     * @param column 表列名
     * @param typeHandler 类型处理器
     */
    public Builder(Configuration configuration, String property, String column, TypeHandler typeHandler) {
      this(configuration, property);
      resultMapping.column = column;
      resultMapping.typeHandler = typeHandler;
    }

    /**
     *
     * @param configuration mybatis全局配置信息
     * @param property 属性名
     * @param column 表列名
     * @param javaType 属性的java类型
     */
    public Builder(Configuration configuration, String property, String column, Class javaType) {
      this(configuration, property);
      resultMapping.column = column;
      resultMapping.javaType = javaType;
    }

    /**
     * 
    
     *     
  1. {@link #resultMapping#flags}初始化空的{@link ArrayList}
    2. 
     *     
  2. {@link #resultMapping#composites}初始化空的{@link ArrayList}
    3. 
     *     
  3. @{@link #resultMapping#lazy}初始为mybatis全局配置文件的 {@link Configuration#lazyLoadingEnabled} 属性设置
    4. 
     * 

     * @param configuration mybatis全局配置信息
     * @param property 属性名
     */
    public Builder(Configuration configuration, String property) {
      resultMapping.configuration = configuration;
      resultMapping.property = property;
      resultMapping.flags = new ArrayList<>();
      resultMapping.composites = new ArrayList<>();
      resultMapping.lazy = configuration.isLazyLoadingEnabled();
    }

    /**
     * 属性的java类型
     */
    public Builder javaType(Class javaType) {
      resultMapping.javaType = javaType;
      return this;
    }

    /**
     * 属性的jdbc类型
     */
    public Builder jdbcType(JdbcType jdbcType) {
      resultMapping.jdbcType = jdbcType;
      return this;
    }

    /**
     * 嵌套的resultMapId
     */
    public Builder nestedResultMapId(String nestedResultMapId) {
      resultMapping.nestedResultMapId = nestedResultMapId;
      return this;
    }

    /**
     * 嵌套的selectId
     */
    public Builder nestedQueryId(String nestedQueryId) {
      resultMapping.nestedQueryId = nestedQueryId;
      return this;
    }

    /**
     * 集合的多结果集
     */
    public Builder resultSet(String resultSet) {
      resultMapping.resultSet = resultSet;
      return this;
    }

    /**
     * 指定外键对应的列名
     */
    public Builder foreignColumn(String foreignColumn) {
      resultMapping.foreignColumn = foreignColumn;
      return this;
    }

    /**
     * 获取指定的不为空才创建实例的列
     */
    public Builder notNullColumns(Set notNullColumns) {
      resultMapping.notNullColumns = notNullColumns;
      return this;
    }

    /**
     * 列前缀
     */
    public Builder columnPrefix(String columnPrefix) {
      resultMapping.columnPrefix = columnPrefix;
      return this;
    }

    /**
     * 属性标记
     */
    public Builder flags(List flags) {
      resultMapping.flags = flags;
      return this;
    }

    /**
     * 类型处理器
     */
    public Builder typeHandler(TypeHandler typeHandler) {
      resultMapping.typeHandler = typeHandler;
      return this;
    }

    /**
     * 组合RequestMapping列表
     */
    public Builder composites(List composites) {
      resultMapping.composites = composites;
      return this;
    }

    /**
     * 懒加载
     */
    public Builder lazy(boolean lazy) {
      resultMapping.lazy = lazy;
      return this;
    }

    /**
     * 构建出ResuatMapping实例。
     * 

     *     resultMapping在Builder初始化时已经创建了，这个方法用于返回resultMapping实例。
     *     而且该方法会对flags,composites进行加锁，以防止在其他调用者修改。在typeHandler
     *     没有设置的情况下，也会在全局typeHandler注册器中找到对应javaType的typeHandlder实例。
     *     也验证了一下属性设置的合法性，将不合法的属性设置抛出异常。
     * 

     * @return
     */
    public ResultMapping build() {
      // lock down collections 锁住集合，让flags,composites集合不能再发生任何更改。
      resultMapping.flags = Collections.unmodifiableList(resultMapping.flags);
      resultMapping.composites = Collections.unmodifiableList(resultMapping.composites);
      //当typeHandler为null,会根据javaType来获取一个typeHandler实例赋值到typeHandler
      resolveTypeHandler();
      //验证,不符合条件的，就会抛出异常中断执行。
      validate();
      return resultMapping;
    }

    /**
     * 验证,不符合下面的某一条件都会抛出 {@link IllegalStateException} 异常。
     * 
    
     *  
  1. 不能同时定义 嵌套的selectId 和 嵌套的resultMapId
    2. 
     *  
  2. 在没有设置嵌套的selectId有没有设置嵌套的resultMapId的情况下，typeHandler不应该没有设置或者获取不到。
    3. 
     *  
  3. 列名是可选的在嵌套的resultMap组，但是不能在没有设置嵌套的resultMapId又没有设置组合的resultMap列表的情况下。
    4. 
     *  
  4. 有结果集结合的情况下，通过','隔开的列名与外键列名数保持一致。
    5. 
     * 

     */
    private void validate() {
      // Issue #697: cannot define both nestedQueryId and nestedResultMapId
      //不能同时定义 嵌套的selectId 和 嵌套的resultMapId
      if (resultMapping.nestedQueryId != null && resultMapping.nestedResultMapId != null) {
        throw new IllegalStateException("Cannot define both nestedQueryId and nestedResultMapId in property " + resultMapping.property);
      }
      // Issue #5: there should be no mappings without typehandler
      //在没有设置嵌套的selectId有没有设置嵌套的resultMapId的情况下，typeHandler不应该没有设置或者获取不到。
      if (resultMapping.nestedQueryId == null && resultMapping.nestedResultMapId == null && resultMapping.typeHandler == null) {
        throw new IllegalStateException("No typehandler found for property " + resultMapping.property);
      }
      // Issue #4 and GH #39: column is optional only in nested resultmaps but not in the rest
      //列名是可选的在嵌套的resultMap组，但是不能在没有设置嵌套的resultMapId又没有设置组合的resultMap列表的情况下。
      if (resultMapping.nestedResultMapId == null && resultMapping.column == null && resultMapping.composites.isEmpty()) {
        throw new IllegalStateException("Mapping is missing column attribute for property " + resultMapping.property);
      }
      //有结果集结合的情况下，通过','隔开的列名与外键列名数保持一致。
      if (resultMapping.getResultSet() != null) {
        int numColumns = 0;
        if (resultMapping.column != null) {
          numColumns = resultMapping.column.split(",").length;
        }
        int numForeignColumns = 0;
        if (resultMapping.foreignColumn != null) {
          numForeignColumns = resultMapping.foreignColumn.split(",").length;
        }
        if (numColumns != numForeignColumns) {
          throw new IllegalStateException("There should be the same number of columns and foreignColumns in property " + resultMapping.property);
        }
      }
    }

    /**
     * 解析TypeHadnler实例
     * 

     *     当 {@link #typeHandler} 的为null时，该方法就会根据 {@link #javaType}去
     *     {@link #configuration}的TypeHandlerResgistry对应的typeHandler实例并赋值到{@link #typeHandler}。
     * 

     */
    private void resolveTypeHandler() {
      if (resultMapping.typeHandler == null && resultMapping.javaType != null) {
        Configuration configuration = resultMapping.configuration;
        TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        resultMapping.typeHandler = typeHandlerRegistry.getTypeHandler(resultMapping.javaType, resultMapping.jdbcType);
      }
    }

    public Builder column(String column) {
      resultMapping.column = column;
      return this;
    }
  }

  public String getProperty() {
    return property;
  }

  public String getColumn() {
    return column;
  }

  public Class getJavaType() {
    return javaType;
  }

  public JdbcType getJdbcType() {
    return jdbcType;
  }

  public TypeHandler getTypeHandler() {
    return typeHandler;
  }

  public String getNestedResultMapId() {
    return nestedResultMapId;
  }

  public String getNestedQueryId() {
    return nestedQueryId;
  }

  public Set getNotNullColumns() {
    return notNullColumns;
  }

  public String getColumnPrefix() {
    return columnPrefix;
  }

  public List getFlags() {
    return flags;
  }

  public List getComposites() {
    return composites;
  }

  /**
   * 是否存在组合ResultMaping列表
   * @return
   */
  public boolean isCompositeResult() {
    return this.composites != null && !this.composites.isEmpty();
  }

  public String getResultSet() {
    return this.resultSet;
  }

  public String getForeignColumn() {
    return foreignColumn;
  }

  public void setForeignColumn(String foreignColumn) {
    this.foreignColumn = foreignColumn;
  }

  public boolean isLazy() {
    return lazy;
  }

  public void setLazy(boolean lazy) {
    this.lazy = lazy;
  }

  /**
   * 判断属性名{@link #property}
   */
  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }

    ResultMapping that = (ResultMapping) o;

    if (property == null || !property.equals(that.property)) {
      return false;
    }

    return true;
  }

  /**
   * 判断属性名{@link #property}
   */
  @Override
  public int hashCode() {
    if (property != null) {
      return property.hashCode();
    } else if (column != null) {
      return column.hashCode();
    } else {
      return 0;
    }
  }

  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder("ResultMapping{");
    //sb.append("configuration=").append(configuration); // configuration doesn't have a useful .toString()
    sb.append("property='").append(property).append('\'');
    sb.append(", column='").append(column).append('\'');
    sb.append(", javaType=").append(javaType);
    sb.append(", jdbcType=").append(jdbcType);
    //sb.append(", typeHandler=").append(typeHandler); // typeHandler also doesn't have a useful .toString()
    sb.append(", nestedResultMapId='").append(nestedResultMapId).append('\'');
    sb.append(", nestedQueryId='").append(nestedQueryId).append('\'');
    sb.append(", notNullColumns=").append(notNullColumns);
    sb.append(", columnPrefix='").append(columnPrefix).append('\'');
    sb.append(", flags=").append(flags);
    sb.append(", composites=").append(composites);
    sb.append(", resultSet='").append(resultSet).append('\'');
    sb.append(", foreignColumn='").append(foreignColumn).append('\'');
    sb.append(", lazy=").append(lazy);
    sb.append('}');
    return sb.toString();
  }

}

你可能感兴趣的:(Mybatis-Mapper各类标签封装类源码解析)

  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • 十大可以挣钱的软件(盘点当前赚钱快还靠谱的7个赚钱软件) 高省APP大九
    挣钱软件可以用“泛滥”来形容了，网上各式各样的打着“赚钱”标签的挣钱软件着实让人眼花缭乱，不知道的还以为随便找个软件玩玩就能发家致富，体验过的人却看得清清楚楚明明白白，挣钱软件哪有看到的那么“繁荣”，很多不过是标榜着赚钱来忽悠老百姓的“假”软件罢了！很多网友都在抱怨想找个真正能赚钱的软件太难了，有人花费了大量的时间和精力也没找到个称心如意的挣钱软件，不过现在你是幸运的，本篇千秋将为大家盘点当前赚钱
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • 网络通信流程 记得开心一点啊 服务器网络运维
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
  • 高中抓住这两招，帮你实现从学渣到学霸的逆袭 以读攻独
    富兰克林曾说：“宝贝放错了地方便是废物。”一句话戳中了“位置”的重要性。大多数人，最初对位置的明显感受，似乎就来源于上高中时的座位：成绩好的，坐前排，那里安静，学习氛围浓，受关注度高；成绩差的坐后面，嘈杂，充斥着汗味、食品味、香水味，也经常被点名。所以，位置不仅代表了分数，也给你打上了“学渣”或“学霸”的标签。在《逆袭》这本书中，就真实地讲述一个参加了2014年高考的高中生，用三年的奋斗史，从班级
  • 今日分享：有的孩子家长常常在对于小朋友老是说谎，还特别爱推卸责任，很头痛，不知道该怎么办！ 雨燕Cassie
    其实六岁以前都不叫撒谎，只能叫做逃避和害怕，因为他们都是没有撒谎的这个概念，家长所谓的撒谎只能说是因为做错了事情，怕受到责罚而找一个「台阶」给自己一下而已，所以家长不能给孩子一个贴上撒谎的这个标签，如果说孩子出现家长所说的撒谎，我们应该做的是：1.允许孩子将事情的原委进行一个表达，给孩子说明的机会，不提示孩子说谎，不急著批评孩子。2.不使用问句，不恐吓和严刑逼供，耐心的以故事或者以分析的形式和孩子
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 项目：事半功倍的法宝 小小效能
    行动的三大流程：记录、排程和执行，也讲了易效能的4D原则以及T-step标签法。这些流程和方法能够解决我们眼前的一地鸡毛，让我们有更多时间和精力去关注更为长远的事情，完成工作、生活和人生中重要的项目。项目管理能够让我们围绕结果去做事情，达成事半功倍的效果，也就是做更少的事情，但达成更好的效果。如果我们能够不断地达成一个又一个的项目，那么我们的人生无疑会像滚雪球一样，在长坡道上面不断积累。一、项目的
  • 解决Obsidian写笔记中的＜img＞标签无法显示图片的问题 全能全知者 笔记
    Obsidian中写md笔记如果使用标签会显示不出图案，后来才知道因为Obsidian的问题导致只能用绝对路径定位。所以我本人写了一个py插件，将md笔记里的img标签批量替换成Obsidian能够读取的形式。安装FixObsImgDpy:pipinstallFixObsImgDpy安装完成后在需要修复的md文件的父目录下运行命令:FixObsImgDpy就会自动修复父目录以下的全部md文件 仓库
  • 《驴友的朝圣》065 户外运动论坛，论户外运动之现在与未来 经典老表
    十几年来，我国户外运动蓬勃发展，已经形成全民参与热情。各类户外运动项目和形式层出不穷。各种户外运动装备产品花样百出。看着形势一派大好。但是，在这大好形势之下，仍存在着诸多的发展瓶颈及安全与管理问题，需要提请重视。为此，江城登山协会在本地召开了“户外运动论坛”，邀请市内户外运动俱乐部及体育系统领导一起研讨本地区户外运动发展的可持续性。2019年6月1日，论坛在世贸万锦大酒店的支持下，在其三层会议大厅
  • [实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
  • 3.1 损失函数和优化：损失函数 做只小考拉
    用一个函数把W当做输入，然后看一下得分，定量地估计W的好坏，这个函数被称为“损失函数”。损失函数用于度量W的好坏。有了损失函数的概念后，就可以定量的衡量W到底是好还是坏，要找到一种有效的方法来从W的可行域里，找到W取何值时情况最不坏，，这个过程将会是一个优化过程。损失函数L_i定义：通过函数f给出预测的分数和真实的目标（或者说是标签y），可以定量的描述训练样本预测的好不好，最终的损失函数是在整个数
  • 生活处处是心理，学习心理目的在于：多一点点觉察和自知 王明鹏
    单位组织健康查体，因故耽误了正常时间，今天预约一早过去，历时2个多小时完成，期间不乏各类心理现象与各种心理体验。体验一：自以为明白或者对的时候，其实糊涂着，或者理解偏颇，这就是自我中心主义思维误区。进入查体大楼，门口聚集不少人，得知在验证健康码，确认无误者才让通过。心想这还不简单，专门下载使用过健康码，调出来出示人家，答复不是这个，需要下载门口告示上的二维码。体验二：急躁情绪的后面，几乎都是预期受
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • 处理标签包裹的字符串，并取出前250字符 周bro 前端javascript开发语言
    //假设这是你的HTML字符串varhtmlString=`这是一个段落。这是一个标题这是另一个段落，包含一些链接。`;//解析HTML字符串并提取文本functionextractTextFromHTML(html){varparser=newDOMParser();vardoc=parser.parseFromString(html,"text/html");vartextContent=do
  • 史上最全git命令,git回滚,git命令大全 騒周 其他git
    git命令大全一、Git整体理解二、由暂存区本地仓库三、由本地仓->远程仓库四、冲突处理五、Git分支操作六、bug的分支七、feature分支八、暂存的使用九、远程仓的操作十、标签的使用十一、Git配置全局信息十二、Linux的一些简单操作和一些符号的解释十三、符号解释十四、显示安装详细信息十五、gitconfig十六、Gitclone十七、Gitinit十八、gitstatus十九、gitre
  • 免费像素画绘制软件 | Pixelorama v1.0.3 dntktop 软件运维windows
    Pixelorama是一款开源像素艺术多工具软件，旨在为用户提供一个强大且易于使用的平台来创作各种像素艺术作品，包括精灵、瓷砖和动画。这款软件以其丰富的工具箱、动画支持、像素完美模式、剪裁遮罩、预制及可导入的调色板等特色功能，满足了像素艺术家们的各种需求。用户可以享受到动态工具映射、洋葱皮效果、帧标签、播放动画时绘制等高级功能，以及非破坏性的、完全可定制的图层效果，如轮廓、渐变映射、阴影和调色板化
  • 2022-8-16晨间日记 飞扬的雪ing
    今天是什么日子起床：7：30就寝：11：20天气：晴热心情：悲伤逆流成河纪念日：被恶意锁文第三天叫我起床的不是闹钟是梦想年度目标及关键点：好好吃饭好好睡觉好好学习，忘记所有悲伤本月重要成果：1.完成暑期各类学习任务2.减肥减肥减肥3.督促孩子们好好训练节目成功日志-记录三五件有收获的事务1.《疫情.怡情》依然被恶意锁文，幼儿级“晨间日记”则不会被锁，可悲可叹!敷衍至极的文章收获上百个赞，可喜可贺!
  • Python精选200Tips：121-125 AnFany Python200+Tipspython开发语言
    Spendyourtimeonself-improvement121Requests-简化的HTTP请求处理发送GET请求发送POST请求发送PUT请求发送DELETE请求会话管理处理超时文件上传122BeautifulSoup-网页解析和抓取解析HTML和XML文档查找单个标签查找多个标签使用CSS选择器查找标签提取文本修改文档内容删除标签处理XML文档123Scrapy-强大的网络爬虫框架示例
  • maven-assembly-plugin 打包实例 带着二娃去遛弯
    1.先在pom.xml文件中添加assembly打包插件org.apache.maven.pluginsmaven-assembly-plugin2.6assembly/assembly.xmlmake-assemblypackagesingle说明:1.需要修改的可能就是descriptors标签下面的打包配置文件目录,指定assembly.xml的路径.2.可以添加多个打包配置文件,进行多种形
  • 《女子监狱》系列，Netflix自此走上牛B之路 IMTVS_cc
    文|温水排版|不二今天小编要给大家推荐的是让Netflix大方打上“原创剧集”这个牛气标签，也让HBO这些老牌电视网倒吸一口凉气的美剧《女子监狱》。剧集播出后，IMDB得分在9分徘徊，媒体评价持续走高。从收视率及口碑上来看，《女子监狱》是网飞当之无愧的王牌，自上线以来斩获金球奖等重要奖项6次、提名19次，网络话题数不胜数。《女子监狱》的英文原名是“Orangeisthenewblack”，直译过来
  • 机器学习-------数据标准化 罔闻_spider 数据分析算法机器学习人工智能
    什么是归一化，它与标准化的区别是什么？一作用在做训练时，需要先将特征值与标签标准化，可以防止梯度防炸和过拟合；将标签标准化后，网络预测出的数据是符合标准正态分布的—StandarScaler()，与真实值有很大差别。因为StandarScaler()对数据的处理是（真实值-平均值）/标准差。同时在做预测时需要将输出数据逆标准化提升模型精度：标准化/归一化使不同维度的特征在数值上更具比较性，提高分类
  • 不给人生设限 接纳万物
    最近在听人物传记，从中汲取的是不给人生设限。我们从小就可能被各种言语设限，别人的一句否定，别人给我们贴的标签，都会让我们在脑海中给自己很多的限制，我们一直活在别人的眼中。如何勇敢的尝试，突破自我，活出精彩的生命？我们能做的是不去评判别人，以及对于别人的评判能做到不在乎。打小我们就被贴上标签，以为自己天生就是这样子的，无法改变，无法突破，然而通过阅读终身成长这本书我们了解到并非如此，只要自己愿意改变
  • 丁俊贵之《“女人和男人”那些事》 兴时态_198812
    【“女人和男人”那些事】生活中，我们经常用性别来给很多现象和问题贴标签。比如：女性发脾气是常见的事情，所以不要跟她们讲道理，要让着她们；女性考虑问题总是比较感性，不如男性那么理性、严谨、全面；女生的数学成绩普遍比较差，因此选文科的女生更多；……许许多多像这样的认知，已经成为我们根深蒂固的信念。我们在生活中哪怕不会直接这样讲，但多多少少都会有类似的想法和感受，并且用这些信念去理解和认知他人。一、人世
  • 【C#Mutex】 initiallyOwned错误引起的缺陷 闻缺陷则喜何志丹 c#互斥量进程同步WaitOneinitiallyOwned临界区
    临界区只能对同一个进程的不同线程同步，互斥量可以跨进程同步。典型应用场景：两个exe会操作同一个注册表项。错误代码封装类publicclassCMutexHelp:IDisposable{publicCMutexHelp(){s_mutex.WaitOne();}privatestaticMutexs_mutex=newMutex(true,"Time202409091406ab");public
  • 让真善美成为人格的中坚和个人IP标签 matou
    大家都知道，价格围绕价值波动，这是符合逻辑的经济原理。一旦价格偏离了价值，作为生产价值的人就会焦虑不安，害怕价格会一路走低，自己的付出会打水漂。所以便产生了急功近利，希望价格波动小一些，希望价格上升快一些，甚至开始信奉价值应该围绕价格波动的理论。价格高蜂拥而上，价格降低又匆匆而退。忘了去创造价值，而是堕入焦虑，到处寻找收益高、前景好、风险低的项目。我们不惜牺牲健康、违背伦理、违反法律，只为先人一步
  • 广州复刻包包市场（盘点十个广州复刻包包批发渠道） 美鞋之家
    广州作为中国最大的商品交易基地，众多的货源市场使其深受商家们的喜欢。其中复刻包包市场更是闻名全国，以下就为你盘点十个广州复刻包包批发渠道。微信:1179517285(下单赠送精美礼品)1.白马包包批发市场白马包包批发市场是广州最有名的复刻包批发市场之一，这里的包包种类繁多，设计独特，适合各类人群购买使用。2.海珠区新华洲包城新华洲包城主要经营女士配饰、鞋包等商品，这里的复刻包包既有精仿的高端品牌，
  • Halo 开发者指南——容器私有化部署 SHENHUANJIE DockerHalo华为云SWRRegistry
    华为云SWR私有化部署镜像构建dockerbuild-thalo-dev/halo:2.20.0.上传镜像镜像标签sudodockertag{镜像名称}:{版本名称}swr.cn-south-1.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称}sudodockertaghalo-dev/halo:2.20.0swr.cn-south-1.myhuaweicloud.co
  • ViewController添加button按钮解析。（翻译） 张亚雄 c
    <div class="it610-blog-content-contain" style="font-size: 14px"></div>//  ViewController.m //  Reservation software // //  Created by 张亚雄 on 15/6/2.
  • mongoDB 简单的增删改查 开窍的石头 mongodb
       在上一篇文章中我们已经讲了mongodb怎么安装和数据库/表的创建。在这里我们讲mongoDB的数据库操作       在mongo中对于不存在的表当你用db.表名 他会自动统计 下边用到的user是表明，db代表的是数据库       添加(insert):
  • log4j配置 0624chenhong log4j
    1) 新建java项目 2) 导入jar包，项目右击，properties—java build path—libraries—Add External jar，加入log4j.jar包。 3) 新建一个类com.hand.Log4jTest package com.hand; import org.apache.log4j.Logger; public class
  • 多点触摸(图片缩放为例) 不懂事的小屁孩 多点触摸
    多点触摸的事件跟单点是大同小异的，上个图片缩放的代码，供大家参考一下 import android.app.Activity; import android.os.Bundle; import android.view.MotionEvent; import android.view.View; import android.view.View.OnTouchListener
  • 有关浏览器窗口宽度高度几个值的解析 换个号韩国红果果 JavaScripthtml
    1 元素的 offsetWidth 包括border padding  content  整体的宽度。 clientWidth  只包括内容区 padding 不包括border。 clientLeft =  offsetWidth -clientWidth  即这个元素border的值 offsetLeft  若无已定位的包裹元素
  • 数据库产品巡礼：IBM DB2概览 蓝儿唯美 db2
    IBM DB2是一个支持了NoSQL功能的关系数据库管理系统，其包含了对XML，图像存储和Java脚本对象表示（JSON）的支持。DB2可被各种类型的企 业使用，它提供了一个数据平台，同时支持事务和分析操作，通过提供持续的数据流来保持事务工作流和分析操作的高效性。 DB2支持的操作系统 DB2可应用于以下三个主要的平台:   工作站，DB2可在Linus、Unix、Windo
  • java笔记5 a-john java
    控制执行流程： 1，true和false    利用条件表达式的真或假来决定执行路径。例：（a==b）。它利用条件操作符“==”来判断a值是否等于b值，返回true或false。java不允许我们将一个数字作为布尔值使用，虽然这在C和C++里是允许的。如果想在布尔测试中使用一个非布尔值，那么首先必须用一个条件表达式将其转化成布尔值，例如if(a!=0)。 2，if-els
  • Web开发常用手册汇总 aijuans PHP
    一门技术，如果没有好的参考手册指导,很难普及大众。这其实就是为什么很多技术，非常好，却得不到普遍运用的原因。 正如我们学习一门技术，过程大概是这个样子： ①我们日常工作中，遇到了问题，困难。寻找解决方案，即寻找新的技术； ②为什么要学习这门技术？这门技术是不是很好的解决了我们遇到的难题，困惑。这个问题，非常重要，我们不是为了学习技术而学习技术，而是为了更好的处理我们遇到的问题，才需要学习新的
  • 今天帮助人解决的一个sql问题 asialee sql
                今天有个人问了一个问题，如下： type     AD      value          A  
  • 意图对象传递数据 百合不是茶 android意图IntentBundle对象数据的传递
    学习意图将数据传递给目标活动; 初学者需要好好研究的       1,将下面的代码添加到main.xml中    <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http:/
  • oracle查询锁表解锁语句 bijian1013 oracleobjectsessionkill
    一.查询锁定的表 如下语句，都可以查询锁定的表 语句一： select a.sid, a.serial#, p.spid, c.object_name, b.session_id, b.oracle_username, b.os_user_name from v$process p, v$s
  • mac osx 10.10 下安装 mysql 5.6 二进制文件［tar.gz］ 征客丶 mysqlosx
    场景：在 mac osx 10.10 下安装 mysql 5.6 的二进制文件。 环境：mac osx 10.10、mysql 5.6 的二进制文件 步骤：[所有目录请从根“/”目录开始取，以免层级弄错导致找不到目录] 1、下载 mysql 5.6 的二进制文件，下载目录下面称之为 mysql5.6SourceDir； 下载地址：http://dev.mysql.com/downl
  • 分布式系统与框架 bit1129 分布式
    RPC框架 Dubbo 什么是Dubbo   Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。其核心部分包含:    远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。    集群容错: 提供基于接
  • 那些令人蛋痛的专业术语 白糖_ springWebSSOIOC
    spring 【控制反转(IOC)/依赖注入(DI)】： 由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。 简单的说：对象的创建又容器(比如spring容器)来执行，程序里不直接new对象。 Web 【单点登录(SSO)】：SSO的定义是在多个应用系统中，用户
  • 《给大忙人看的java8》摘抄 braveCS java8
    函数式接口：只包含一个抽象方法的接口 lambda表达式：是一段可以传递的代码       你最好将一个lambda表达式想象成一个函数，而不是一个对象，并记住它可以被转换为一个函数式接口。 事实上，函数式接口的转换是你在Java中使用lambda表达式能做的唯一一件事。   方法引用：又是要传递给其他代码的操作已经有实现的方法了，这时可以使
  • 编程之美-计算字符串的相似度 bylijinnan java算法编程之美
    public class StringDistance { /** * 编程之美 计算字符串的相似度 * 我们定义一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为： * 1.修改一个字符（如把“a”替换为“b”）; * 2.增加一个字符（如把“abdd”变为“aebdd”）; * 3.删除一个字符（如把“travelling”变为“trav
  • 上传、下载压缩图片 chengxuyuancsdn 下载
    /** * * @param uploadImage --本地路径(tomacat路径) * @param serverDir --服务器路径 * @param imageType --文件或图片类型 * 此方法可以上传文件或图片.txt,.jpg,.gif等 */ public void upload(String uploadImage,Str
  • bellman-ford(贝尔曼-福特)算法 comsci 算法F#
    Bellman-Ford算法(根据发明者 Richard Bellman 和 Lester Ford 命名)是求解单源最短路径问题的一种算法。单源点的最短路径问题是指：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore zu 也为这个算法的发展做出了贡献。 与迪科
  • oracle ASM中ASM_POWER_LIMIT参数 daizj ASMoracleASM_POWER_LIMIT磁盘平衡
    ASM_POWER_LIMIT 该初始化参数用于指定ASM例程平衡磁盘所用的最大权值，其数值范围为0~11，默认值为1。该初始化参数是动态参数，可以使用ALTER  SESSION或ALTER  SYSTEM命令进行修改。示例如下： SQL>ALTER  SESSION  SET   Asm_power_limit=2;
  • 高级排序:快速排序 dieslrae 快速排序
    public void quickSort(int[] array){ this.quickSort(array, 0, array.length - 1); } public void quickSort(int[] array,int left,int right){ if(right - left <= 0
  • C语言学习六指针_何谓变量的地址 一个指针变量到底占几个字节 dcj3sjt126com C语言
    # include <stdio.h> int main(void) { /* 1、一个变量的地址只用第一个字节表示 2、虽然他只使用了第一个字节表示，但是他本身指针变量类型就可以确定出他指向的指针变量占几个字节了 3、他都只存了第一个字节地址，为什么只需要存一个字节的地址，却占了4个字节，虽然只有一个字节， 但是这些字节比较多，所以编号就比较大，
  • phpize使用方法 dcj3sjt126com PHP
    phpize是用来扩展php扩展模块的，通过phpize可以建立php的外挂模块,下面介绍一个它的使用方法,需要的朋友可以参考下 安装（fastcgi模式）的时候，常常有这样一句命令： 代码如下: /usr/local/webserver/php/bin/phpize   一、phpize是干嘛的？ phpize是什么？ phpize是用来扩展php扩展模块的，通过phpi
  • Java虚拟机学习 - 对象引用强度 shuizhaosi888 JAVA虚拟机
    本文原文链接：http://blog.csdn.net/java2000_wl/article/details/8090276 转载请注明出处！ 无论是通过计数算法判断对象的引用数量，还是通过根搜索算法判断对象引用链是否可达，判定对象是否存活都与“引用”相关。 引用主要分为 ：强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Wea
  • .NET Framework 3.5 Service Pack 1（完整软件包）下载地址 happyqing .net下载framework
      Microsoft .NET Framework 3.5 Service Pack 1（完整软件包）  http://www.microsoft.com/zh-cn/download/details.aspx?id=25150 Microsoft .NET Framework 3.5 Service Pack 1 是一个累积更新，包含很多基于 .NET Framewo
  • JAVA定时器的使用 jingjing0907 javatimer线程定时器
    1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。 对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。 privatejava.util.Timer timer; timer = newTimer(true); timer.schedule( newjava.util.TimerTask() { public void run()
  • Webbench 流浪鱼 webbench
    首页下载地址 http://home.tiscali.cz/~cz210552/webbench.html Webbench是知名的网站压力测试工具，它是由Lionbridge公司（http://www.lionbridge.com）开发。 Webbench能测试处在相同硬件上，不同服务的性能以及不同硬件上同一个服务的运行状况。webbench的标准测试可以向我们展示服务器的两项内容：每秒钟相
  • 第11章 动画效果（中） onestopweb 动画
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • windows下制作bat启动脚本. sanyecao2314 javacmd脚本bat
    java -classpath C:\dwjj\commons-dbcp.jar;C:\dwjj\commons-pool.jar;C:\dwjj\log4j-1.2.16.jar;C:\dwjj\poi-3.9-20121203.jar;C:\dwjj\sqljdbc4.jar;C:\dwjj\voucherimp.jar com.citsamex.core.startup.MainStart
  • Java进行RSA加解密的例子 tomcat_oracle java
    加密是保证数据安全的手段之一。加密是将纯文本数据转换为难以理解的密文；解密是将密文转换回纯文本。 　　数据的加解密属于密码学的范畴。通常，加密和解密都需要使用一些秘密信息，这些秘密信息叫做密钥，将纯文本转为密文或者转回的时候都要用到这些密钥。 　　对称加密指的是发送者和接收者共用同一个密钥的加解密方法。 　　非对称加密(又称公钥加密)指的是需要一个私有密钥一个公开密钥，两个不同的密钥的
  • Android_ViewStub 阿尔萨斯 ViewStub
    public final class ViewStub extends View java.lang.Object android.view.View android.view.ViewStub 类摘要： ViewStub 是一个隐藏的，不占用内存空间的视图对象，它可以在运行时延迟加载布局资源文件。当 ViewSt
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他