myBatis源码解析-类型转换篇（5）

前言

开始分析Type包前，说明下使用场景。数据构建语句使用PreparedStatement，需要输入的是jdbc类型，但我们一般写的是java类型。同理，数据库结果集返回的是jdbc类型，而我们需要java类型。这就涉及到一个类型转换问题，Type包就是解决这个问题。下面是Type包类图所在结构：

 

 

 

 源码解析

1. BaseTypeHandle - 类型处理器实现的基类

mybatis中的默认类型处理器，自定义类型处理器都继承自BaseTypeHandle。是分析类型处理器的关键，查看其类图如下：

 

 

 分析BaseTypeHandle前，分析其接口TypeHandle。

// 类型处理器接口，查询参数时将java类型转为jdbc类型。获取结果时将jdbc类型转问java类型。
public interface TypeHandler {
  // 设置查询参数，java类型转为jdbc类型
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;
  // 获取结果参数，jdbc转为java类型
  T getResult(ResultSet rs, String columnName) throws SQLException;

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

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

}

TypeHandler接口定义了参数转换的方法。查询时将java类型转为jdbc类型，获取结果时将jdbc类型转为java类型。

分析继承的抽象类,TypeReference,主要是获取泛型T的原生类型。

public abstract class TypeReference {

  private final Type rawType;   // 保存所处理的java原生类型、个人理解即T泛型的类型。

  protected TypeReference() {
    rawType = getSuperclassTypeParameter(getClass());
  }
  // rawType的获取过程。任务类型处理器都需要继承BaseTypeHandle,而BaseTypeHandle继承TypeReference,此处为了获取T的java类型。
  // 至于为什么使用这一变量，因为我们自定义类型处理器可以不指定java类型，只指定jdbc类型，这样java类型默认就是T类型。
  Type getSuperclassTypeParameter(Class clazz) {
    Type genericSuperclass = clazz.getGenericSuperclass();  // 获取分类，包括T。此处和getSuperClass的区别是，getSuperClass只返回直接父类，并不包括父类带的泛型T
    if (genericSuperclass instanceof Class) {  // 任何类型处理器都有泛型T，一直循环找，如果没找到，直接报错。
      // try to climb up the hierarchy until meet something useful
      if (TypeReference.class != genericSuperclass) {
        return getSuperclassTypeParameter(clazz.getSuperclass());
      }

      throw new TypeException("'" + getClass() + "' extends TypeReference but misses the type parameter. "
        + "Remove the extension or add a type parameter to it.");
    }

    Type rawType = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0]; // 获取泛型T的java类型
    // TODO remove this when Reflector is fixed to return Types
    if (rawType instanceof ParameterizedType) {  // ？自己debug没有进入到这一步，保留。个人理解是万一还是类型嵌套模式如user，还有泛型T。就再次获取T的java类型。
      rawType = ((ParameterizedType) rawType).getRawType();
    }

    return rawType;
  }
  
  public final Type getRawType() {
    return rawType;  // 返回解析的rawType
  }
  .....
}

TypeReference类提供了获取rawType的方法。对于我们自定义类型转换器，可以只输入要转换的jdbc类型，那默认的待转换java类型就是rawType类型。

接下来分析BaseTypeHandle,也是一个抽象类，查看其源码，主要实现了对输入参数，结果参数为空的处理，若不为空，则交给子类具体实现。

// 类型处理器基类，增加了输入参数为null时的处理
public abstract class BaseTypeHandler extends TypeReference implements TypeHandler {

  protected Configuration configuration;  // 全局配置参数

  public void setConfiguration(Configuration c) {
    this.configuration = c;
  }

  public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    if (parameter == null) {   // 对输入参数为null时的处理
      if (jdbcType == null) {  // jdbcType不能为空
        throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
      }
      try {
        ps.setNull(i, jdbcType.TYPE_CODE); // 将指定位置参数设置为空
      } catch (SQLException e) {
        throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . " +
                "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. " +
                "Cause: " + e, e);
      }
    } else {
      setNonNullParameter(ps, i, parameter, jdbcType); // 输入参数不为空的处理
    }
  }
  .......
  // 对非空参数需要子类实现。
  public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;

  public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;

  public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;

BaseTypeHandler其实只对空数据进行处理，非空数据交给子类实现，此处使用了模板设计模式。查看具体的类型处理器，如DateTypeHandle进行验证。

public class DateTypeHandler extends BaseTypeHandler { // 日期转换处理器，泛型T为java.util.date

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) 
      throws SQLException {
    ps.setTimestamp(i, new Timestamp((parameter).getTime()));  // 设置PreparedStatement，其实就是java类型转为数据库识别的jdbc类型
  }

  @Override
  public Date getNullableResult(ResultSet rs, String columnName)
      throws SQLException {
    Timestamp sqlTimestamp = rs.getTimestamp(columnName); // 获取指定列的结果
    if (sqlTimestamp != null) {
      return new Date(sqlTimestamp.getTime());  // 获取Date结果,jdbc类型转为java类型。
    }
    return null;
  }

类型处理器实现也很简单，是将java数据类型和数据库识别的jdbc类型的相互转换。其余的类型处理器太多了，暂且不分析了，大家感兴趣的可以自己看下。

2. TypeHandleRegistry - 类型处理器注册类

类型转换处理器定义完毕后，需要有个仓库进行注册，后续使用直接去拿即可。TypeHandleRegistry就是处理器注册的地方。现在对TypeHandleRegistry源码进行分析。

private static final Map, Class> reversePrimitiveMap = new HashMap, Class>() {
    private static final long serialVersionUID = 1L;
    {
      put(Byte.class, byte.class);
      put(Short.class, short.class);
      put(Integer.class, int.class);
      put(Long.class, long.class);
      put(Float.class, float.class);
      put(Double.class, double.class);
      put(Boolean.class, boolean.class);
      put(Character.class, char.class);
    }
  };
  // 数据库类型处理器map集合,jdbc类型为key,TypeHandle为value
  private final Map> JDBC_TYPE_HANDLER_MAP = new EnumMap>(JdbcType.class);
  // java类型处理器map集合，由此可知，一个java类型可以对应对个 jdbc类型
  private final Map>> TYPE_HANDLER_MAP = new HashMap>>();
  // 默认的未知类型处理器
  private final TypeHandler