myBatis源码解析-类型转换篇（5）
前言
开始分析Type包前，说明下使用场景。数据构建语句使用PreparedStatement，需要输入的是jdbc类型，但我们一般写的是java类型。同理，数据库结果集返回的是jdbc类型，而我们需要java类型。这就涉及到一个类型转换问题，Type包就是解决这个问题。下面是Type包类图所在结构：
源码解析
1. BaseTypeHandle<T> - 类型处理器实现的基类
mybatis中的默认类型处理器，自定义类型处理器都继承自BaseTypeHandle。是分析类型处理器的关键，查看其类图如下：
分析BaseTypeHandle<T>前，分析其接口TypeHandle。
// 类型处理器接口，查询参数时将java类型转为jdbc类型。获取结果时将jdbc类型转问java类型。 public interface TypeHandler<T> { // 设置查询参数，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>,主要是获取泛型T的原生类型。
public abstract class TypeReference<T> { private final Type rawType; // 保存所处理的java原生类型、个人理解即T泛型的类型。 protected TypeReference() { rawType = getSuperclassTypeParameter(getClass()); } // rawType的获取过程。任务类型处理器都需要继承BaseTypeHandle<T>,而BaseTypeHandle<T>继承TypeReference<T>,此处为了获取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。就再次获取T的java类型。 rawType = ((ParameterizedType) rawType).getRawType(); } return rawType; } public final Type getRawType() { return rawType; // 返回解析的rawType } ..... }
TypeReference<T>类提供了获取rawType的方法。对于我们自定义类型转换器，可以只输入要转换的jdbc类型，那默认的待转换java类型就是rawType类型。
接下来分析BaseTypeHandle<T>,也是一个抽象类，查看其源码，主要实现了对输入参数，结果参数为空的处理，若不为空，则交给子类具体实现。
// 类型处理器基类，增加了输入参数为null时的处理 public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> { 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<T>其实只对空数据进行处理，非空数据交给子类实现，此处使用了模板设计模式。查看具体的类型处理器，如DateTypeHandle进行验证。
public class DateTypeHandler extends BaseTypeHandler<Date> { // 日期转换处理器，泛型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<?>, Class<?>> reversePrimitiveMap = new HashMap<Class<?>, 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<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<JdbcType, TypeHandler<?>>(JdbcType.class); // java类型处理器map集合，由此可知，一个java类型可以对应对个 jdbc类型 private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>(); // 默认的未知类型处理器 private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this); // 所有类型的处理器 private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<Class<?>, TypeHandler<?>>();
分析完具体属性后，看具体注册方法。TypeHandleRegistry支持的注册方法有多种，重写的register（）方法就有很多种。一般注册我们需要提供转换的java类型和jdbc类型，具体的转换器。mybatis除了支持这种默认的注册方式外，还提供了如java类型+处理器，jdbc类型+处理器，单个处理器四种处理方法，一个个分析。
2.1 java类型+jdbc类型+处理器方法
// java type + jdbc type + handler public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) { register((Type) type, jdbcType, handler); } private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) { // 根据java类型，jdbc类型，typeHandle来注册 if (javaType != null) { // 若对应的java类型不为空 // 获取java类型对应的 jdbc+handle 集合 Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType); if (map == null) { // 若为空，则建立一个，并将此 jdbc+handle 集合放入TYPE_HANDLER_MAP中 map = new HashMap<JdbcType, TypeHandler<?>>(); TYPE_HANDLER_MAP.put(javaType, map); } map.put(jdbcType, handler); // 如果当前的java类型是基本数据类型的包装类（Integer,Long等），则将其对应的基本数据类型（int,long等)也注册进去 if (reversePrimitiveMap.containsKey(javaType)) { register(reversePrimitiveMap.get(javaType), jdbcType, handler); } } ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler); }
流程很简单，其余的注册方法基本会调用这个方法。流程如下：
2.2 java类型+处理器方法
public <T> void register(Class<T> javaType, TypeHandler<? extends T> typeHandler) { register((Type) javaType, typeHandler); } private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) { // 获取类型处理器中@MappedJdbcTypes注解，该注解作用是定义类型处理器所处理的jdbc类型列表 MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class); if (mappedJdbcTypes != null) { // 若没有定义，则默认为空 for (JdbcType handledJdbcType : mappedJdbcTypes.value()) { // 一个java类型可对应多个jdbc类型。 register(javaType, handledJdbcType, typeHandler); } if (mappedJdbcTypes.includeNullJdbcType()) { register(javaType, null, typeHandler); } } else { register(javaType, null, typeHandler); } }
java类型+处理器类型其实也是调用java类型+jdbc类型+处理器注册方法。只是提供了一个获取@MappedJdbcTypes注解的功能。此注解用在自定义处理器类，用来获取处理器指定的jdbc类型。
2.3 jdbc类型+处理器方法
public void register(JdbcType jdbcType, TypeHandler<?> handler) { JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler); // 在map中添加条记录而已 }
jdbc类型+处理器方法实际上只是在jdbc与处理器关联的map中放了条记录。
2.4 只提供处理器
// Only handler @SuppressWarnings("unchecked") public <T> void register(TypeHandler<T> typeHandler) { boolean mappedTypeFound = false; // 获取java类型，我们在自定义类型处理器使用@MappedTypes注解来定义我们要转换的java类型 MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class); if (mappedTypes != null) { // 若定义了转换的java类型 for (Class<?> handledType : mappedTypes.value()) { // 则遍历java类型的列表，在调用java类型+处理器类型的注册方法 register(handledType, typeHandler); mappedTypeFound = true; // 找到了待转换的java类型 } } // @since 3.1.0 - try to auto-discover the mapped type // 若没找到待注册的java类型且继承了TypeReference<T>。前文分析了，任何一个类型注册器都会继承TypeReference<T>，所以后面的判断条件会为true if (!mappedTypeFound && typeHandler instanceof TypeReference) { try { TypeReference<T> typeReference = (TypeReference<T>) typeHandler; register(typeReference.getRawType(), typeHandler); // 调用typeReference<T>.getRawType()其实获取的是泛型T的类型 mappedTypeFound = true; } catch (Throwable t) { // maybe users define the TypeReference with a different type and are not assignable, so just ignore it } } if (!mappedTypeFound) { register((Class<T>) null, typeHandler); // 调用java类型+处理器类型的注册方法 } }
此方法一般用于用户注册自定义处理器。综上分析，用户自己实现BaseTypeHandle<T>时，可以使用@MappedTypes注解来指定要转换的java类型，若没有指定，则默认为TypeReference<T>泛型T的java类型。也可以使用@MappedJdbcTypes注解来指定要转换的jdbc类型，若没有指定，则默认为null。这也是为什么网上很多自定义类型处理器有的使用了注解，有的没有使用注解。此处，算是做了一个解释。另外还需注意的是，通过JDBC_TYPE_HANDLER_MAP这一属性可知，对于一个java类型，其实支持多种jdbc类型与之对应。
总结
对于类型处理器这块，总体来说比较简单，分析起来较轻松。本来还打算写一篇事务包的分析，但发现mybatis其实自身没有实现任务事务的操作。仅是对数据库本身事务的简单封装。接下来准备开始分析session，execute数据库执行过程了，还得慢慢来。如觉得还可以，还请看官们点个赞支持下。
