前言
目前水平有限,但是又想多看看源码,所以很多地方对于框架的代码不是很理解,本篇及后续的文章主要是对自己阅读源码的一个记录,希望对有些同学有帮助,总之一句话只做参考,别无它用.还是建议喜欢编程的同学多看看源码,一方面增加自己的认知,另一方面在模仿中创新.
下面的代码
导读
- 代码对一些比较中的的节点或者方法进行注释
- 列出TypeHandlerRegistry类.该类主要用于在mybatis中注册Java类型/jdbc类型/类型处理器之间映射(例如:Java类型使用Integer/jdbc类型使用int/类型处理器使用IntegerTypeHandler)
①//类型处理器注册器
public final class TypeHandlerRegistry {
private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<JdbcType, TypeHandler<?>>(JdbcType.class);//JDBC_TYPE_HANDLER_MAP用于保存JdbcType类型与类型处理器之间的映射关系,使用枚举哈希数据保存(我觉得可能是因为数据库的JdbcType类型就那些个使用EnumMap可以完全表示而且是哈希表中效率最高的一种)
private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<Type, Map<JdbcType, TypeHandler<?>>>();//TYPE_HANDLER_MAP用于保存JavaType与JdbcType以及TypeHandler之间的映射关系,后续每种JavaType与jdbcType之间进行类型转换使用的类型处理器全部取于此处
private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);//未知类型类型处理器
private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<Class<?>, TypeHandler<?>>();/这是一个以类型处理器本身的class对象为key,类型处理器为value的统管所有类型处理器
private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();//null类型处理器
private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;//枚举类型处理器
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(Reader.class, new ClobReaderTypeHandler());
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(InputStream.class, new BlobInputStreamTypeHandler());
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());
// mybatis-typehandlers-jsr310//JSR310是Java8关于日期时间的标准API,例如相比之前新增的LocalDateTime等
if (Jdk.dateAndTimeApiExists) {
this.register(Instant.class, InstantTypeHandler.class);
this.register(LocalDateTime.class, LocalDateTimeTypeHandler.class);
this.register(LocalDate.class, LocalDateTypeHandler.class);
this.register(LocalTime.class, LocalTimeTypeHandler.class);
this.register(OffsetDateTime.class, OffsetDateTimeTypeHandler.class);
this.register(OffsetTime.class, OffsetTimeTypeHandler.class);
this.register(ZonedDateTime.class, ZonedDateTimeTypeHandler.class);
this.register(Month.class, MonthTypeHandler.class);
this.register(Year.class, YearTypeHandler.class);
this.register(YearMonth.class, YearMonthTypeHandler.class);
this.register(JapaneseDate.class, JapaneseDateTypeHandler.class);
}
// issue #273
register(Character.class, new CharacterTypeHandler());
register(char.class, new CharacterTypeHandler());
}
/**
* Set a default {@link TypeHandler} class for {@link Enum}.
* A default {@link TypeHandler} is {@link org.apache.ibatis.type.EnumTypeHandler}.
* @param typeHandler a type handler class for {@link Enum}
* @since 3.4.5
*/
public void setDefaultEnumTypeHandler(Class<? extends TypeHandler> typeHandler) {
this.defaultEnumTypeHandler = typeHandler;
}
public boolean hasTypeHandler(Class<?> javaType) {
return hasTypeHandler(javaType, null);//判断给定的javaType是否有映射的类型处理器
}
public boolean hasTypeHandler(TypeReference<?> javaTypeReference) {
return hasTypeHandler(javaTypeReference, null);//判断给定的javaType是否有映射的类型处理器
}
public boolean hasTypeHandler(Class<?> javaType, JdbcType jdbcType) {
return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null;//判断给定的javaType与jdbcType是否有映射的类型处理器
}
public boolean hasTypeHandler(TypeReference<?> javaTypeReference, JdbcType jdbcType) {
return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null;//判断给定的javaType与jdbcType是否有映射的类型处理器
}
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);//获取指定javaType映射的类型处理器
}
public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference) {
return getTypeHandler(javaTypeReference, null);//获取指定javaType映射的类型处理器
}
public TypeHandler<?> getTypeHandler(JdbcType jdbcType) {
return JDBC_TYPE_HANDLER_MAP.get(jdbcType);//获取指定jdbcType类型映射的类型处理器
}
public <T> TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType) {
return getTypeHandler((Type) type, jdbcType);//获取指定JavaType与jdbcType映射的类型处理器
}
public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference, JdbcType jdbcType) {
return getTypeHandler(javaTypeReference.getRawType(), jdbcType);//获取指定JavaType与jdbcType映射的类型处理器
}
@SuppressWarnings("unchecked")
private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
if (ParamMap.class.equals(type)) {若JavaType为ParamMap.class,返回null(不理解).ParamMap就是HashMap<String,V>
return null;
}
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);//若JavaType不为ParamMap.class,根据type为键获取TYPE_HANDLER_MAP中映射的value-->>Map<JdbcType, TypeHandler<?>>
TypeHandler<?> handler = null;
if (jdbcHandlerMap != null) {
handler = jdbcHandlerMap.get(jdbcType);//根据jdbcType从上一步获取的Map<JdbcType, TypeHandler<?>>中获取映射的类型处理器
if (handler == null) {
handler = jdbcHandlerMap.get(null);//若上一步获取的类型处理器为空,再以null为键获取类型处理器
}
if (handler == null) {
// #591
handler = pickSoleHandler(jdbcHandlerMap);//若此时类型处理器仍为空,若该type映射的Map<JdbcType, TypeHandler<?>>仅有一个,则将其作为默认的类型处理器,若不仅有一个则返回null(不理解)
}
}
// type drives generics here类型驱动泛型
return (TypeHandler<T>) handler;
}
private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);//以type为key获取映射的jdbcHandlerMap(此map中entry可能不止一个)
if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {//若为null类型类型处理器返回null
return null;
}
if (jdbcHandlerMap == null && type instanceof Class) {//若jdbcHandlerMap为空即无映射的jdbcType与类型处理器,并且该参数类型type是原始类型
Class<?> clazz = (Class<?>) type;
if (clazz.isEnum()) {
jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);//type为枚举类型
if (jdbcHandlerMap == null) {
register(clazz, getInstance(clazz, defaultEnumTypeHandler));
return TYPE_HANDLER_MAP.get(clazz);
}
} else {
jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);//type为普通类型(类)
}
}
TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);//将type与新获取的jdbcHandlerMap作为新的JavaType与jdbcType与typehandler的映射关系置入TYPE_HANDLER_MAP中
return jdbcHandlerMap;
}
//获取枚举类型的JdbcHandlerMap
private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForEnumInterfaces(Class<?> clazz, Class<?> enumClazz) {
for (Class<?> iface : clazz.getInterfaces()) {
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(iface);
if (jdbcHandlerMap == null) {
jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);//原理就是获取clazz继承或实现的接口然后遍历,在TYPE_HANDLER_MAP中获取是否已经注册过该枚举继承或实现接口的Map<JdbcType, TypeHandler<?>>,若没有就一直递归上溯
}
if (jdbcHandlerMap != null) {
// Found a type handler regsiterd to a super interface为父接口注册一个类型处理器
HashMap<JdbcType, TypeHandler<?>> newMap = new HashMap<JdbcType, TypeHandler<?>>();
for (Entry<JdbcType, TypeHandler<?>> 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<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> clazz) {
Class<?> superclass = clazz.getSuperclass();//获取父类(该方法将在clazz为Object/接口/基本类型/void时返回空,即只会返回非Object的父类)
if (superclass == null || Object.class.equals(superclass)) {
return null;//若父类为Object或null则返回null
}
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);//以父类为key返回映射的Map<JdbcType, TypeHandler<?>>,若为null则进行递归上溯
if (jdbcHandlerMap != null) {
return jdbcHandlerMap;
} else {
return getJdbcHandlerMapForSuperclass(superclass);
}
}
private TypeHandler<?> pickSoleHandler(Map<JdbcType, TypeHandler<?>> jdbcHandlerMap) {
TypeHandler<?> soleHandler = null;
for (TypeHandler<?> handler : jdbcHandlerMap.values()) {遍历jdbcHandlerMap,若该map中仅有一个节点返回,否则返回null
if (soleHandler == null) {
soleHandler = handler;
} else if (!handler.getClass().equals(soleHandler.getClass())) {
// More than one type handlers registered.
return null;
}
}
return soleHandler;
}
public TypeHandler<Object> getUnknownTypeHandler() {
return UNKNOWN_TYPE_HANDLER;
}
public void register(JdbcType jdbcType, TypeHandler<?> handler) {
JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
}
//
// REGISTER INSTANCE
//
// Only handler
@SuppressWarnings("unchecked")
public <T> void register(TypeHandler<T> typeHandler) {
boolean mappedTypeFound = false;
MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);//获取该类型处理器的上是否有@MappedTypes注解
if (mappedTypes != null)
for (Class<?> handledType : mappedTypes.value()) {//该注解仅有一个属性value是一个class<?>[]
register(handledType, typeHandler);//注册该类型处理器与映射的处理类型handledType(就是该处理器处理的Java类型)
mappedTypeFound = true;
}
}
// @since 3.1.0 - try to auto-discover the mapped type
if (!mappedTypeFound && typeHandler instanceof TypeReference) {//若类型处理器上没有映射的处理类型且为TypeReference的子类
try {
TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
register(typeReference.getRawType(), typeHandler);//"typeReference.getRawType()"获取类型处理器的参数化类型最外层并注册该类型处理器/参数化类型
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);//若类型处理器仍为空,注册该类型处理器的映射类型为null
}
}
// java type + handler
public <T> void register(Class<T> javaType, TypeHandler<? extends T> typeHandler) {
register((Type) javaType, typeHandler);//注册javaType与映射的类型处理器
}
private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);//获取类型处理器上的MappedJdbcTypes注解,获取映射的jdbcType类型
if (mappedJdbcTypes != null) {
for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {//mappedJdbcTypes属性value为jdbcType[]
register(javaType, handledJdbcType, typeHandler);//注册javaType与jdbcType与类型处理器三者联合
}
if (mappedJdbcTypes.includeNullJdbcType()) {
register(javaType, null, typeHandler);//MappedJdbcTypes包含includeNullJdbcType属性,表明该注解的类型处理器映射jdbcType的null类型
}
} else {
register(javaType, null, typeHandler);//若无MappedJdbcTypes注解,注册javaType与null与typeHandler三者联合
}
}
public <T> void register(TypeReference<T> javaTypeReference, TypeHandler<? extends T> handler) {
register(javaTypeReference.getRawType(), handler);//与类型处理器的TypeReference类似
}
// 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) {
if (javaType != null) {
Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);//三者联合注册先以javaType为键从TYPE_HANDLER_MAP获取jdbcType&类型处理器
if (map == null || map == NULL_TYPE_HANDLER_MAP) {
map = new HashMap<JdbcType, TypeHandler<?>>();
TYPE_HANDLER_MAP.put(javaType, map);//若获取的映射map为null或为null类型映射的集合,则新建一个集合
}
map.put(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(String javaTypeClassName, String typeHandlerClassName) throws ClassNotFoundException {
register(Resources.classForName(javaTypeClassName), Resources.classForName(typeHandlerClassName));
}
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);
}
}
// scan
public void register(String packageName) {
ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
Set<Class<? 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
/**
* @since 3.2.2
*/
public Collection<TypeHandler<?>> getTypeHandlers() {
return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
}
②//沿着TypeReference子类的继承路线,直到获取父类的泛型信息
public abstract class TypeReference<T> {
private final Type rawType;
protected TypeReference() {
rawType = getSuperclassTypeParameter(getClass());
}
Type getSuperclassTypeParameter(Class<?> clazz) {
Type genericSuperclass = clazz.getGenericSuperclass();//获取继承的直接父类
if (genericSuperclass instanceof Class) {//父类为原生类型(类/枚举/数组/注解),注解/数组/枚举又不可继承,所以就是普通的类或接口,其实只有类(上一步获取的是直接继承的父类)
// try to climb up the hierarchy until meet something useful
if (TypeReference.class != genericSuperclass) {//若获取的父类不是TypeReference类型的进行方法递归
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];获取父类的参数化类型数组中的第一个(本质就一个,因为超类为TypeReference<T>,但是可以嵌套)
// TODO remove this when Reflector is fixed to return Types
if (rawType instanceof ParameterizedType) {//若泛型信息为参数化类型则获取获取整个泛型的RawType,举个例子:如果TypeReference<List<String>>最终获取的就是class java.util.List
rawType = ((ParameterizedType) rawType).getRawType();
}
return rawType;//返回父类的参数化类型信息
}
252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
