MyBatis配置文件(四)－－typeHandlers

typeHandlers又叫类型处理器，就像在JDBC中，我们在PreparedStatement中设置预编译sql所需的参数或执行sql后根据结果集ResultSet对象获取得到的数据时，需要将数据库中的类型和java中字段的类型进行转换一样，在MyBatis中使用typeHandler来实现。所以说白了，typeHandlers就是用来完成javaType和jdbcType之间的转换。举个比较简单的例子，我创建一个博客表，表中的创建时间和修改时间用VARCHAR类型，但是在我的POJO对象中，创建时间和修改时间的类型是Date，这样我在向数据库插入数据时，需要将日期类型转化成VARCHAR,而从数据库中查询出的结果中，又需要将VARCHAR类型转换成Date.在MyBatis中，使用typeHandlers配置来实现这个转换过程。和别名一样，MyBatis中的类型处理器也存在系统定义的和自定义两种，MyBatis会根据javaType和jdbcType来决定采用哪个typeHandler来处理这些转换规则，而且系统定义的能满足大部分需求，可以说是非常好用，用户只需要自定义一些特有的转换规则，如枚举类型。下面分别介绍这两种typeHandler。

一、系统定义的typeHandler

同上一节的typeAliases，typeHandler也能通过Configuration对象获取到，如下：

 /**
      * 获取类型处理器
      */
     public static void getTypeHandlers() {
         SqlSession sqlSession = getSqlSession();
         TypeHandlerRegistry typeHandlerRegistry = sqlSession.getConfiguration().getTypeHandlerRegistry();
         Collection<TypeHandler<?>> handlers =  typeHandlerRegistry.getTypeHandlers();
         System.out.println(handlers.size());
         for (TypeHandler<?> typeHandler : handlers) {
             System.out.println(typeHandler.getClass().getName());
         }
     }

执行结果如下：

 39
 org.apache.ibatis.type.SqlDateTypeHandler
 org.apache.ibatis.type.ClobReaderTypeHandler
 org.apache.ibatis.type.LocalTimeTypeHandler
 org.apache.ibatis.type.YearMonthTypeHandler
 org.apache.ibatis.type.NStringTypeHandler
 org.apache.ibatis.type.LocalDateTypeHandler
 org.apache.ibatis.type.BigIntegerTypeHandler
 org.apache.ibatis.type.OffsetDateTimeTypeHandler
 org.apache.ibatis.type.ByteObjectArrayTypeHandler
 org.apache.ibatis.type.ArrayTypeHandler
 org.apache.ibatis.type.BigDecimalTypeHandler
 org.apache.ibatis.type.UnknownTypeHandler
 org.apache.ibatis.type.OffsetTimeTypeHandler
 org.apache.ibatis.type.ByteArrayTypeHandler
 org.apache.ibatis.type.DateOnlyTypeHandler
 org.apache.ibatis.type.JapaneseDateTypeHandler
 org.apache.ibatis.type.TimeOnlyTypeHandler
 org.apache.ibatis.type.NClobTypeHandler
 org.apache.ibatis.type.BooleanTypeHandler
 org.apache.ibatis.type.BlobTypeHandler
 org.apache.ibatis.type.YearTypeHandler
 org.apache.ibatis.type.BlobByteObjectArrayTypeHandler
 org.apache.ibatis.type.MonthTypeHandler
 org.apache.ibatis.type.FloatTypeHandler
 org.apache.ibatis.type.DateTypeHandler
 org.apache.ibatis.type.ClobTypeHandler
 org.apache.ibatis.type.BlobInputStreamTypeHandler
 org.apache.ibatis.type.ByteTypeHandler
 org.apache.ibatis.type.SqlTimestampTypeHandler
 org.apache.ibatis.type.ZonedDateTimeTypeHandler
 org.apache.ibatis.type.IntegerTypeHandler
 org.apache.ibatis.type.LocalDateTimeTypeHandler
 org.apache.ibatis.type.CharacterTypeHandler
 org.apache.ibatis.type.SqlTimeTypeHandler org.apache.ibatis.type.DoubleTypeHandler
 org.apache.ibatis.type.ShortTypeHandler
 org.apache.ibatis.type.LongTypeHandler
39 org.apache.ibatis.type.InstantTypeHandler
40 org.apache.ibatis.type.StringTypeHandler

从结果来看，系统总过定义了39个类型处理器。

现在选择其中的StringTypeHandler来进行分析，看看其源代码

1、获取StringTypeHandler的源代码

 /**
  *    Copyright 2009-2015 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
 package org.apache.ibatis.type;

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

 /**
  * @author Clinton Begin
  */
 public class StringTypeHandler 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);
   }
 }

从上述代码可以看出它继承了一个叫做BaseTypeHandler<String>的类，这个类的范型是String，即javaType，几个方法如下：

1⃣️setNonNullParameter：这个方法是用来将javaType转换成jdbcTpe

2⃣️getNullableResult：这个方法用来将从结果集根据列名称获取到的数据的jdbcType转换成javaType

3⃣️getNullableResult：这个方法用来将从结果集根据列索引获取到的数据的jdbcType转换成javaType

4⃣️getNullableResult：这个方法用在存储过程中

其实主要就是完成不同类型之间的转换，下面来看一下它所继承的BaseTypeHandler<String>类

2、BaseTypeHandler<String>类源码

 /**
  *    Copyright 2009-2015 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
 package org.apache.ibatis.type;

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

 import org.apache.ibatis.executor.result.ResultMapException;
 import org.apache.ibatis.session.Configuration;

 /**
  * @author Clinton Begin
  * @author Simone Tripodi
  */
 public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {

   protected Configuration configuration;

   public void setConfiguration(Configuration c) {
     this.configuration = c;
   }

   @Override
   public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
     if (parameter == null) {
       if (jdbcType == null) {
         throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
       }
       try {
         ps.setNull(i, jdbcType.TYPE_CODE);
       } catch (SQLException e) {
         throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . " +
                 "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. " +
                 "Cause: " + e, e);
       }
     } else {
       try {
         setNonNullParameter(ps, i, parameter, jdbcType);
       } catch (Exception e) {
         throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . " +
                 "Try setting a different JdbcType for this parameter or a different configuration property. " +
                 "Cause: " + e, e);
       }
     }
   }

   @Override
   public T getResult(ResultSet rs, String columnName) throws SQLException {
     T result;
     try {
       result = getNullableResult(rs, columnName);
     } catch (Exception e) {
       throw new ResultMapException("Error attempting to get column '" + columnName + "' from result set.  Cause: " + e, e);
     }
     if (rs.wasNull()) {
       return null;
     } else {
       return result;
     }
   }

   @Override
   public T getResult(ResultSet rs, int columnIndex) throws SQLException {
     T result;
     try {
       result = getNullableResult(rs, columnIndex);
     } catch (Exception e) {
       throw new ResultMapException("Error attempting to get column #" + columnIndex+ " from result set.  Cause: " + e, e);
     }
     if (rs.wasNull()) {
       return null;
     } else {
       return result;
     }
   }

   @Override
   public T getResult(CallableStatement cs, int columnIndex) throws SQLException {
     T result;
     try {
       result = getNullableResult(cs, columnIndex);
     } catch (Exception e) {
       throw new ResultMapException("Error attempting to get column #" + columnIndex+ " from callable statement.  Cause: " + e, e);
     }
     if (cs.wasNull()) {
       return null;
     } else {
       return result;
     }
   }

   public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

   public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;

   public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;

   public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;

 }

此类是一个抽象类，重写了四个接口之外，还有四个抽象方法，也就是在StringTypeHandler中实现的接口，那么重写的四个接口是什么呢？我们去看一下它所实现的TypeHandler<T>接口

3、接口TypeHandler<T>源代码

 /**
  *    Copyright 2009-2015 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
 package org.apache.ibatis.type;

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

 /**
  * @author Clinton Begin
  */
 public interface TypeHandler<T> {

   void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

   T getResult(ResultSet rs, String columnName) throws SQLException;

   T getResult(ResultSet rs, int columnIndex) throws SQLException;

   T getResult(CallableStatement cs, int columnIndex) throws SQLException;

 }

这里也定义了四个接口，一个set方法用来将javaType转为jdbcType，三个get方法用来将jdbcType转为javaType，而在BaseTypeHandler中实现的就是这四个方法。

所以当我们自定义自己的typeHandler时有两种方法：

第一种：继承BaseTypeHandler类

第二种：实现TypeHandler接口

二、自定义typeHandler

我使用实现TypeHandler接口的方式创建一个MyDateHandler，用来完成javaType中的Date类型与jdbcType中的varchar类型之间的转化。

创建MyDateHandler

 package com.daily.handler;

 import java.sql.CallableStatement;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 import org.apache.ibatis.type.DateTypeHandler;
 import org.apache.ibatis.type.JdbcType;
 import org.apache.ibatis.type.TypeHandler;
 import org.postgresql.jdbc2.optional.SimpleDataSource;

 /**
  * 自定义一个TypeHandler用来将javatype的日期类型和jdbctype的VARCHAR进行转换
  */
 public class MyDateHandler implements TypeHandler<Date> {
     @Override
     // 设置sql中指定索引的参数，即将javaType转化为jdbcType
     public void setParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
         //设置数据存储到数据库中的格式
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         ps.setString(i, sdf.format(parameter));
     }

     @Override
     // 根据列名称从结果集获取值，并将jdbcType转换成javaType
     public Date getResult(ResultSet rs, String columnName) throws SQLException {
         String columnValue = rs.getString(columnName);
         if (null != columnValue) {
             return new Date(Long.valueOf(columnValue));
         }
         return null;
     }

     @Override
     // 根据列名称从结果集获取值，并将jdbcType转换成javaType
     public Date getResult(ResultSet rs, int columnIndex) throws SQLException {
         String columnValue = rs.getString(columnIndex);
         if (null != columnValue) {
             return new Date(Long.valueOf(columnValue));
         }
         return null;
     }

     @Override
     public Date getResult(CallableStatement cs, int columnIndex) throws SQLException {
         String columnValue = cs.getString(columnIndex);
         if (null != columnValue) {
             return new Date(Long.valueOf(columnValue));
         }
         return null;
     }

 }

下面用一个例子来说明这个handler的使用。

1⃣️创建一个blog表，表中的时间用varchar类型

2⃣️创建POJO对象，将create_time和modify_time的类型定义为Date

 package com.daily.pojo;

 import java.util.Date;

 public class Blog {
     private Integer blogId;

     private String blogTitle;

     private String blogContent;

     private Date createTime;

     private Date modifyTime;

     public Integer getBlogId() {
         return blogId;
     }

     public void setBlogId(Integer blogId) {
         this.blogId = blogId;
     }

     public String getBlogTitle() {
         return blogTitle;
     }

     public void setBlogTitle(String blogTitle) {
         this.blogTitle = blogTitle == null ? null : blogTitle.trim();
     }

     public String getBlogContent() {
         return blogContent;
     }

     public void setBlogContent(String blogContent) {
         this.blogContent = blogContent == null ? null : blogContent.trim();
     }

     public Date getCreateTime() {
         return createTime;
     }

     public void setCreateTime(Date createTime) {
         this.createTime = createTime == null ? null : createTime;
     }

     public Date getModifyTime() {
         return modifyTime;
     }

     public void setModifyTime(Date modifyTime) {
         this.modifyTime = modifyTime == null ? null : modifyTime;
     }
 }

3⃣️在mybatis-config.xml文件中注册刚才自定义的MyDateHandler

 <!--类型处理器 -->
     <typeHandlers>
         <!-- 注册自定义handler，说明它作用的jdbcType和javaType -->
         <typeHandler jdbcType="VARCHAR" javaType="date" handler="com.daily.handler.MyDateHandler" />
     </typeHandlers>

4⃣️在BlogMapper.xml文件中使用

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.daily.dao.BlogMapper">
     <resultMap id="BaseResultMap" type="com.daily.pojo.Blog">
         <id column="blog_id" jdbcType="INTEGER" property="blogId" />
         <result column="blog_title" jdbcType="VARCHAR" property="blogTitle" />
         <result column="blog_content" jdbcType="VARCHAR" property="blogContent" />
         <!-- 不使用MyDateHandler-->
         <result column="create_time" jdbcType="VARCHAR" property="createTime" />
         <!-- 使用MyDateHandler-->
         <result column="modify_time" typeHandler="com.daily.handler.MyDateHandler" property="modifyTime" />
     </resultMap>

     <insert id="insert" parameterType="com.daily.pojo.Blog">
         insert into blog (blog_id, blog_title, blog_content,
         create_time, modify_time)
         values (#{blogId,jdbcType=INTEGER}, #{blogTitle,jdbcType=VARCHAR},
         #{blogContent,jdbcType=VARCHAR},
         #{createTime,jdbcType=VARCHAR}, #{modifyTime,typeHandler=com.daily.handler.MyDateHandler})
     </insert>
 </mapper>

5⃣️查看结果

第一种：create_time不设置typeHandler，modify_time设置typeHandler

从上面的结果来看，虽然create_time没有设置typeHandler，但是结果跟使用了typeHandler的modify_time是一样的，那么我把两个都去掉呢？

第二种：两个都不设置

可以看到结果也是一样，下面我去掉注册的MyDateHandler呢？

第三种：去掉MyDateHandler

从上述结果可以看到，当去掉自定义的处理器时，MyBatis会根据结果自动选择合适的handler进行转换。

日常开发中，一般不需要定义，使用默认的就可以，除非是像枚举这种特殊类型就需要自己实现。

以上就是MyBatis配置文件中typeHandlers的配置内容。