上篇文章《深入淺出Mybatis系列（四）---配置詳解之typeAliases別名（mybatis源碼篇）》為大家介紹了mybatis中別名的使用，以及其源碼。本篇將為大家介紹TypeHandler， 並簡單分析其原始碼。
Mybatis中的TypeHandler是什麼？
無論是MyBatis 在預處理語句（PreparedStatement）中設定一個參數時，或是從結果集中取出一個值時，都會用類型處理器將取得的值以適當的方式轉換成Java類型。 Mybatis預設為我們實作了許多TypeHandler, 當我們沒有配置指定TypeHandler時，Mybatis會根據參數或傳回結果的不同，預設為我們選擇合適的TypeHandler處理。
那麼，Mybatis為我們實作了哪些TypeHandler呢? 我們怎麼自訂實作一個TypeHandler ? 這些都會在接下來的mybatis的原始碼中看到。
在看原始碼之前，還是像之前一樣，先看看怎麼配置吧？
配置TypeHandler:
<configuration>
<typehandlers>
<!--
当配置package的时候，mybatis会去配置的package扫描TypeHandler
<package name="com.dy.demo"/> -->
<!-- handler属性直接配置我们要指定的TypeHandler -->
<typehandler></typehandler>
<!-- javaType 配置java类型，例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->
<typehandler></typehandler>
<!-- jdbcType 配置数据库基本数据类型，例如varchar, 如果配上jdbcType, 那么指定的typeHandler就只作用于指定的类型 -->
<typehandler></typehandler>
<!-- 也可两者都配置 -->
<typehandler></typehandler>
</typehandlers>
......
</configuration>
上面簡單介紹了一下TypeHandler, 下面就看看mybatis中TypeHandler的源碼了。
=================================== ======================我是源碼分割線========================= ===================================
老規矩，先從對xml的解析講起：
/**
* 解析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的管理註冊類別：
TypeHandlerRegistry：
/**
* typeHandler注册管理类 */public final class TypeHandlerRegistry {
//源码一上来，二话不说，几个大大的HashMap就出现，这不又跟上次讲的typeAliases的注册类似么
//基本数据类型与其包装类
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不用说就知道存的是什么东西吧，命名的好处
private final Map<jdbctype>> JDBC_TYPE_HANDLER_MAP = new EnumMap<jdbctype>>(JdbcType.class); private final Map<type>>> TYPE_HANDLER_MAP = new HashMap<type>>>(); private final TypeHandler<object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this); private final Map<class>, TypeHandler>> ALL_TYPE_HANDLERS_MAP = new HashMap<class>, 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 <t> TypeHandler<t> getTypeHandler(Class<t> type) { return getTypeHandler((Type) type, null);
} public <t> TypeHandler<t> getTypeHandler(TypeReference<t> javaTypeReference) { return getTypeHandler(javaTypeReference, null);
} public TypeHandler> getTypeHandler(JdbcType jdbcType) { return JDBC_TYPE_HANDLER_MAP.get(jdbcType);
} public <t> TypeHandler<t> getTypeHandler(Class<t> type, JdbcType jdbcType) { return getTypeHandler((Type) type, jdbcType);
} public <t> TypeHandler<t> getTypeHandler(TypeReference<t> javaTypeReference, JdbcType jdbcType) { return getTypeHandler(javaTypeReference.getRawType(), jdbcType);
} private <t> TypeHandler<t> getTypeHandler(Type type, JdbcType jdbcType) {
Map<jdbctype>> 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<t> returned = (TypeHandler<t>) handler; return returned;
} public TypeHandler<object> 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 <t> void register(TypeHandler<t> 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<t> typeReference = (TypeReference<t>) 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<t>) null, typeHandler);
}
} /**
* 配置了typeHandlerhe和javaType */
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
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 <t> void register(TypeReference<t> javaTypeReference, TypeHandler extends T> handler) {
register(javaTypeReference.getRawType(), handler);
} /**
* typeHandlerhe、javaType、jdbcType都配置了 */
public <t> void register(Class<t> 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<jdbctype>> map = TYPE_HANDLER_MAP.get(javaType);
if (map == null) {
map = new HashMap<jdbctype>>();
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 <t> TypeHandler<t> getInstance(Class> javaTypeClass, Class> typeHandlerClass) { if (javaTypeClass != null) { try {
Constructor> c = typeHandlerClass.getConstructor(Class.class);
return (TypeHandler<t>) 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<t>) 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<class>> resolverUtil = new ResolverUtil<class>>();
resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
Set<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<typehandler>> getTypeHandlers() {
return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
}
}</typehandler></class></class></class></t></t></t></t></jdbctype></jdbctype></t></t></t></t></t></t></t></t></t></t></t></t></object></t></t></jdbctype></t></t></t></t></t></t></t></t></t></t></t></t></t></t></class></class></object></type></type></jdbctype></jdbctype></class></class>
由原始碼可以看到， mybatis為我們實作了那麼多TypeHandler, 隨便開啟一個TypeHandler，看其原始碼，都可以看到，它繼承自一個抽象類別：BaseTypeHandler，那我們是不是也能透過繼承BaseTypeHandler，從而實現自訂的TypeHandler ? 答案是肯定的， 那麼現在下面就為大家示範一下自訂TypeHandler:
==== =================================================定義TypeHandler分割線============================================== ===============
ExampleTypeHandler:
@MappedJdbcTypes(JdbcType.VARCHAR)
//此处如果不用注解指定jdbcType, 那么，就可以在配置文件中通过"jdbcType"属性指定， 同理， javaType 也可通过 @MappedTypes指定public class ExampleTypeHandler extends BaseTypeHandler<string> {
@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);
}
}</string>
然後，就該配置我們的自訂TypeHandler了：
<configuration> <typehandlers> <!-- 由于自定义的TypeHandler在定义时已经通过注解指定了jdbcType, 所以此处不用再配置jdbcType --> <typehandler></typehandler> </typehandlers> ...... </configuration>
也就是說，我們在自訂TypeHandler的時候，可以在TypeHandler透過@MappedJdbcTypes指定jdbcType, 通過@MappedTypes 指定javaType, 如果沒有使用註解指定，那麼我們就需要在設定檔中設定。
好啦，這篇文章到此結束。
以上就是深入淺出Mybatis系列（五）---TypeHandler簡介及設定（mybatis原始碼篇）的內容，更多相關內容請關注PHP中文網（www.php.cn）！
陳述
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
熱AI工具
Undresser.AI Undress
人工智慧驅動的應用程序，用於創建逼真的裸體照片
AI Clothes Remover
用於從照片中去除衣服的線上人工智慧工具。
Undress AI Tool
免費脫衣圖片
Clothoff.io
AI脫衣器
AI Hentai Generator
免費產生 AI 無盡。
熱門文章
刺客信條陰影：貝殼謎語解決方案
3 週前ByDDD
Windows 11 KB5054979中的新功能以及如何解決更新問題
2 週前ByDDD
在哪裡可以找到原子中的起重機控制鑰匙卡
3 週前ByDDD
節省R.E.P.O.解釋（並保存文件）
1 個月前By尊渡假赌尊渡假赌尊渡假赌
刺客信條陰影 - 如何找到鐵匠，解鎖武器和裝甲定制
4 週前ByDDD
熱工具
SublimeText3漢化版
中文版，非常好用
Dreamweaver Mac版
視覺化網頁開發工具
Atom編輯器mac版下載
最受歡迎的的開源編輯器
SublimeText3 Mac版
神級程式碼編輯軟體(SublimeText3)
MinGW - Minimalist GNU for Windows
這個專案正在遷移到osdn.net/projects/mingw的過程中，你可以繼續在那裡關注我們。 MinGW：GNU編譯器集合（GCC）的本機Windows移植版本，可自由分發的導入函式庫和用於建置本機Windows應用程式的頭檔；包括對MSVC執行時間的擴展，以支援C99功能。 MinGW的所有軟體都可以在64位元Windows平台上運作。
