【MyBatis源码分析】TypeHandler解析属性配置元素详述及相关枚举使用高级进阶

最新推荐文章于 2024-08-08 23:20:59 发布
最新推荐文章于 2024-08-08 23:20:59 发布
阅读量768 收藏
点赞数 1
分类专栏： 源码 Mybatis深度源码分析 文章标签： mybatis 框架 源码 java 数据访问
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35807136/article/details/79016291
版权

TypeHandler解析

接着看一下typeHandlerElement(root.evalNode("typeHandlers"));方法，这句读取的是<configuration>下的<typeHandlers>节点，代码实现为：

private void typeHandlerElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String typeHandlerPackage = child.getStringAttribute("name");
          typeHandlerRegistry.register(typeHandlerPackage);
        } else {
          String javaTypeName = child.getStringAttribute("javaType");
          String jdbcTypeName = child.getStringAttribute("jdbcType");
          String handlerTypeName = child.getStringAttribute("handler");
          Class<?> javaTypeClass = resolveClass(javaTypeName);
          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
          Class<?> typeHandlerClass = resolveClass(handlerTypeName);
          if (javaTypeClass != null) {
            if (jdbcType == null) {
              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
            } else {
              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
            }
          } else {
            typeHandlerRegistry.register(typeHandlerClass);
          }
        }
      }
    }
  }

Mybatis中的TypeHandler是什么？

　　无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。Mybatis默认为我们实现了许多TypeHandler, 当我们没有配置指定TypeHandler时，Mybatis会根据参数或者返回结果的不同，默认为我们选择合适的TypeHandler处理。

那么，Mybatis为我们实现了哪些TypeHandler呢?  我们怎么自定义实现一个TypeHandler ?  这些都会在接下来的mybatis的源码中看到。

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(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
    try {
      // since 1.0.0
      register("java.time.Instant", "org.apache.ibatis.type.InstantTypeHandler");
      register("java.time.LocalDateTime", "org.apache.ibatis.type.LocalDateTimeTypeHandler");
      register("java.time.LocalDate", "org.apache.ibatis.type.LocalDateTypeHandler");
      register("java.time.LocalTime", "org.apache.ibatis.type.LocalTimeTypeHandler");
      register("java.time.OffsetDateTime", "org.apache.ibatis.type.OffsetDateTimeTypeHandler");
      register("java.time.OffsetTime", "org.apache.ibatis.type.OffsetTimeTypeHandler");
      register("java.time.ZonedDateTime", "org.apache.ibatis.type.ZonedDateTimeTypeHandler");
      // since 1.0.1
      register("java.time.Month", "org.apache.ibatis.type.MonthTypeHandler");
      register("java.time.Year", "org.apache.ibatis.type.YearTypeHandler");

    } catch (ClassNotFoundException e) {
      // no JSR-310 handlers
    }

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }
其实大部分需求上面的注册已经满足！接下来我们先看typeHandler相关Xml配置信息： 
<typeHandlers>
         <!--javaType 配置java类型，例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->
        <!--<typeHandler handler="Handler.AddressTypeHandler"  javaType="model.Address" jdbcType="VARCHAR" />-->
        <!--<typeHandler handler="org.apache.ibatis.type.EnumTypeHandler"  /> 使用枚举名称作为参数传递-->
        <typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler"  javaType="enums.web" /><!-- 使用整数下标作为参数传递-->
        <!--<typeHandler handler="org.apache.ibatis.type.EnumTypeHandler"  javaType="enums.web" /><!– 使用字符串作为参数传递–>-->
        <!-- 配置package的时候，mybatis会去配置的package扫描TypeHandler -->
        <package name="Handler"/>

    </typeHandlers>

我们来自定义实现一个自定义Handler：

假设邮箱可用拼接的方式存储

定义一个邮箱类：

/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: AssembledMail
 * Author:   temp
 * Date:     2018/3/29 13:51
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package model;

/**
 * 邮箱类
 *  组装邮箱<br>
 * 〈〉
 *
 * @author temp
 * @create 2018/3/29
 * @since 1.0.0
 */
public class AssembledMail {

    private String head;

    private String tail;

    public AssembledMail(){

    }

    public AssembledMail(String head,String tail){

        this.head = head;
        this.tail = tail;
    }

    public String getHead() {
        return head;
    }

    public String getTail() {
        return tail;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public void setTail(String tail) {
        this.tail = tail;
    }

    @Override
    public String toString() {
        return head + "@" + tail;
    }
}

继承并实现BaseTypeHandler可实现注册TypeHandler(可配置JavaType及JdbcType)

/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: AddressTypeHandler
 * Author:   temp
 * Date:     2018/3/29 9:58
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package Handler;

import model.AssembledMail;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author temp
 * @create 2018/3/29
 * @since 1.0.0
 */
@MappedJdbcTypes(JdbcType.VARCHAR)
@MappedTypes(value = {AssembledMail.class})
public class AddressTypeHandler  extends BaseTypeHandler<AssembledMail> {


    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, AssembledMail address, JdbcType jdbcType) throws SQLException {
        preparedStatement.setString(i,address.toString());

    }

    @Override
    public AssembledMail getNullableResult(ResultSet resultSet, String s) throws SQLException {

        return get(resultSet.getString(s));
    }

    @Override
    public AssembledMail getNullableResult(ResultSet resultSet, int i) throws SQLException {

        return get(resultSet.getString(i));
    }

    @Override
    public AssembledMail getNullableResult(CallableStatement callableStatement, int i) throws SQLException {

        return get(callableStatement.getString(i));
    }

    private AssembledMail get(String sta){
        AssembledMail assembledMail = new AssembledMail();
        assembledMail.setHead(sta.substring(0, sta.indexOf("@")));
        assembledMail.setTail(sta.substring(sta.indexOf("@")+1,sta.length()));
        return assembledMail;
    }
}

开起xml扫描这个类

xml映射配置

<resultMap type="Mail" id="MailResultMap">
         <result column="id" property="id" />
         <result column="create_time" property="createTime" />
         <result column="modify_time" property="modifyTime" />
         <result column="web_id" property="webId" />
         <result column="mail" property="mail" typeHandler="Handler.AddressTypeHandler"/>
         <result column="use_for" property="useFor" />
     </resultMap>

接下来修改Mail的mail的类型为AssemblerMail类型

接下来我们测试一下

 @Test
	 public void testInsert() {
	    Mail mail1 = new Mail(1, new AssembledMail("ztp","qq.com"), "个人使用");
	    System.out.println(mailDao.insertMail(mail1));
	 }

结果mail这个单个字段已经映射进去

接下来我们查询一下

@Test
	 public void testDelete() {
	     System.out.println(mailDao.deleteMail(12));
	 }

结果符合我们的要求.

实现简单实现自定义Handler后我们按照业务场景实现比较多的枚举映射

前面的xml配置文件已经简单说明了Mybatis自带的针对枚举的映射类区别

我们来实现一下枚举Handler:

定义一个枚举类

/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: web
 * Author:   temp
 * Date:     2018/3/29 11:03
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package enums;

import org.apache.ibatis.type.MappedTypes;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author temp
 * @create 2018/3/29
 * @since 1.0.0
 */
/*@MappedTypes(enums.web.class)*/
public enum  web {

    SING(1,"新浪"),
    QQ(2,"QQ"),
    SOHU(3,"搜狐"),
    FIREFOX(4,"火狐");

    private int id;

    private String name;

    private web(int id,String name){

        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return super.toString();
    }

    public static web getweb(int id){
        if(id == 1){

            return SING;
        }else if(id == 2){

            return QQ;
        }else if(id == 3){

            return SOHU;
        }else if(id == 4){

            return FIREFOX;
        }
        return null;
    }
}

配置属性映射

<resultMap type="Mail" id="MailResultMap">
         <result column="id" property="id" />
         <result column="create_time" property="createTime" />
         <result column="modify_time" property="modifyTime" />
         <result column="web_id" property="webId" typeHandler="org.apache.ibatis.type.EnumOrdinalTypeHandler" />
         <result column="mail" property="mail" typeHandler="Handler.AddressTypeHandler"/>
         <result column="use_for" property="useFor" />
     </resultMap>

接下来修改Mail的webId的类型为枚举web

接下来我们看实际运行效果：

@Test
	 public void testInsert() {
	    Mail mail1 = new Mail(web.FIREFOX, new AssembledMail("ztp","qq.com"), "个人使用");
	    System.out.println(mailDao.insertMail(mail1));
	 }

效果

查询结果

从源码实现中我们可以知道两点，<typeHandlers>标签下可以定义<package>和<typeHandler>两种标签，但是看第4行和第7行的判断，这是一段if...else...，因此可以知道<package>标签和<typeHandler>标签只能定义其中的一种。

接下来我们继续看到6行代码：

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);
      }
    }
  }
第3行根据路径packageName寻找它下面的".class"文件拿到所有的".class"文件对应的类的Class，然后遍历所有的Class，做了三层判断
  • 必须不是匿名类
  • 必须不是接口
  • 必须不是抽象成员类
此时此Class对应的类符合条件，会进行注册，通过register方法进行注册，看一下方法实现： 

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));
    }
  }
第3行获取类上面的注解MappedTypes，如果MappedTypes注解中有定义value属性且指定了对象的class，那么第4行~第7行的判断优先取这个Class。

我们继续看第6行：

public void register(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
    register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
  }
方法重载,我们看一下getInstance方法： 

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);
    }
  }
通过反射它的泛型，来知道你想用这个TypeHandler处理的java类型，直接调用newInstance(),返回对象; 

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);
    }
  }
方法的重载，第2行获取类上面的注解MappedJdbcTyoes，获取MappedJdbcTyoes注解中有定义JdbcType的属性；如果有jdbcType则用当前的jdbcTyoe;否则给null作为参数;

接下来看第5行代码:

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);
    }
    ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
  }

如果当前指定的typeHandler存在,则在当前的存储map中取获取；如果当前没有存储，则创建一个存储map；将指定的jdbctype作为key，存储typeHandler；

TYPE_HANDLER_MAP添加当前的 key:javaType value : map

用一个新增加的ALL_TYPE_HANDLERS_MAP存储新增加的typeHandler；

接下来我们看不使用注解的方式:

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;
      }
    }
    // @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);
    }
  }
从1~9行代码还是进行对MappedTypes注解进行判断是否存在，上面已经讲述了；

接下来我们看到第11~18行获取到泛型指定的类进行给到方法入参，接下来就是跟上面方法一样了；

接下来我们看使用（javaType，jdbcType，handler）的方式：

          String javaTypeName = child.getStringAttribute("javaType");
          String jdbcTypeName = child.getStringAttribute("jdbcType");
          String handlerTypeName = child.getStringAttribute("handler");
          Class<?> javaTypeClass = resolveClass(javaTypeName);
          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
          Class<?> typeHandlerClass = resolveClass(handlerTypeName);
          if (javaTypeClass != null) {
            if (jdbcType == null) {
              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
            } else {
              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
            }
          } else {
            typeHandlerRegistry.register(typeHandlerClass);
          }
我们看到第4行代码： 
protected Class<?> resolveClass(String alias) {
    if (alias == null) {
      return null;
    }
    try {
      return resolveAlias(alias);
    } catch (Exception e) {
      throw new BuilderException("Error resolving class. Cause: " + e, e);
    }
  }
根据配置的javaType值，如果为空则直接返回null;

继续往下面看到resolveAlias方法：

public <T> Class<T> resolveAlias(String string) {
    try {
      if (string == null) {
        return null;
      }
      // issue #748
      String key = string.toLowerCase(Locale.ENGLISH);
      Class<T> value;
      if (TYPE_ALIASES.containsKey(key)) {
        value = (Class<T>) TYPE_ALIASES.get(key);
      } else {
        value = (Class<T>) Resources.classForName(string);
      }
      return value;
    } catch (ClassNotFoundException e) {
      throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
  }

第七行将字符串首字母小写转换

第九行判断当前类名解析器中有没有这个对象，如果有则直接返回；如果没有则根据配置的对象路径返回对象，路径错误则异常；

JdbcType jdbcType = resolveJdbcType(jdbcTypeName);从JdbcType返回jdbcType对象；

handlerTypeName获取和javaTypeName一样，就不多说了；

解析完三个参数；接着就根据参数分别注册不同的typeHandler;


接下来我们学习下自定义TypeHandler处理枚举；

在Mybatis中，处理枚举类的TypeHandler有两个：

  1. EnumTypeHandler: 用于保存枚举名
  2. EnumOrdinalTypeHandler: 用于保存枚举的序号。

在实际项目中，以上往往不能满足我们的需求。

需求分析

枚举需要包含两个属性，name(用于显示), id(实际的枚举值)。数据库保存枚举值(id)。

这很明显Mybatis提供的两个枚举TypeHandler不能满足我们的需求。此时，我们可以自定义一个通用的枚举TypeHandler来满足我们的需求。

自定义枚举TypeHandler

通用枚举DisplayedEnum 
/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: DisplayedEnum
 * Author:   temp
 * Date:     2018/3/29 16:05
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package TypeHandler;

import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author temp
 * @create 2018/3/29
 * @since 1.0.0
 */
public interface  DisplayedEnum {
    String DEFAULT_VALUE_NAME = "id";

    String DEFAULT_LABEL_NAME = "name";

    default Integer getValue() {
        Field field = ReflectionUtils.findField(this.getClass(), DEFAULT_VALUE_NAME);
        if (field == null)
            return null;
        try {
            field.setAccessible(true);
            return Integer.parseInt(field.get(this).toString());
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }


    default String getLabel() {
        Field field = ReflectionUtils.findField(this.getClass(), DEFAULT_LABEL_NAME);
        if (field == null)
            return null;
        try {
            field.setAccessible(true);
            return field.get(this).toString();
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    static <T extends Enum<T>> T valueOfEnum(Class<T> enumClass, Integer value) {
        if (value == null)
            throw  new IllegalArgumentException("DisplayedEnum value should not be null");
        if (enumClass.isAssignableFrom(DisplayedEnum.class))
            throw new IllegalArgumentException("illegal DisplayedEnum type");
        T[] enums = enumClass.getEnumConstants();
        for (T t: enums) {
            DisplayedEnum displayedEnum = (DisplayedEnum)t;
            if (displayedEnum.getValue().equals(value))
                return (T) displayedEnum;
        }
        throw new IllegalArgumentException("cannot parse integer: " + value + " to " + enumClass.getName());
    }

}

修改之前的普通枚举类
/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: web
 * Author:   temp
 * Date:     2018/3/29 11:03
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package enums;

import TypeHandler.DisplayedEnum;
import org.apache.ibatis.type.MappedTypes;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author temp
 * @create 2018/3/29
 * @since 1.0.0
 */
public enum  web implements DisplayedEnum {

    SING(1,"新浪"),
    QQ(2,"QQ"),
    SOHU(3,"搜狐"),
    FIREFOX(4,"火狐");

    private int id;

    private String name;

    private web(int id,String name){

        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }


}

说明：
普通枚举类通过实现DisplayedEnum接口，就可以：
  1. 通过getId()获取枚举值。
  2. 通过getNmae()获取枚举的name属性。
  3. 通过valueOfEnum()将Integer值转换为指定的枚举类型。
以上就是一个普通枚举类的示例。
自定义枚举TypeHandler
/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: DefaultEnumTypeHandler
 * Author:   temp
 * Date:     2018/3/29 16:48
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package Handler;

import TypeHandler.DisplayedEnum;
import enums.web;
import model.AssembledMail;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author temp
 * @create 2018/3/29
 * @since 1.0.0
 */
@MappedJdbcTypes(value = JdbcType.TINYINT, includeNullJdbcType = true)
@MappedTypes(value = {web.class})
public class DefaultEnumTypeHandler extends BaseTypeHandler<DisplayedEnum> {

    private Class<DisplayedEnum> type;

    public DefaultEnumTypeHandler(){
        System.out.print(111);
    };

    public DefaultEnumTypeHandler(Class<DisplayedEnum> type) {
        if (type == null) throw new IllegalArgumentException("Type argument cannot be null");
        this.type = type;
    }

    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, DisplayedEnum displayedEnum, JdbcType jdbcType) throws SQLException {
        preparedStatement.setInt(i, displayedEnum.getValue());
    }

    @Override
    public DisplayedEnum getNullableResult(ResultSet resultSet, String s) throws SQLException {
        return convert(resultSet.getInt(s));
    }

    @Override
    public DisplayedEnum getNullableResult(ResultSet resultSet, int i) throws SQLException {
        return convert(resultSet.getInt(i));
    }

    @Override
    public DisplayedEnum getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        return convert(callableStatement.getInt(i));
    }

    private DisplayedEnum convert(int status){
        DisplayedEnum[] objs = type.getEnumConstants();
        for(DisplayedEnum em: objs){
            if(em.getValue() == status){
                return  em;
            }
        }
        return null;
    }
}
使用我们自定义的DefaultEnumTypeHandler

注意：不能同时和包扫描使用

<typeHandlers>
         <!--javaType 配置java类型，例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->
        <typeHandler handler="Handler.AddressTypeHandler"/>
        <!--<typeHandler handler="org.apache.ibatis.type.EnumTypeHandler"  /> 使用枚举名称作为参数传递-->
        <typeHandler handler="Handler.DefaultEnumTypeHandler" /><!-- 使用整数下标作为参数传递-->
    </typeHandlers>

由于Mybatis默认在处理枚举类型的时候会使用EnumTypeHandler(只保存及转换枚举类型的名字), 因此，我们需要手动指定使用DefaultEnumTypeHandler。示例如下：

<resultMap type="Mail" id="MailResultMap">
         <result column="id" property="id" />
         <result column="create_time" property="createTime" />
         <result column="modify_time" property="modifyTime" />
         <result column="web_id" property="webId"  typeHandler="Handler.DefaultEnumTypeHandler" />
         <result column="mail" property="mail"   typeHandler="Handler.AddressTypeHandler"/>
         <result column="use_for" property="useFor" />
     </resultMap>
测试结果正确
即我们需要通过使用typeHandler来指定。
以上是我们应用在实际项目中的一个对于Mybatis处理枚举类的方案。我看大多数人也都是这样在用。

























-ztp
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
9.2.6 typeHandlerElement方法(XMLConfigBuilder分析) -《SSM深入解析与项目实战》
谙忆-陈浩翔
11-08 1295
项目中所有的源码都可以在此链接的仓库中找到：https://github.com/chenhaoxiang/uifuture-ssm 文章目录9.2.6 typeHandlerElement方法 9.2.6 typeHandlerElement方法 typeHandlerElement方法，是用来读取并解析XML中的typeHandler元素（typeHandler 的作用就是将参数从 javaType 转化为 jdbcType，或者从数据库取出结果时把 jdbcType 转化为 javaType），配
【微服务】mybatis typehandler使用详解
congge
02-25 5977
mybatis typehandler 使用详解
Mybatis配置文件之<typeHandlers>元素解析
渔潭的博客
05-04 1802
Mybatis配置文件之元素解析 1. 概述 mybatis在预处理语句（PreparedStatement）中设置一个参数或者从结果集中（ResultSet）中取出一个值时，都会用注册了的typeHandler进行处理。 由于数据库厂商的不同，所以厂商设置的参数可能也不同，同时数据库也可以自定义数据类型，typeHandler允许我们根据项目的需要自定义设置Java传递到数据库的参数中，或...
typeHandlers 类型处理器
yyqhwr的博客
09-06 3268
类型转换器官网地址 无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。下表描述了一些默认的类型处理器。 提示 从 3.4.5 开始，MyBatis 默认支持 JSR-310(日期和时间 API) 。 类型处理器 Java 类型 JDBC 类型 ...
Mybatis TypeHandler 介绍及使用
最新发布
weixin_38687619的博客
08-08 279
TypeHandler类型转换器是负责Java类和jdbc类型之间的转换。主要涉及到下面这几个类：TypeHandler 类型转换器的顶层接口BaseTypeHandler 抽象类继承自TypeHandler，Mybatis中所有的类型转换器实现均继承他。TypeHandlerRegistry 类型转换器注册器，负责存储类型转换器。TypeAliasRegistry 类型别名转换器，用来存储类型与别名的对应关系。
mybatis--基础--2.4--xml配置--类型处理器(typeHandlers)
zhou920786312的博客
10-18 1859
重写已有的类型处理器或创建你自己的类型处理器具体做法为：实现org.apache.ibatis.type.TypeHandler接口继承类org.apache.ibatis.type.BaseTypeHandler，并且可以(可选地)将它映射到一个JDBC类型。配置方式：直接配置包名配置注意点使用自动发现功能的时候，只能通过注解方式来指定JDBC的类型。默认不使用自动发现功能/*** 将 数据库String类型转为Java Long类型。
TypeHandler简介及配置（mybatis源码篇）
weixin_30307921的博客
08-27 103
作者：南柯梦 Mybatis中的TypeHandler是什么？ 　　无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。Mybatis默认为我们实现了许多TypeHandler, 当我们没有配置指定TypeHandler时，Mybatis会根据参数或者返回结果的不同...
mybatis源码解析之基础模块-TypeHandler
iteye_7068的博客
10-20 308
MyBatis源码解析之基础模块—TypeHandler 前文回顾 上一章节我们一起分析了Mybatis的Plugin模块的源码。掌握了如何配置拦截器注解，如何自定义拦截器以及拦截器的执行过程。 在使用Mybatis的过程中，基本上我们都要在xml中编写相应的sql语句以及对应的java属性与字段的转换。那么对于数据库与java之间的转换，Mybatis是怎么做的呢？ 接下来本章节我们对MyBatis Type模块类型转换的源码进行分析。 架构设计 按惯例，咱们先了解下Type模块的总体架构设计。 Ty..
Mybatis实战之TypeHandler高级进阶
08-31
完成以上步骤后，我们不再需要在resultMap中为每个枚举字段指定typeHandler属性，Mybatis会自动使用我们注册的自定义TypeHandler进行转换。 总结来说，自定义枚举TypeHandler并解决频繁指定的问题，需要深入理解...
Mybatis中自定义TypeHandler处理枚举详解
08-31
在Mybatis中，枚举类型的数据处理是通过TypeHandler实现的。默认情况下，Mybatis提供了两种内置的枚举TypeHandler： 1. `EnumTypeHandler`: 这个TypeHandler将枚举对象转换为它们的字符串表示，即枚举的名称。在...
MyBatis使用自定义TypeHandler转换类型的实现方法
08-26
MyBatis使用自定义TypeHandler转换类型的实现方法 MyBatis是一款流行的ORM（Object-Relational Mapping）框架，提供了强大的数据库交互功能。然而，在使用MyBatis时，开发者可能会遇到类型转换的问题，特别是在处理...
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
Mybatis源码学习笔记（五）配置简介之TypeHandler
海的那边见
06-10 725
配置简介之TypeHandler
MyBatis 源码解读-typeHandlerElement()
Leon_Jinhai_Sun的博客
12-10 119
跟TypeAlias 一样，TypeHandler 有两种配置方式，一种是单独配置一个类，一种是指定一个package。最后我们得到的是JavaType 和JdbcType，以及用来做相互映射的TypeHandler 之间的映射关系。 最后存放在TypeHandlerRegistry 对象里面。 问题：这种三个对象（Java 类型，JDBC 类型，Handler）的关系怎么映射？（Map里面再放一个Map） ...
Mybatis TypeHandler介绍使用举例
热门推荐
张彦峰的博客
01-17 81万+
Mybatis TypeHandler介绍使用举例，主要回顾Mybatis的原理内容，在介绍TypeHandler的基本功能，最后给出使用TypeHandler的样例和注意事项等内容
springboot+mybatis自定义typeHandler 解决varchar到JsonObject的映射
Nio的博客
06-30 614
【代码】springboot+mybatis自定义typeHandler 解决varchar到JsonObject的映射。
MyBatis配置typeHandler类型转换器 (自定义类型转换器)
我是guyue，guyue就是我O(∩_∩)O
11-03 2846
MyBatis配置のtypeHandler类型转换器 - 简书 https://www.jianshu.com/p/8e0a2d06892c     初始typeHandler 在JDBC中，需要在PreparedStatement对象中设置那些已经预编译过的SQL语句 参数。 执行SQL后，会通过ResultSet对象获取得到数据库的数据，而这些MyBatis是根据数据的类型通过type...
mybatis 类型转换TypeHandler基础
03-16 478
本篇文章用来记录作者自己的学习过程 ，在这个过程中参考了以下作者的文章： http://elim.iteye.com/blog/1847854#_Toc353481987 TypeHandler的由来 java有java的数据类型，数据库有数据库的类型，大家都知道在jdbc中我们两者之间的转换都需要自己写代码实现，typeHandler就是为了解决两者之间的自动的转换 ...
MP typeHandler 用法
chengmin123456789的博客
06-18 591
typeHandler 可以在新增、更新、查询时候字段进行数据类型转换与解析 步骤1、实体类配置注解： // 只针对jdbcType为varchar的字段进行mapping处理，勿略jdbcType设置为空的字段 @MappedJdbcTypes(includeNullJdbcType = false, value = JdbcType.VARCHAR) //autoResultMap 默认为false,设为true之后字段解析有typeHandler 的特殊字段 @TableName(value = "
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值