mybaits原始碼分析--型別轉換模組（三）

童話述說我的結局發表於2021-08-31

一、型別轉換模組

String sql = "SELECT id,user_name,real_name,password,age,d_id from t_user where
id = ? and user_name = ?";
ps = conn.prepareStatement(sql);
ps.setInt(1,2);
ps.setString(2,"張三");

MyBatis是一個持久層框架ORM框架，實現資料庫中資料和Java物件中的屬性的雙向對映，那麼不可避免的就會碰到型別轉換的問題，在PreparedStatement為SQL語句繫結引數時，需要從Java型別轉換為JDBC型別，而從結果集中獲取資料時，則需要從JDBC型別轉換為Java型別，所以來看下在MyBatis中是如何實現型別的轉換的。

1.1 TypeHandler

MyBatis中的所有的型別轉換器都繼承了TypeHandler介面，在TypeHandler中定義了型別轉換器的最基本的功能。

public interface TypeHandler<T> {

  /**
   * 負責將Java型別轉換為JDBC的型別
   * @param ps
   * @param i
   * @param parameter
   * @param jdbcType
   * @throws SQLException
   */
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * 從ResultSet中獲取資料時會呼叫此方法，會將資料由JdbcType轉換為Java型別
   * @param columnName Colunm name, when configuration <code>useColumnLabel</code> is <code>false</code>
   */
  T getResult(ResultSet rs, String columnName) throws SQLException;

  T getResult(ResultSet rs, int columnIndex) throws SQLException;

  T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}

1.2 BaseTypeHandler

為了方便使用者自定義TypeHandler的實現，在MyBatis中提供了BaseTypeHandler這個抽象類，它實現了TypeHandler介面，並繼承了TypeReference類
，

在BaseTypeHandler中的實現方法中實現了對null的處理，非空的處理是交給各個子類去實現的。這個在程式碼中很清楚的體現了出來

1.3 TypeHandler實現類

TypeHandler的實現類比較多，而且實現也都比較簡單。

以Integer為例

public class IntegerTypeHandler extends BaseTypeHandler<Integer> {
    @Override
    public void setNonNullParameter(PreparedStatement ps ,int i ,Integer parameter ,JdbcType jdbcType) throws SQLException {
        ps.setInt(i, parameter); // 實現引數的繫結
    }

    @Override
    public Integer getNullableResult(ResultSet rs ,String columnName) throws SQLException {
        int result = rs.getInt(columnName); // 獲取指定列的值
        return result == 0 && rs.wasNull() ? null : result;
    }

    @Override
    public Integer getNullableResult(ResultSet rs ,int columnIndex) throws SQLException {
        int result = rs.getInt(columnIndex); // 獲取指定列的值
        return result == 0 && rs.wasNull() ? null : result;
    }

    @Override
    public Integer getNullableResult(CallableStatement cs ,int columnIndex) throws SQLException {
        int result = cs.getInt(columnIndex); // 獲取指定列的值
        return result == 0 && cs.wasNull() ? null : result;
    }
}

1.4 TypeHandlerRegistry

通過前面的介紹可以發現在MyBatis中給我們提供的具體的型別轉換器實在是太多了，那麼在實際的使用時我們是如何知道使用哪個轉換器類處理的呢？實際上在MyBatis中是將所有的TypeHandler都儲存註冊在了TypeHandlerRegistry中的。首先注意宣告的相關屬性

然後在器構造方法中完成了系統提供的TypeHandler的註冊

注意的是register()方法，關鍵幾個實現如下

 private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
    // 獲取@MappedJdbcTypes註解
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {
      // 遍歷獲取註解中指定的 JdbcType 型別
      for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
        // 呼叫下一個過載的方法
        register(javaType, handledJdbcType, typeHandler);
      }
      if (mappedJdbcTypes.includeNullJdbcType()) {
        // JdbcType型別為空的情況
        register(javaType, null, typeHandler);
      }
    } else {
      register(javaType, null, typeHandler);
    }
  }

  public <T> void register(TypeReference<T> javaTypeReference, TypeHandler<? extends T> handler) {
    register(javaTypeReference.getRawType(), handler);
  }

  // java type + jdbc type + handler

  // Cast is required here
  @SuppressWarnings("cast")
  public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) {
    register((Type) type, jdbcType, handler);
  }

  /**
   *
   * @param javaType  Java 型別
   * @param jdbcType  Jdbc 型別
   * @param handler   這兩種型別對應的處理器
   */
  private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
    if (javaType != null) {// 如果不為空
      // 從 TypeHandle集合中根據Java型別來獲取對應的集合
      Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);
      if (map == null || map == NULL_TYPE_HANDLER_MAP) {
        // 如果沒有就建立一個新的
        map = new HashMap<>();
      }
      // 把對應的jdbc型別和處理器新增到map集合中
      map.put(jdbcType, handler);
      // 然後將 java型別和上面的map集合儲存到TypeHandle的容器中
      typeHandlerMap.put(javaType, map);
    }
    // 同時也把這個處理器新增到了 儲存有所有處理器的容器中
    allTypeHandlersMap.put(handler.getClass(), handler);
  }

有註冊的方法，當然也有從註冊器中獲取TypeHandler的方法，getTypeHandler方法，這個方法也有多個過載的方法，這裡過載的方法最終都會執行的方法是

  /**
   * 根據對應的Java型別和Jdbc型別來查詢對應的TypeHandle
   */
  private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
    if (ParamMap.class.equals(type)) {
      return null;
    }
    // 根據Java型別獲取對應的 Jdbc型別和TypeHandle的集合容器
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
    TypeHandler<?> handler = null;
    if (jdbcHandlerMap != null) {
      // 根據Jdbc型別獲取對應的 處理器
      handler = jdbcHandlerMap.get(jdbcType);
      if (handler == null) {
        // 獲取null對應的處理器
        handler = jdbcHandlerMap.get(null);
      }
      if (handler == null) {
        // #591
        handler = pickSoleHandler(jdbcHandlerMap);
      }
    }
    // type drives generics here
    return (TypeHandler<T>) handler;
  }

當然除了使用系統提供的TypeHandler以外，其實還可以建立我們自己的TypeHandler了

1.5 TypeAliasRegistry

在MyBatis的應用的時候會經常用到別名，這能大大簡化我們的程式碼，其實在MyBatis中是通過TypeAliasRegistry類管理的。首先在構造方法中會注入系統常見型別的別名

public class TypeAliasRegistry {

  // 儲存 型別和別名的對應關係
  private final Map<String, Class<?>> typeAliases = new HashMap<>();

  public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
  }

註冊的方法邏輯也比較簡單

  public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748 別名統一轉換為小寫
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
    }
    // 將 別名 和 型別 新增到 Map 集合中
    typeAliases.put(key, value);
  }

那麼在實際使用時通過package指定別名路徑和通過@Alisa註解來指定別名的操作是如何實現的呢？也在TypeAliasRegistry中有實現

  /**
   * 根據 packagename 來指定
   * @param packageName
   * @param superType
   */
  public void registerAliases(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for (Class<?> type : typeSet) {
      // Ignore inner classes and interfaces (including package-info.java)
      // Skip also inner classes. See issue #6
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(type);
      }
    }
  }

  /**
   * 掃描 @Alias註解
   * @param type
   */
  public void registerAlias(Class<?> type) {
    String alias = type.getSimpleName();
    // 掃描 @Alias註解
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      // 獲取註解中定義的別名名稱
      alias = aliasAnnotation.value();
    }
    registerAlias(alias, type);
  }

1.6 TypeHandler的應用

1.6.1 SqlSessionFactory

在構建SqlSessionFactory時，在Configuration物件例項化的時候在成員變數中完成了TypeHandlerRegistry和TypeAliasRegistry的例項化

在TypeHandlerRegistry的構造方法中完成了常用型別的TypeHandler的註冊

public TypeHandlerRegistry(Configuration configuration) {
    this.unknownTypeHandler = new UnknownTypeHandler(configuration);

    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());

    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());

    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());

    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());

    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());

    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());

    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());

    register(Reader.class, new ClobReaderTypeHandler());
    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());

    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());

    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());

    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

    register(InputStream.class, new BlobInputStreamTypeHandler());
    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());

    register(Object.class, unknownTypeHandler);
    register(Object.class, JdbcType.OTHER, unknownTypeHandler);
    register(JdbcType.OTHER, unknownTypeHandler);

    register(Date.class, new DateTypeHandler());
    register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());

    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

    register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());

    register(Instant.class, new InstantTypeHandler());
    register(LocalDateTime.class, new LocalDateTimeTypeHandler());
    register(LocalDate.class, new LocalDateTypeHandler());
    register(LocalTime.class, new LocalTimeTypeHandler());
    register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());
    register(OffsetTime.class, new OffsetTimeTypeHandler());
    register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());
    register(Month.class, new MonthTypeHandler());
    register(Year.class, new YearTypeHandler());
    register(YearMonth.class, new YearMonthTypeHandler());
    register(JapaneseDate.class, new JapaneseDateTypeHandler());

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }

在TypeAliasRegistry中完成了常用Java型別別名的註冊

 public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
  }

在Configuration的構造方法中會為各種常用的型別向TypeAliasRegistry中註冊型別別名資料

 public Configuration() {
    // 為型別註冊別名
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
    typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
    typeAliasRegistry.registerAlias("LRU", LruCache.class);
    typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
    typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

    typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

    typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
    typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

    typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
    typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
    typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
    typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
    typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
    typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
    typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

    typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
    typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
    languageRegistry.register(RawLanguageDriver.class);
  }

以上步驟完成了TypeHandlerRegistry和TypeAliasRegistry的初始化操作，然後在解析全域性配置檔案時會通過解析<typeAliases>標籤和<typeHandlers>標籤，可以註冊我們新增的別名和TypeHandler。

因為我們在全域性配置檔案中指定了對應的別名，那麼我們在對映檔案中就可以簡寫我們的型別了，這樣在解析對映檔案時，我們同樣也是需要做別名的處理的。在XMLStatementBuilder中

這個parameterType就可以是我們定義的別名，然後在 resolveClass中就會做對應的處理

  protected <T> Class<? extends T> resolveClass(String alias) {
    if (alias == null) {
      return null;
    }
    try {
      return resolveAlias(alias);//別名處理
    } catch (Exception e) {
      throw new BuilderException("Error resolving class. Cause: " + e, e);
    }
  }

  protected <T> Class<? extends T> resolveAlias(String alias) {
    return typeAliasRegistry.resolveAlias(alias); // 根據別名查詢真實的型別
  }

1.6.2 執行SQL語句

TypeHandler型別處理器使用比較多的地方應該是在給SQL語句中引數繫結值和查詢結果和物件中屬性對映的地方用到的比較多，首先進入DefaultParameterHandler中看看引數是如何處理的

  /**
   * 為SQL語句中的問號點位符繫結實參
   * @param ps
   */
  @Override
  public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    //取出SQL中的引數對映列表
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    //獲取對應的點位符
    if (parameterMappings != null) {
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        //過濾掉儲存過程中的輸出引數
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          //獲取引數型別對應的型別處理器
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
            //通過TypeHandler處理引數
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }

然後進入到DefaultResultSetHandler中的getRowValue方法中

 //
  // GET VALUE FROM ROW FOR SIMPLE RESULT MAP
  //

  private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
    // 和延遲載入有關的物件
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    // 建立該行記錄對映之後得到的結果物件，該結果物件的型別有<reslutMap> 節點的 type 屬性執行
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;
      // 是否允許進行自動對映
      if (shouldApplyAutomaticMappings(resultMap, false)) {
        // 自動對映
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
      }
      // 處理ResultMap中有對映關係的屬性
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    return rowValue;
  }

然後再進入applyAutomaticMappings方法中檢視

  private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
    // 獲取ResultSet中存在，但在ResultMap中沒有明確對映的列
    List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
    boolean foundValues = false;
    if (!autoMapping.isEmpty()) {
      for (UnMappedColumnAutoMapping mapping : autoMapping) {
        // 使用TypeHandler 獲取自定對映的列值
        final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
        if (value != null) {
          foundValues = true;
        }
        if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
          // gcode issue #377, call setter on nulls (value is not 'found')
          // 將自動對映的屬性值設定到結果物件中
          metaObject.setValue(mapping.property, value);
        }
      }
    }
    return foundValues;
  }

根據對應的TypeHandler返回對應型別的值。

2.3、mybatis原始碼分析-基礎模組之型別轉換
2018-09-12
MyBatis原始碼型別
mybaits原始碼分析--binding模組（五）
2021-09-06
AI原始碼
mybaits原始碼分析--快取模組（六）
2021-09-03
AI原始碼快取
mybaits原始碼分析--日誌模組（四）
2021-09-01
AI原始碼
myBatis原始碼解析-型別轉換篇（5）
2020-08-14
MyBatis原始碼型別
mybaits原始碼分析--事務管理（八）
2021-09-08
AI原始碼
mybaits原始碼分析--自定義外掛（七）
2021-09-03
AI原始碼
PostgreSQL 原始碼解讀（202）- 查詢#115(型別轉換)
2019-06-13
SQL原始碼型別
JavaScript資料型別分析及其轉換
2021-09-09
JavaScript資料型別
型別轉換
2024-08-19
型別
java- 型別-轉換：基本型別以及包裝型別的轉換
2020-10-31
Java型別
自學PHP筆記 (三) 型別轉換
2021-04-12
PHP筆記型別
自學PHP筆記(三) 型別轉換
2021-04-09
PHP筆記型別
資料型別,型別轉換
2024-04-08
資料型別
PostgreSQL 原始碼解讀（203）- 查詢#116(型別轉換實現)
2019-06-14
SQL原始碼型別
從原始碼分析Node的Cluster模組
2019-01-21
原始碼
Swoole 原始碼分析——Reactor 模組之 ReactorEpoll
2018-08-06
原始碼React
Swoole 原始碼分析——Client模組之Send
2019-05-12
原始碼client
Swoole 原始碼分析——Client模組之Connect
2019-05-14
原始碼client
Swoole 原始碼分析——Client模組之Recv
2019-05-14
原始碼client
JavaScript 模組化及 SeaJs 原始碼分析
2021-09-09
JavaScriptJS原始碼
Django（49）drf解析模組原始碼分析
2021-06-08
Django原始碼
Django（51）drf渲染模組原始碼分析
2021-06-08
Django原始碼
js型別轉換
2019-02-12
JS型別
型別轉換（cast）
2024-10-07
型別AST
Convert型別轉換
2024-08-10
型別
Javascript基礎之-強制型別轉換（三）
2019-02-16
JavaScript型別
PostgreSQL 原始碼解讀（210）- 隱式型別轉換(func_match_argtypes)
2019-07-16
SQL原始碼型別
PostgreSQL 原始碼解讀（209）- 隱式型別轉換(func_select_candidate)
2019-07-15
SQL原始碼型別
Presto原始碼分析之資料型別
2021-09-09
REST原始碼資料型別
Swoole 原始碼分析——Server 模組之 OpenSSL (下)
2018-09-22
原始碼Server
Swoole 原始碼分析——Server 模組之 OpenSSL (上)
2018-09-18
原始碼Server
(一) Mybatis原始碼分析-解析器模組
2020-04-19
MyBatis原始碼
Swoole 原始碼分析——Server模組之OpenSSL (上)
2019-05-12
原始碼Server
beego cache模組原始碼分析筆記四
2018-12-26
Go原始碼筆記
Django（48）drf請求模組原始碼分析
2021-06-07
Django原始碼
從位元組碼看java型別轉換【深入理解 (T[]) new Object[size] 】
2018-11-18
Java型別Object
Java資料型別及型別轉換
2020-11-27
Java資料型別