《Mybatis源码》第6章 标签封装类

最新推荐文章于 2022-12-09 15:57:16 发布
最新推荐文章于 2022-12-09 15:57:16 发布
阅读量162 收藏
点赞数
分类专栏： 《Mybatis从0到1》 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44051038/article/details/121524422
版权

一、请求

MappedStatement

我们的DML标签会被封装成MappedStatement对象，该类的关键点都在字段上，其它的方法都是最简单的赋值，

public final class MappedStatement {

  // 路径来源
  private String resource;
  private Configuration configuration;
  // DML标签id
  private String id;
  // 单次查询数量
  private Integer fetchSize;
  // 超时等待时间
  private Integer timeout;
  // Statement类型 默认ParementStatement
  private StatementType statementType;
  // 结果集类型
  private ResultSetType resultSetType;
  // Sql来源 是静态编译还是动态编译
  private SqlSource sqlSource;
  // 二级缓存区域
  private Cache cache;
  // 官网标记对应的标签为废弃
  private ParameterMap parameterMap;
  // 对应ResultMap标签
  private List<ResultMap> resultMaps;
  // 每次请求是否刷新缓存
  private boolean flushCacheRequired;
  // 是否使用缓存
  private boolean useCache;
  private boolean resultOrdered;
  // SQL类型  增删改查
  private SqlCommandType sqlCommandType;
  private KeyGenerator keyGenerator;
  private String[] keyProperties;
  private String[] keyColumns;
  // 包含嵌套映射
  private boolean hasNestedResultMaps;
  private String databaseId;
  private Log statementLog;
  // 语言驱动
  private LanguageDriver lang;
  // 多结果集	
  private String[] resultSets;

  MappedStatement() {
    // constructor disabled
  }

  public static class Builder {
    private MappedStatement mappedStatement = new MappedStatement();

    public Builder(Configuration configuration, String id, SqlSource sqlSource, SqlCommandType sqlCommandType) {
      mappedStatement.configuration = configuration;
      mappedStatement.id = id;
      mappedStatement.sqlSource = sqlSource;
      mappedStatement.statementType = StatementType.PREPARED;
      mappedStatement.parameterMap = new ParameterMap.Builder(configuration, "defaultParameterMap", null, new ArrayList<ParameterMapping>()).build();
      mappedStatement.resultMaps = new ArrayList<ResultMap>();
      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<ResultMap> 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;
      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<ResultMap> 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;
  }
  
  public BoundSql getBoundSql(Object parameterObject) {
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

    // 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(",");
    }
  }
}

ParameterMapping

public class ParameterMapping {

  private Configuration configuration;

  // 参数名
  private String property;
  // 参数类型
  private ParameterMode mode;
  // Java类型 默认Object
  private Class<?> javaType = Object.class;
  private JdbcType jdbcType;
  // 小数点保留的位数
  private Integer numericScale;
  // 类型处理器
  private TypeHandler<?> typeHandler;
  // 结果映射Id
  private String resultMapId;
  private String jdbcTypeName;
  // 表达式
  private String expression;

  private ParameterMapping() {
  }

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

    public Builder(Configuration configuration, String property, TypeHandler<?> typeHandler) {
      parameterMapping.configuration = configuration;
      parameterMapping.property = property;
      parameterMapping.typeHandler = typeHandler;
      parameterMapping.mode = ParameterMode.IN;
    }

    public Builder(Configuration configuration, String property, Class<?> javaType) {
      parameterMapping.configuration = configuration;
      parameterMapping.property = property;
      parameterMapping.javaType = javaType;
      parameterMapping.mode = ParameterMode.IN;
    }

    public Builder mode(ParameterMode mode) {
      parameterMapping.mode = mode;
      return this;
    }

    public Builder javaType(Class<?> javaType) {
      parameterMapping.javaType = javaType;
      return this;
    }

    public Builder jdbcType(JdbcType jdbcType) {
      parameterMapping.jdbcType = jdbcType;
      return this;
    }

    public Builder numericScale(Integer numericScale) {
      parameterMapping.numericScale = numericScale;
      return this;
    }

    public Builder resultMapId(String resultMapId) {
      parameterMapping.resultMapId = resultMapId;
      return this;
    }

    public Builder typeHandler(TypeHandler<?> typeHandler) {
      parameterMapping.typeHandler = typeHandler;
      return this;
    }

    public Builder jdbcTypeName(String jdbcTypeName) {
      parameterMapping.jdbcTypeName = jdbcTypeName;
      return this;
    }

    public Builder expression(String expression) {
      parameterMapping.expression = expression;
      return this;
    }

    // 构建
    public ParameterMapping build() {
      // 处理TypeHandler
      resolveTypeHandler();
      // 验证
      validate();
      return parameterMapping;
    }

    private void validate() {
      if (ResultSet.class.equals(parameterMapping.javaType)) {
        if (parameterMapping.resultMapId == null) { 
          throw new IllegalStateException("Missing resultmap in property '"  
              + parameterMapping.property + "'.  " 
              + "Parameters of type java.sql.ResultSet require a resultmap.");
        }            
      } else {
        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.");
        }
      }
    }

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

  }

  // 省略一些 setter/getter 方法...

  @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

对应我们Mapper中的ResultMap，需要注意的点

  1. 会处理id、result、constructor、discriminator标签
  2. 如果 resultMap 没有 id 子标签，那么所有的result标签都是 id标签，这主要在嵌套映射的时候使用
  3. 将结果映射会进行分组
  4. 如果包含constructor标签，那么先判断是否存在对应构造方法，然后将其进行排序
public class ResultMap {
    
  private Configuration configuration;
  
  // <resultMap>的id属性
  private String id;
  // <resultMap>的type属性
  private Class<?> type;
  // 除<discriminator>元素外的所有属性映射关系
  private List<ResultMapping> resultMappings;
  // 所有属性映射中带有ID标志的映射关系，包括<id>元素和<constructor>的<idArg>子元素
  private List<ResultMapping> idResultMappings;
  // 带有Constructor标志的映射关系
  private List<ResultMapping> constructorResultMappings;
  // 所有属性映射中不带有Constructor标志的映射关系
  private List<ResultMapping> propertyResultMappings;
  // 所有属性映射中的column属性的集合
  private Set<String> mappedColumns;
  // 所有属性映射中的properties属性的集合
  private Set<String> mappedProperties;
  // 鉴别器
  private Discriminator discriminator;
  // 是否包含嵌套的结果映射
  private boolean hasNestedResultMaps;
  // 是否包含嵌套的结果查询
  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();

    public Builder(Configuration configuration, String id, Class<?> type, List<ResultMapping> resultMappings) {
      this(configuration, id, type, resultMappings, null);
    }

    public Builder(Configuration configuration, String id, Class<?> type, List<ResultMapping> resultMappings, Boolean autoMapping) {
      resultMap.configuration = configuration;
      resultMap.id = id;
      resultMap.type = type;
      resultMap.resultMappings = resultMappings;
      resultMap.autoMapping = autoMapping;
    }
    
    // 鉴别器
    public Builder discriminator(Discriminator discriminator) {
      resultMap.discriminator = discriminator;
      return this;
    }

    public Class<?> type() {
      return resultMap.type;
    }

    // 建造方法
    public ResultMap build() {
      if (resultMap.id == null) {
        throw new IllegalArgumentException("ResultMaps must have an id");
      }
      // 初始化集合
      resultMap.mappedColumns = new HashSet<String>();
      resultMap.mappedProperties = new HashSet<String>();
      resultMap.idResultMappings = new ArrayList<ResultMapping>();
      resultMap.constructorResultMappings = new ArrayList<ResultMapping>();
      resultMap.propertyResultMappings = new ArrayList<ResultMapping>();
      final List<String> constructorArgNames = new ArrayList<String>();
      // 遍历结果映射
      for (ResultMapping resultMapping : resultMap.resultMappings) {
        // 是否包含嵌套查询
        resultMap.hasNestedQueries = resultMap.hasNestedQueries || resultMapping.getNestedQueryId() != null;
        // 是否包含嵌套映射
        resultMap.hasNestedResultMaps = resultMap.hasNestedResultMaps || (resultMapping.getNestedResultMapId() != null && resultMapping.getResultSet() == null);
        // 列名
        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));
            }
          }
        }
        // Bean字段名
        final String property = resultMapping.getProperty();
        if(property != null) {
          // 添加
          resultMap.mappedProperties.add(property);
        }
        // 构造方法映射集合
        if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
          resultMap.constructorResultMappings.add(resultMapping);
          if (resultMapping.getProperty() != null) {
            constructorArgNames.add(resultMapping.getProperty());
          }
        } else {
          // 除Constructor的映射集合
          resultMap.propertyResultMappings.add(resultMapping);
        }
        // id映射集合
        if (resultMapping.getFlags().contains(ResultFlag.ID)) {
          resultMap.idResultMappings.add(resultMapping);
        }
      }
      // 如果没有id映射集合 那么全都是主键映射集合 这个主要在嵌套映射的时候使用 
      if (resultMap.idResultMappings.isEmpty()) {
        resultMap.idResultMappings.addAll(resultMap.resultMappings);
      }
      if (!constructorArgNames.isEmpty()) {
        // 获取对应构造方法的参数名
        final List<String> actualArgNames = argNamesOfMatchingConstructor(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.");
        }
        // 排序  让constructorResultMappings的顺序跟构造方法的形参顺序一直
        Collections.sort(resultMap.constructorResultMappings, new Comparator<ResultMapping>() {
          @Override
          public int compare(ResultMapping o1, ResultMapping 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;
    }

    // 匹配构造函数的参数名称
    private List<String> argNamesOfMatchingConstructor(List<String> constructorArgNames) {
      // 获取结果类型的构造方法
      Constructor<?>[] constructors = resultMap.type.getDeclaredConstructors();
      for (Constructor<?> constructor : constructors) {
        // 构造方法参数集合
        Class<?>[] paramTypes = constructor.getParameterTypes();
        // 参数个数判断
        if (constructorArgNames.size() == paramTypes.length) {
          // 获取参数名称
          List<String> paramNames = getArgNames(constructor);
          // 参数名匹配 && 参数类型匹配
          if (constructorArgNames.containsAll(paramNames)
              && argTypesMatch(constructorArgNames, paramTypes, paramNames)) {
            return paramNames;
          }
        }
      }
      return null;
    }

    // 匹配构造函数的参数类型
    private boolean argTypesMatch(final List<String> constructorArgNames,
        Class<?>[] paramTypes, List<String> paramNames) {
      for (int i = 0; i < constructorArgNames.size(); i++) {
        Class<?> actualType = paramTypes[paramNames.indexOf(constructorArgNames.get(i))];
        Class<?> specifiedType = resultMap.constructorResultMappings.get(i).getJavaType();
        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;
    }

    // 获取构造方法参数名
    private List<String> getArgNames(Constructor<?> constructor) {
      if (resultMap.configuration.isUseActualParamName() && Jdk.parameterExists) {
        return ParamNameUtil.getParamNames(constructor);
      } else {
        List<String> paramNames = new ArrayList<String>();
        final Annotation[][] paramAnnotations = constructor.getParameterAnnotations();
        int paramCount = paramAnnotations.length;
        for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
          String name = null;
          for (Annotation annotation : paramAnnotations[paramIndex]) {
            if (annotation instanceof Param) {
              name = ((Param) annotation).value();
              break;
            }
          }
          paramNames.add(name != null ? name : "arg" + paramIndex);
        }
        return paramNames;
      }
    }
  }

  // 省略一些 setter/getter 构造方法
}

ResultMapping

该类封装了ResultMap标签中的子标签，一个对象对应一个子标签，包括id，result，constructor

public class ResultMapping {

  // 配置
  private Configuration configuration;
  // 对应bean的属性
  private String property;
  // 对应mysql的列
  private String column;
  private Class<?> javaType;
  private JdbcType jdbcType;
  // 处理器
  private TypeHandler<?> typeHandler;
  // 嵌套映射Id   【命名空间+resultMapId】
  private String nestedResultMapId;
  // 嵌套查询Id   【命名空间+selectId】
  private String nestedQueryId;
  // 不能为空的列名
  private Set<String> notNullColumns;
  // 列名前缀
  private String columnPrefix;
  // 标记
  private List<ResultFlag> flags;
  // 组合ResultMaping列表
  private List<ResultMapping> composites;
  // 结果集
  private String resultSet;
  private String foreignColumn;
  // 是否懒加载
  private boolean lazy;

  ResultMapping() {
  }

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

    public Builder(Configuration configuration, String property, String column, TypeHandler<?> typeHandler) {
      this(configuration, property);
      resultMapping.column = column;
      resultMapping.typeHandler = typeHandler;
    }

    public Builder(Configuration configuration, String property, String column, Class<?> javaType) {
      this(configuration, property);
      resultMapping.column = column;
      resultMapping.javaType = javaType;
    }

    public Builder(Configuration configuration, String property) {
      resultMapping.configuration = configuration;
      resultMapping.property = property;
      resultMapping.flags = new ArrayList<>();
      resultMapping.composites = new ArrayList<>();
      resultMapping.lazy = configuration.isLazyLoadingEnabled();
    }

    public Builder javaType(Class<?> javaType) {
      resultMapping.javaType = javaType;
      return this;
    }

    public Builder jdbcType(JdbcType jdbcType) {
      resultMapping.jdbcType = jdbcType;
      return this;
    }

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

    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<String> notNullColumns) {
      resultMapping.notNullColumns = notNullColumns;
      return this;
    }

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

    public Builder flags(List<ResultFlag> flags) {
      resultMapping.flags = flags;
      return this;
    }

    public Builder typeHandler(TypeHandler<?> typeHandler) {
      resultMapping.typeHandler = typeHandler;
      return this;
    }

    public Builder composites(List<ResultMapping> composites) {
      resultMapping.composites = composites;
      return this;
    }

    public Builder lazy(boolean lazy) {
      resultMapping.lazy = lazy;
      return this;
    }

    // 创建方法
    public ResultMapping build() {
      // lock down collections
      // 锁定集合
      resultMapping.flags = Collections.unmodifiableList(resultMapping.flags);
      resultMapping.composites = Collections.unmodifiableList(resultMapping.composites);
      // 处理结果类型
      resolveTypeHandler();
      // 验证
      validate();
      return resultMapping;
    }

    // 验证
    private void validate() {
      // 不能同时存在嵌套查询 和 嵌套映射
      if (resultMapping.nestedQueryId != null && resultMapping.nestedResultMapId != null) {
        throw new IllegalStateException("Cannot define both nestedQueryId and nestedResultMapId in property " + resultMapping.property);
      }
      // 没有嵌套查询和嵌套映射 并且没有类型处理器
      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
      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);
        }
      }
    }

    // 当TypeHandler为空时，根据javaType从Configuration获取对应的处理器
    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;
    }
  }

  // 省略一些 setter / getter 方法

  // 是否简单查询   
  // 判断条件为  不是嵌套映射 && 不是嵌套查询
  public boolean isSimple() {
    return this.nestedResultMapId == null && this.nestedQueryId == null && this.resultSet == null;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }

    ResultMapping that = (ResultMapping) o;

    return property != null && property.equals(that.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();
  }
}

三、枚举

ParameterMode 参数类型

public enum ParameterMode {
  // 输入 输出 输入输出
  IN, OUT, INOUT
}

SqlCommandType SQL类型

public enum SqlCommandType {
  UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
}

ResultFlag 结果标记

public enum ResultFlag {
  // 对应resultMap标签的id标签和constructor标签
  ID, CONSTRUCTOR
}

StatementType 类型

public enum StatementType {
  // 对应 Statement PreparedStatement
  // CallableStatement 负责存储函数的
  STATEMENT, PREPARED, CALLABLE
}

FetchType

public enum FetchType {
  // 懒加载  实时加载   默认值
  LAZY, EAGER, DEFAULT
}
为人师表好少年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
mybatis SqlCommandType 的深入了解
chengqisi0561的博客
05-28 1891
在一次开发中，意外发现mybatis的中的update元素下写着delete的sql语句（如下图），却能正常运行，为了搞清楚，特意了解下mysql的动态解析。 <update id="delete" parameterType="java.lang.Long"> DELETE...
Mybatis的源码初步理解——四大内置对象
weixin_45976188的博客
01-02 926
Mybatis四大内置对象的初步理解
Mybatis使用笔记（二）
qq_43310219的博客
08-29 1183
文章目录Mybatis查询之resultMap的使用一对一映射嵌套查询分布查询总结一对多映射嵌套查询分布查询 Mybatis查询之resultMap的使用 使用result的高级功能，一对一映射、一对多映射以及多对多映射 一对一映射对应的标签为association，一对多映射对应的标签为collection 一对一映射使用包装对象实现，例如：要查找学生和班级，但是学生信息以及班级信息在两个类中，可以将班级类型作为一个对象包装进入学生类中 @Data public class Student { p
[MyBatis源码分析系列] StatementType, ResultSetType, SqlCommandType, FetchType, ParameterMode等枚举类
weixin_36210698的博客
10-29 3901
StatementType public enum StatementType{ STATEMENT, PREPARED, CALLABLE; } 分别对应MySQL的普通语句，预处理语句，储存过程。 SqlCommandType public enum SqlCommandType { UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH; } 对...
Winform开发之SqlCommand常用属性和方法
m0_52722639的博客
12-09 239
/输出 Text 表示这是一条SQL语句 cmd.CommandText=CommandType.StoredProcedure/CommandType.Text。using (XmlReader reader = cmd.ExecuteXmlReader()) //由Command实例返回XmlReader的实例。//输出当前行的第一列，第二列数据。Console.WriteLine("本次执行影响行数为：" + cmd.EndExecuteNonQuery(result));
Mybatis源码分析
02-20
Mybatis源码分析 Mybatis是一款流行的持久化框架，提供了强大的SQL映射和缓存机制。本文将对Mybatis的源码进行分析，探究其运行原理、缓存机制和设计模式。 Mybatis简介 Mybatis是一个第一类持久化框架，支持...
深入浅出MyBatis技术原理与实战 第六章 源代码
07-30
在深入探讨MyBatis技术原理与实战的第六章中，我们主要关注的是MyBatis的源代码分析。MyBatis是一个流行的Java持久层框架，它提供了灵活的SQL映射功能，使得开发人员能够轻松地将数据库操作与业务逻辑集成在一起。这...
mybatis 练习源码（供自己练习使用）并非原创
07-02
4. **缓存机制**：MyBatis 内置了第一级和第二级缓存，可以提高数据读取效率。开发者可以根据需要自定义缓存策略。 5. **事务管理**：MyBatis 可以和 Spring 集成，利用 Spring 的事务管理功能，实现数据库事务的...
Spring+MyBatis 企业应用实战之人事管理系统源码
05-05
6. **DAO（Data Access Object）层**：DAO接口和其实现类负责与数据库交互，通常包含增删改查等基本操作。MyBatis的动态SQL使得DAO层的代码更加简洁。 7. **Service层**：服务层是业务逻辑的核心，它封装了多个DAO...
mybatis-generator 自动代码生成
08-15
MyBatis Generator（MBG）是一款强大的自动化代码生成工具，尤其在处理MyBatis框架相关的实体类、Mapper接口和XML映射文件时，能够显著提高开发效率。它可以从数据库中的表自动生成Java实体类、Mapper接口及对应的...
MyBatis工作流程-初始化阶段二
m0_37607945的博客
12-15 175
系列文章目录 MyBatis开发要点 MyBatis一级缓存 MyBatis二级缓存 MyBatis日志模块 MyBatis日志增强 MyBatis数据源 MyBatis缓存模块（二级缓存深入理解） MyBatis反射模块 MyBatis工作流程-初始化阶段一 MyBatis工作流程-初始化阶段二 文章目录系列文章目录 前言 mapper解析目标 mapper解析流程 总结 前言 在上一章节当中我们主要是讲解了MyBatis工作流程初始化阶段的第一步，解析配置文件。解析配置文件主要使用的XMLC
MyBatis的ResultMapping链式调用老大说好样的
qq_57756904的博客
03-21 2765
一、前言 这里啰嗦一下，实例方法就是没有static关键字的对象行为方法，有static关键字的就是静态方法可直接通过类名调用，构造方法就是与类名相同的方法， 上一篇文章《关于Java变量的类型权限选择与变量变更途径》我也提了链式调用，今天再次来聊聊这个链式调用。我们都知道类实例方法的调用，一般你得通过new获取对象实例，才能调用实例方法；同时我们也知道this关键字可表示对象实例。理解这些内容很关键的哦！！！ 当你读懂这些代码，某一天派上用场时，项目大佬肯定在心里暗暗惊叹，哎......
mybatis resultMap collection column 子查询用到父查询中的不存在的条件的传递参数问题
itrytellyou的博客
06-26 7639
mybatis resultMap collection column 子查询用到父查询中的不存在的条件的传递参数问题描述思路和解决例子展示注意 描述 标题描述的可能不够清晰，场景就是，在mybatis中，dao层传递了多个参数，有很多参数并不是父查询要是用的而是子查询要使用的，而且参数的类型可能为List或者String等，这个时候的解决方案。 思路和解决例子展示 我们可以在父查询时，将需要传递...
黑马程序员-sqlcommand中各参数含义
06-25 201
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 一、sqlcommand简介 sqlcommand表示要对SQL Server 数据库执行的一个Transact-SQL语句或存储过程。无法继承此类。 命名空间： System.Data.SqlClient 程序集：...
【设计模式】学习之创建型 建造者模式
tony_java_2017的博客
11-26 168
上一篇 我们学习了工厂模式 ，这一篇我们学习建造者模式，所谓建造者模式就是要我们像现实生活中的建筑建造者一样 一个步骤一个步骤地建造自己的伟大建筑，因为伟大的建筑都是复杂的。当我们要建造一个复杂的对象时，只能是一步一步的进行构造，而不能像平常那样，直接使用一个构造函数进行构造。接下来我们还是结合MyBatis源码学习该模式： 1. MappedStatement     该类是MyBatis中...
mybatis源码学习7---MappedStatement初始化过程
qq_45100361的博客
05-28 588
上一篇我们了解到了MappedStatement类就是mapper.xml中的一个sql语句，而Configuration初始化的时候会加载所有的mapper接口类，而本篇再分析下是如何将mapper接口和xml进行绑定的。 先从上一篇的源码开始分析： public <T> void addMapper(Class<T> type) { if (type.isInterface()) { if (hasMapper(type)) {
MyBatis高级查询
欧尼熊不懂 的博客
10-02 982
MyBatis高级查询功能：多表嵌套查询、复杂元素查询、引用类型元素查询使用介绍
JSF Validation Error: Value is not valid(值无效)错误解决一
xumingrencai
11-30 2054
问题提出： 平台：Richfaces,Jsf,Spring,Ejb3.0 页面文件: Html代码 &lt;h:selectOneListboxsize="1" value="#{coalDailyBackBean.currentEntity.coalDaily.coalTS}"converter="com.mycompany.CoalTransportSt...
Java基础（private中对于boolean类型的Getter特殊情况练习）
Money_bagZ的博客
04-22 1592
对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。 例如： package 类和对象; public class Demo05 { public static void main(String[] args) { Student stu = new Student(); stu.setName("鹿晗"); ...
mybatis 源码学习
最新发布
08-04
2. SQL语句解析与执行：MyBatis将SQL语句封装成MappedStatement对象进行管理，了解MappedStatement的生成过程，以及SQL语句的解析、参数处理和执行过程，可以深入了解MyBatis的SQL执行原理。 3. 会话管理和事务处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

为人师表好少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值