TypeHandlerRegistry 注册handler

最新推荐文章于 2024-12-28 10:15:00 发布
原创 最新推荐文章于 2024-12-28 10:15:00 发布 · 1.7k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了MyBatis的TypeHandlerRegistry类，它是MyBatis中负责管理和注册类型处理器的关键组件。文章讲解了其内部结构，如JDBC_TYPE_HANDLER_MAP和TYPE_HANDLER_MAP，以及如何注册、查找和处理不同类型与JdbcType的映射。同时，还涵盖了默认的EnumTypeHandler和自定义类型处理器的注册方法。

age org.apache.ibatis.type;

import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.Year;
import java.time.YearMonth;
import java.time.ZonedDateTime;
import java.time.chrono.JapaneseDate;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.ibatis.binding.MapperMethod.ParamMap;
import org.apache.ibatis.io.ResolverUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.reflection.Jdk;

/**

  • @author Clinton Begin
  • @author Kazuki Shimizu
    */
    public final class TypeHandlerRegistry {

private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap

private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();

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
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);
}

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);
}

@SuppressWarnings(“unchecked”)
private TypeHandler getTypeHandler(Type type, JdbcType jdbcType) {
if (ParamMap.class.equals(type)) {
return null;
}
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
TypeHandler<?> handler = null;
if (jdbcHandlerMap != null) {
handler = jdbcHandlerMap.get(jdbcType);
if (handler == null) {
handler = jdbcHandlerMap.get(null);
}
if (handler == null) {
// #591
handler = pickSoleHandler(jdbcHandlerMap);
}
}
// type drives generics here
return (TypeHandler) handler;
}

private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {
return null;
}
if (jdbcHandlerMap == null && type instanceof Class) {
Class<?> clazz = (Class<?>) type;
if (clazz.isEnum()) {
jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);
if (jdbcHandlerMap == null) {
register(clazz, getInstance(clazz, defaultEnumTypeHandler));
return TYPE_HANDLER_MAP.get(clazz);
}
} else {
jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
}
}
TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
return 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);
}
if (jdbcHandlerMap != null) {
// Found a type handler regsiterd to a super interface
HashMap<JdbcType, TypeHandler<?>> newMap = new HashMap

private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> clazz) {
Class<?> superclass = clazz.getSuperclass();
if (superclass == null || Object.class.equals(superclass)) {
return null;
}
Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);
if (jdbcHandlerMap != null) {
return jdbcHandlerMap;
} else {
return getJdbcHandlerMapForSuperclass(superclass);
}
}

private TypeHandler<?> pickSoleHandler(Map

public TypeHandler 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 void register(TypeHandler typeHandler) {
boolean mappedTypeFound = false;
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);
}
}

// java type + handler

public void register(Class javaType, TypeHandler<? extends T> typeHandler) {
register((Type) javaType, typeHandler);
}

private 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 void register(TypeReference javaTypeReference, TypeHandler<? extends T> handler) {
register(javaTypeReference.getRawType(), handler);
}

// java type + jdbc type + handler

public void register(Class 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);
if (map == null || map == NULL_TYPE_HANDLER_MAP) {
map = new HashMap<JdbcType, TypeHandler<?>>();
TYPE_HANDLER_MAP.put(javaType, map);
}
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 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);
}
}

// scan

public void register(String packageName) {
ResolverUtil<Class<?>> resolverUtil = new ResolverUtil

// get information

/**

  • @since 3.2.2
    */
    public Collection<TypeHandler<?>> getTypeHandlers() {
    return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
    }

}

9.2.6 typeHandlerElement方法(XMLConfigBuilder分析) -《SSM深入解析与项目实战》
谙忆-陈浩翔
11-08 1497
项目中所有的源码都可以在此链接的仓库中找到：https://github.com/chenhaoxiang/uifuture-ssm 文章目录9.2.6 typeHandlerElement方法 9.2.6 typeHandlerElement方法 typeHandlerElement方法，是用来读取并解析XML中的typeHandler元素（typeHandler 的作用就是将参数从 javaType 转化为 jdbcType，或者从数据库取出结果时把 jdbcType 转化为 javaType），配
Mybatis源码（六）— TypeHandlerRegistry
weixin_43936962的博客
05-10 885
type包下类的解析
【Mybatis源码分析】类型处理器（TypeHandler）及其注册
qq_63691275的博客
04-15 1588
写类型处理器，可以选择继承BaseTypeHandler类，也可以选择去实现TypeHandler接口。如果不想在配置文件中去配置对应的Java类型的话，那就使用@MappedTypes注解进行配置（当然可以配置多个，因为一个处理器可以对应多个Java数据类型嘛，可以达到一致效果的也可以配置，从而达到复用）。
关于mybatis自定义类型转换器时报没有找到相应的控制器处理的问题
qq_37225699的博客
08-21 6697
mybatis的类型转换器typeHandler是mybatis用于Java类型与数据库类型之间的转换用到的东西，事实上mybatis的typeHandler已经能够应对大部分的场景了，但是有时候也会不够用，比如在使用枚举的时候，枚举有特殊的转化规则，这时就需要用到自定义的类型转换器来处理了。 我在使用时出现了两次这样类似的异常如图： org.apache.ibatis.exception...
Mybatis系列三：类型别名、类型解析器的注册
lemon
03-08 961
TypeAlias可以帮助我们在Mybatis配置文件中直接引用类别名，而不必使用类完全限定名那么冗长的名字。TypeAliasRegistry、Configuration实例化时会注册默认的类别名，方便我们使用。类别名忽略大小写，在注册类别名或根据类别名或去类时，Mybatis会将别名转换成小写。 TypeHandlerRegistry帮助我们将Java类型和数据库类型进行转换。一个Java类...
Configuration--typeHandlers(三-7)
XingTree的博客
08-07 604
本篇文章我们继续来了解typeHandlers标签,这个标签的作用主要就是用于Java类型和数据库字段类型的相互转换.基本用法为: <typeHandlers> <typeHandler handler="" javaType="" jdbcType=""></typeHandler> <package name=""></package> </type
java-Mybatis自定义JsonObjectTypeHandler动态解析数据库JSON类型数据
草青工作室 的专栏
06-05 3134
配置并使用自定义的TypeHandler比较容易，继承个基类实现几个方法就OK了。不过总有一种猜的成分在里面，不知道他是如何工作如何实现的，甚至不清楚我自定义的handler是否成功，是否注册到了需要生效的位置。如果不通过分析代码分析流程自己永远只能在“黑盒”之外用一用。遇到问题解决问题，是很好的学些过程，在时间和进度允许的的情况下，可以钻下“牛角尖”。
Mybatis的类型转换注册类TypeHandlerRegistry
l688899886的博客
08-07 740
这篇文章主要讲解了类型转换注册类的TypeHandlerRegistry的注册方法和根据Java类型获取对应的TypeHandler实例的功能,注册类是重要的一个类，Mybatis的类型转换都需要在这个类进行注册才能实现类型转换。...
MybatisPlus中Enum的使用（MybatisEnumTypeHandler）及遇到的问题
yiyuzz的博客
08-02 9111
下面是TypeHandlerRegistry部分代码，其中javaTypeClass会根据是否配置javaType进行变化，如果javaType=true，那会按照实体类或者xml对应字段的java类型获取，如果javaType=false，那这里有可能是Object或者null，对于MybatisEnumTypeHandler来说应该是Object（我调试的时候是这样）上面的第三步不用了，然后又分两种情况，BaseMapper方式和Mapper.xml方式，其实主要是看你的sql语句在哪。...
Java使用mybatis的TypeHandler映射，字段类型转换失败
akili_007的博客
08-14 580
解决：debug之后发现，不是配置文件等问题，单纯是因为我的实体字段顺序和数据库顺序不一样，debug发现转换的时候是按照java实体顺序和数据库做映射转换值的，如果顺序不一样且字段类型不同时就会报错了。背景：接了一个新项目，之前开发用的TypeHandler做java实体和jdbc转换，我新增了一个实体结果报错了，并没有使用自定义handler。拓展：同理，数据库新增字段，预发线上共用一张表，但是线上代码实体没增加字段，也不会有问题。
【Mybatis源码】注册器 - TypeHandlerRegistry
Mointor
11-06 994
主要介绍Mybatis中TypeHandlerRegistry注册器的原理及使用。
TypeHandler注册、获取和参数解析
最新发布
qq_66627105的博客
12-28 1223
主要通过对org.apache.ibatis.type.BaseTypeHandler的继承，可以实现对Java字段类型和JDBC类型的设置和转换。BaseTypeHandler对TypeHandler进行了封装，增加了入参为空或返回值为空的预处理。@Overrideif (jdbcType == null) { // 检查jdbcTypethrow new TypeException("方便阅读，已删减");try {// 检查jdbcType。
mybatis 源码分析六、TypeHandlerRegistry和TypeHandler详解
m0_56362438的博客
12-06 635
TypeHandlerRegistry和TypeHandler在mybatis源码type包中，TypeHandler主要的作用是用做JdbcType 和 javaType的类型转换，就是我们常说的数据库类型和java中实体类型的转换。可以看做是正对TypeHandler的缓存，一次性将所有的TypeHandler进行了注册在我们需要使用的时候在重TypeHandlerRegistry注册器中获取。这样我们将我们自定义的TypeHandler注入到了我们的项目中。我们可以看一下执行的结果。
Mybatis 源码学习(9)-类型转换（TypeHandlerRegistry）
teaandnoodle的专栏
11-24 720
历史文章： Mybatis 源码学习(8)-类型转换（TypeHandler） 定义 TypeHandler 后，Mybatis 还需要对这些 TypeHandler 进行管理，Mybatis 是通过 TypeHandlerRegistry 来实现 TypeHandler 的管理的。TypeHandlerRegistry 的初始化是在 Configuration 中，Configuration ...
mybatis进阶之typeHandler
weixin_34198797的博客
12-21 219
2019独角兽企业重金招聘Python工程师标准>>> ...
MyBatis官方教程及源码解析——类型别名、类型处理器的解析
orzxxx01的专栏
03-14 2084
MyBatis官方教程及源码解析——类型别名、类型处理器的解析
【MyBatis源码分析】TypeHandler解析属性配置元素详述及相关枚举使用高级进阶
温柔常伴
01-09 883
TypeHandler解析接着看一下typeHandlerElement(root.evalNode("typeHandlers"));方法，这句读取的是&lt;configuration&gt;下的&lt;typeHandlers&gt;节点，代码实现为：private void typeHandlerElement(XNode parent) throws Exception { if...
精尽 MyBatis 源码分析 —— 类型模块
qq_32782279的博客
08-22 487
1. 概述 ① MyBatis 为简化配置文件提供了别名机制，该机制是类型转换模块的主要功能之一。 ② 类型转换模块的另一个功能是实现 JDBC 类型与 Java 类型之间的转换，该功能在为 SQL 语句绑定实参以及映射查询结果集时都会涉及： 在为 SQL 语句绑定实参时，会将数据由 Java 类型转换成 JDBC 类型。 而在映射结果集时，会将数据由 JDBC 类型转换成 Java 类型 2. TypeHandler org.apache.ibatis.type.TypeHandler ，类型转换处理器。
Mybatis 查询语句条件为枚举类型时报错处理
ttaannkkee的博客
06-10 2387
通常我们对于数据库中一些枚举字段使用tinyInt类型，而java对象对应的字段很多时候会为了方便定义成short或者int。但这样显然不美观方便，让后面维护的人抠破脑袋找你的常量定义在哪儿，要是没有注释简直让人崩溃。时间久后，没有人知道这里面的值。只能一行行读源码。 优雅的程序员当然想到了优雅的枚举，而mybatis“强大”的枚举类型处理器EnumOrdinalTypeHandler相信都不陌生。 然而配置枚举处理器花了九牛二虎之力改好原来的mapper运行测试用例全在报错。而插入、部分查询却没报错。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值