/**
* typeHandler注册管理类 */
public
final
class
TypeHandlerRegistry {
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
);
}
};
private
final
Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP =
new
EnumMap<JdbcType, TypeHandler<?>>(JdbcType.
class
);
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<?>>();
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());
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, TypeHandler<?>> 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"
)
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);
}
/**
* 只配置了typeHandler, 没有配置jdbcType 或者javaType
*/
@SuppressWarnings
(
"unchecked"
)
public
<T>
void
register(TypeHandler<T> typeHandler) {
boolean
mappedTypeFound =
false
;
MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.
class
);
if
(mappedTypes !=
null
) {
for
(Class<?> handledType : mappedTypes.value()) {
register(handledType, typeHandler);
mappedTypeFound =
true
;
}
}
if
(!mappedTypeFound && typeHandler
instanceof
TypeReference) {
try
{
TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
register(typeReference.getRawType(), typeHandler);
mappedTypeFound =
true
;
}
catch
(Throwable t) {
}
}
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 = 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, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
if
(map ==
null
) {
map =
new
HashMap<JdbcType, TypeHandler<?>>();
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);
}
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));
}
}
public
void
register(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
}
public
void
register(Class<?> javaTypeClass, JdbcType jdbcType, Class<?> typeHandlerClass) {
register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));
}
@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) {
}
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<?
extends
Class<?>>> handlerSet = resolverUtil.getClasses();
for
(Class<?> type : handlerSet) {
if
(!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
register(type);
}
}
}
/**
* 通过configuration对象可以获取已注册的所有typeHandler */
public
Collection<TypeHandler<?>> getTypeHandlers() {
return
Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
}
}