2.3、mybatis源码分析-基础模块之类型转换

  • java数据类型和JDBC数据类型不是完全对等,在执行sql参数绑定和结果集处理时候需要进行Java和JDBC之间的类型转换。
  • 在Mybatis中使用类处理器来完成上述的两种转换。

一、TypeHandler

在myabtis中一般情况下TypeHandler用于完成单个参数以及单个列值得类型转换,在mybatis中所有的类型转换器都继承了TypeHandler接口。

1、TypeHandler接口

public interface TypeHandler {
//负责将数据由JdbcType转为Java类型
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;
//将Java转为JdbcType类型
  T getResult(ResultSet rs, String columnName) throws SQLException;
  T getResult(ResultSet rs, int columnIndex) throws SQLException;
  T getResult(CallableStatement cs, int columnIndex) throws SQLException;
}

2、BaseTypeHandler实现该接口并继承TypeRefrence抽象类

  • 来看BaseTypeHandler具体实现了类型转换的两个方法
1.负责将数据由JdbcType转为Java类型
 public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    if (parameter == null) {
      if (jdbcType == null) {
        throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
      }
      try {
      //绑定参数为null的处理
        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);
    }
  }
2.将Java转为JdbcType类型
 public T getResult(ResultSet rs, String columnName) throws SQLException {
    //抽象方法,由子类实现
    T result = getNullableResult(rs, columnName);
    if (rs.wasNull()) {
      return null;
    } else {
      return result;
    }
  }

3、BaseTypeHandler子类

  • 子类很多,大多数是直接调用PrepareStatement和ResultSet或者CallableStatement的对应方法
  • 以IntegerTypeHandler为例子介绍
@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 {
//根据结果集获取数据
    return rs.getInt(columnName);
  }

二、TypeHandlerRegistry

  • 用于管理TypeHandler和实现TypeHandler注册
    1、属性及构造函数
1、重点属性
//记录jdbcType和TypeHandler之间的对应关系,用于从数据集读取数据时候将数据从jdbc类转为java类型
  private final Map> JDBC_TYPE_HANDLER_MAP = new EnumMap>(JdbcType.class);
  //记录java类型向jdbcType转换,需要使用到TypeHandler
  private final Map>> TYPE_HANDLER_MAP = new HashMap>>();
 //记录了全部TypeHandler的类型以及该类型相应的TypeHandler对象
  private final TypeHandler UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);
   //空TypeHandler集合的标识
  private final Map, TypeHandler> ALL_TYPE_HANDLERS_MAP = new HashMap, TypeHandler>();
2、构造函数
 //构造函数中已经完成了很多类型的注册
 public TypeHandlerRegistry() {
    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());
    ..........
}
 
 

2、TypeHandler的注册

有很多的register的重载方法,大多数会最终会调用下面的方法完成注册
 private void register(Type javaType, JdbcType jdbcType, TypeHandler handler) {
    if (javaType != null) {
      Map> map = TYPE_HANDLER_MAP.get(javaType);
      if (map == null || map == NULL_TYPE_HANDLER_MAP) {
        map = new HashMap>();
        TYPE_HANDLER_MAP.put(javaType, map);
      }
      map.put(jdbcType, handler);
    }
    ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
  }

3、查找TypeHandler

private  TypeHandler getTypeHandler(Type type, JdbcType jdbcType) {
    if (ParamMap.class.equals(type)) {
      return null;
    }
//获取JdbcType、TypeHandler映射关系的map
    Map> jdbcHandlerMap = getJdbcHandlerMap(type);
    TypeHandler handler = null;
    if (jdbcHandlerMap != null) {
      handler = jdbcHandlerMap.get(jdbcType);
      if (handler == null) {
        handler = jdbcHandlerMap.get(null);
      }
      if (handler == null) {
        // 如果只是注册了一个Typehandler则使用此Typehandler对象
        handler = pickSoleHandler(jdbcHandlerMap);
      }
    }
    return (TypeHandler) handler;
  }
---------------------------------------------------------------
1.获取JdbcType、TypeHandler映射关系的map
  private Map> getJdbcHandlerMap(Type type) {
  //查找java对应的TypeHandler集合
    Map> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
    if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {
      return null;
    }
    if (jdbcHandlerMap == null && type instanceof Class) {
      Class clazz = (Class) type;
      if (clazz.isEnum()) {
      //如果是枚举类型,查找父接口对应的TypeHandler集合,作为初始化集合
        jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);
        if (jdbcHandlerMap == null) {
          register(clazz, getInstance(clazz, defaultEnumTypeHandler));
          return TYPE_HANDLER_MAP.get(clazz);
        }
      } else {
       //查找父类对应的TypeHandler集合,作为初始化集合
        jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
      }
    }
    TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
    return jdbcHandlerMap;
  }
  private Map> getJdbcHandlerMapForEnumInterfaces(Class clazz, Class enumClazz) {
    for (Class iface : clazz.getInterfaces()) {
      Map> jdbcHandlerMap = TYPE_HANDLER_MAP.get(iface);
      if (jdbcHandlerMap == null) {
      //递归调用
        jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);
      }
      if (jdbcHandlerMap != null) {
        // Found a type handler regsiterd to a super interface
        HashMap> newMap = new HashMap>();
        for (Entry> entry : jdbcHandlerMap.entrySet()) {
          // Create a type handler instance with enum type as a constructor arg
          newMap.put(entry.getKey(), getInstance(enumClazz, entry.getValue().getClass()));
        }
        return newMap;
      }
    }
    return null;
  }

  private Map> getJdbcHandlerMapForSuperclass(Class clazz) {
    Class superclass =  clazz.getSuperclass();
    if (superclass == null || Object.class.equals(superclass)) {
      return null;
    }
    Map> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);
    if (jdbcHandlerMap != null) {
      return jdbcHandlerMap;
    } else {
    //递归
      return getJdbcHandlerMapForSuperclass(superclass);
    }
  }
2、如果只是注册了一个Typehandler则使用此Typehandler对象
  private TypeHandler pickSoleHandler(Map> jdbcHandlerMap) {
    TypeHandler soleHandler = null;
    for (TypeHandler handler : jdbcHandlerMap.values()) {
      if (soleHandler == null) {
        soleHandler = handler;
      } else if (!handler.getClass().equals(soleHandler.getClass())) {
        // More than one type handlers registered.
        return null;
      }
    }
    return soleHandler;
  }
  • 同样还可以在config配置文件中自定义TypeHandler接口实现类,mybatis
    初始化时候会自动注册到TypeHandlerRegistry。

三、TypeAliaRegistry

  • 别名注册类型,通过该类完成别名注册和管理功能。主要通过TYPE_ALIASES字段管理别名和Java类型直接的对对应关系
  • 构造器中默认注册了很多的别名
    通过registerAliases完成别名注册

  //扫面指定包下面的所有类,并为执行类添加别名
  public void registerAliases(String packageName, Class superType){
    ResolverUtil> resolverUtil = new ResolverUtil>();
    //查找指定包下的superType类型对象
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set>> typeSet = resolverUtil.getClasses();
    for(Class type : typeSet){
      // 过滤掉内部类及接口欧和抽象类
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(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);
  }
 public void registerAlias(String alias, Class value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // 忽略大小写
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    TYPE_ALIASES.put(key, value);
  }

四、总结

在mybatis中定义了一套机制来出来相关的类型转换
1、使用TypeHandler接口定义了JDBCType和JavaType之间的转换关系
2、使用TypeHandlerRegistry来对TypeHandler进行注册和管理
3、使用TypeAliaRegistry来进行mybatis中类别名的注册和管理

你可能感兴趣的:(2.3、mybatis源码分析-基础模块之类型转换)