上篇文章《深入浅出Mybatis系列(四)---配置详解之typeAliases别名(mybatis源码篇)》为大家介绍了mybatis中别名的使用,以及其源码。本篇将为大家介绍TypeHandler, 并简单分析其源码。
那么,Mybatis为我们实现了哪些TypeHandler呢? 我们怎么自定义实现一个TypeHandler ? 这些都会在接下来的mybatis的源码中看到。
=========================================================我是源码分割线==========================================================
/**
* 解析typeHandlers节点
*/
private void typeHandlerElement(XNode parent) throws Exception {
if (parent != null ) {
for (XNode child : parent.getChildren()) {
// 子节点为package时,获取其name属性的值,然后自动扫描package下的自定义typeHandler
if ("package".equals(child.getName())) {
String typeHandlerPackage = child.getStringAttribute("name");
typeHandlerRegistry.register(typeHandlerPackage);
} else {
// 子节点为typeHandler时, 可以指定javaType属性, 也可以指定jdbcType, 也可两者都指定
// javaType 是指定java类型
// jdbcType 是指定jdbc类型(数据库类型: 如varchar)
String javaTypeName = child.getStringAttribute("javaType");
String jdbcTypeName = child.getStringAttribute("jdbcType");
// handler就是我们配置的typeHandler
String handlerTypeName = child.getStringAttribute("handler");
// resolveClass方法就是我们上篇文章所讲的TypeAliasRegistry里面处理别名的方法
Class> javaTypeClass = resolveClass(javaTypeName);
// JdbcType是一个枚举类型,resolveJdbcType方法是在获取枚举类型的值
JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
Class > typeHandlerClass = resolveClass(handlerTypeName);
// 注册typeHandler, typeHandler通过TypeHandlerRegistry这个类管理
if (javaTypeClass != null ) {
if (jdbcType == null ) {
typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
} else {
typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
}
} else {
typeHandlerRegistry.register(typeHandlerClass);
}
}
}
}
}
/**
* typeHandler注册管理类
*/
public final class TypeHandlerRegistry {
// 源码一上来,二话不说,几个大大的HashMap就出现,这不又跟上次讲的typeAliases的注册类似么
// 基本数据类型与其包装类
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不用说就知道存的是什么东西吧,命名的好处
private final Map> JDBC_TYPE_HANDLER_MAP = new EnumMap>(JdbcType.class );
private final Map>> TYPE_HANDLER_MAP = new HashMap>>();
private final TypeHandler UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this );
private final Map, TypeHandler>> ALL_TYPE_HANDLERS_MAP = new HashMap, TypeHandler>>();
// 就像上篇文章讲的typeAliases一样,mybatis也默认给我们注册了不少的typeHandler
// 具体如下
public TypeHandlerRegistry() {
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(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 ClobTypeHandler());
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 ClobTypeHandler());
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(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 , UNKNOWN_TYPE_HANDLER);
register(Object. class , JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
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());
// issue #273
register(Character.class , new CharacterTypeHandler());
register( char .class , new CharacterTypeHandler());
}
public boolean hasTypeHandler(Class> javaType) {
return hasTypeHandler(javaType, null );
}
public boolean hasTypeHandler(TypeReference> javaTypeReference) {
return hasTypeHandler(javaTypeReference, null );
}
public boolean hasTypeHandler(Class> javaType, JdbcType jdbcType) {
return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null ;
}
public boolean hasTypeHandler(TypeReference> javaTypeReference, JdbcType jdbcType) {
return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null ;
}
public TypeHandler> getMappingTypeHandler(Class extends TypeHandler>> handlerType) {
return ALL_TYPE_HANDLERS_MAP.get(handlerType);
}
public TypeHandler getTypeHandler(Class type) {
return getTypeHandler((Type) type, null );
}
public TypeHandler getTypeHandler(TypeReference javaTypeReference) {
return getTypeHandler(javaTypeReference, null );
}
public TypeHandler> getTypeHandler(JdbcType jdbcType) {
return JDBC_TYPE_HANDLER_MAP.get(jdbcType);
}
public TypeHandler getTypeHandler(Class type, JdbcType jdbcType) {
return getTypeHandler((Type) type, jdbcType);
}
public TypeHandler getTypeHandler(TypeReference javaTypeReference, JdbcType jdbcType) {
return getTypeHandler(javaTypeReference.getRawType(), jdbcType);
}
private TypeHandler getTypeHandler(Type type, JdbcType jdbcType) {
Map > jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
TypeHandler > handler = null ;
if (jdbcHandlerMap != null ) {
handler = jdbcHandlerMap.get(jdbcType);
if (handler == null ) {
handler = jdbcHandlerMap.get(null );
}
}
if (handler == null && type != null && type instanceof Class && Enum.class .isAssignableFrom((Class>) type)) {
handler = new EnumTypeHandler((Class>) type);
}
@SuppressWarnings( "unchecked")
// type drives generics here
TypeHandler returned = (TypeHandler) handler;
return returned;
}
public TypeHandler getUnknownTypeHandler() {
return UNKNOWN_TYPE_HANDLER;
}
public void register(JdbcType jdbcType, TypeHandler> handler) {
JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
}
//
// REGISTER INSTANCE
//
/**
* 只配置了typeHandler, 没有配置jdbcType 或者javaType
*/
@SuppressWarnings( "unchecked")
public void register(TypeHandler typeHandler) {
boolean mappedTypeFound = false ;
// 在自定义typeHandler的时候,可以加上注解MappedTypes 去指定关联的javaType
// 因此,此处需要扫描MappedTypes注解
MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class );
if (mappedTypes != null ) {
for (Class> handledType : mappedTypes.value()) {
register(handledType, typeHandler);
mappedTypeFound = true ;
}
}
// @since 3.1.0 - try to auto-discover the mapped type
if (!mappedTypeFound && typeHandler instanceof TypeReference) {
try {
TypeReference typeReference = (TypeReference) typeHandler;
register(typeReference.getRawType(), typeHandler);
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 ) null , typeHandler);
}
}
/**
* 配置了typeHandlerhe和javaType
*/
public void register(Class javaType, TypeHandler extends T> typeHandler) {
register((Type) javaType, typeHandler);
}
private void register(Type javaType, TypeHandler extends T> typeHandler) {
// 扫描注解MappedJdbcTypes
MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class );
if (mappedJdbcTypes != null ) {
for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
register(javaType, handledJdbcType, typeHandler);
}
if (mappedJdbcTypes.includeNullJdbcType()) {
register(javaType, null , typeHandler);
}
} else {
register(javaType, null , typeHandler);
}
}
public void register(TypeReference javaTypeReference, TypeHandler extends T> handler) {
register(javaTypeReference.getRawType(), handler);
}
/**
* typeHandlerhe、javaType、jdbcType都配置了
*/
public void register(Class type, JdbcType jdbcType, TypeHandler extends T> handler) {
register((Type) type, jdbcType, handler);
}
/**
* 注册typeHandler的核心方法
* 就是向Map新增数据而已
*/
private void register(Type javaType, JdbcType jdbcType, TypeHandler> handler) {
if (javaType != null ) {
Map > map = TYPE_HANDLER_MAP.get(javaType);
if (map == null ) {
map = new HashMap>();
TYPE_HANDLER_MAP.put(javaType, map);
}
map.put(jdbcType, handler);
if (reversePrimitiveMap.containsKey(javaType)) {
register(reversePrimitiveMap.get(javaType), jdbcType, handler);
}
}
ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
}
//
// REGISTER CLASS
//
// Only handler type
public void register(Class> typeHandlerClass) {
boolean mappedTypeFound = false ;
MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class );
if (mappedTypes != null ) {
for (Class> javaTypeClass : mappedTypes.value()) {
register(javaTypeClass, typeHandlerClass);
mappedTypeFound = true ;
}
}
if (!mappedTypeFound) {
register(getInstance( null , typeHandlerClass));
}
}
// java type + handler type
public void register(Class> javaTypeClass, Class> typeHandlerClass) {
register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
}
// java type + jdbc type + handler type
public void register(Class> javaTypeClass, JdbcType jdbcType, Class> typeHandlerClass) {
register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));
}
// Construct a handler (used also from Builders)
@SuppressWarnings( "unchecked")
public TypeHandler getInstance(Class> javaTypeClass, Class> typeHandlerClass) {
if (javaTypeClass != null ) {
try {
Constructor > c = typeHandlerClass.getConstructor(Class.class );
return (TypeHandler) c.newInstance(javaTypeClass);
} catch (NoSuchMethodException ignored) {
// ignored
} catch (Exception e) {
throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);
}
}
try {
Constructor > c = typeHandlerClass.getConstructor();
return (TypeHandler) c.newInstance();
} catch (Exception e) {
throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);
}
}
/**
* 根据指定的pacakge去扫描自定义的typeHander,然后注册
*/
public void register(String packageName) {
ResolverUtil > resolverUtil = new ResolverUtil>();
resolverUtil.find( new ResolverUtil.IsA(TypeHandler.class ), packageName);
Set extends Class>>> handlerSet = resolverUtil.getClasses();
for (Class> type : handlerSet) {
// Ignore inner classes and interfaces (including package-info.java) and abstract classes
if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
register(type);
}
}
}
// get information
/**
* 通过configuration对象可以获取已注册的所有typeHandler
*/
public Collection> getTypeHandlers() {
return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
}
}
由源码可以看到, mybatis为我们实现了那么多TypeHandler, 随便打开一个TypeHandler,看其源码,都可以看到,它继承自一个抽象类:BaseTypeHandler, 那么我们是不是也能通过继承BaseTypeHandler,从而实现自定义的TypeHandler ? 答案是肯定的, 那么现在下面就为大家演示一下自定义TypeHandler:
=====================================================自定义TypeHandler分割线============================================================
@MappedJdbcTypes(JdbcType.VARCHAR) //此处如果不用注解指定jdbcType, 那么,就可以在配置文件中通过"jdbcType"属性指定, 同理, javaType 也可通过 @MappedTypes指定
public class ExampleTypeHandler extends BaseTypeHandler {
@Override
public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
ps.setString(i, parameter);
}
@Override
public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
return rs.getString(columnName);
}
@Override
public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
return rs.getString(columnIndex);
}
@Override
public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
return cs.getString(columnIndex);
}
}