Mybatis源码分析（三）通过实例来看typeHandlers

Love The Way You Lie 2022-02-22 13:04 208阅读 0赞

# 一、案例分析 #

在日常开发中，我们肯定有对日期类型的操作。比如订单时间、付款时间等，通常这一类数据在数据库以 `datetime`类型保存。如果需要在页面上展示此值，在Java中以什么类型接收它呢？

在不执行任何二次操作的情况下： 用 `java.util.Date`接收，在页面展示的就是 `TueOct1616:05:13CST2018`。 用 `java.lang.String`接收，在页面展示的就是 `2018-10-1616:10:47.0`。

显然，我们不能显示第一种。第二种似乎可行，但大部分情况下不能出现毫秒数。当然了，不管哪种方式，在显示的时候format一下当然是可行的。有没有更好的方式呢？

# 二、typeHandlers #

无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。 在数据库中，datetime和timestamp类型含义是一样的，不过timestamp存储空间小， 所以它表示的时间范围也更小。 下面来看几个Mybatis默认的时间类型处理器。

<table> 
 <thead> 
  <tr> 
   <th>JDBC 类型</th> 
   <th>Java 类型</th> 
   <th>类型处理器</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DATE</td> 
   <td>java.util.Date</td> 
   <td>DateOnlyTypeHandler</td> 
  </tr> 
  <tr> 
   <td>DATE</td> 
   <td>java.sql.Date</td> 
   <td>SqlDateTypeHandler</td> 
  </tr> 
  <tr> 
   <td>DATE</td> 
   <td>java.time.LocalDate</td> 
   <td>LocalDateTypeHandler</td> 
  </tr> 
  <tr> 
   <td>DATE</td> 
   <td>java.time.LocalTime</td> 
   <td>LocalTimeTypeHandler</td> 
  </tr> 
  <tr> 
   <td>TIMESTAMP</td> 
   <td>java.util.Date</td> 
   <td>DateTypeHandler</td> 
  </tr> 
  <tr> 
   <td>TIMESTAMP</td> 
   <td>java.time.Instant</td> 
   <td>InstantTypeHandler</td> 
  </tr> 
  <tr> 
   <td>TIMESTAMP</td> 
   <td>java.time.LocalDateTime</td> 
   <td>LocalDateTimeTypeHandler</td> 
  </tr> 
  <tr> 
   <td>TIMESTAMP</td> 
   <td>java.sql.Timestamp</td> 
   <td>SqlTimestampTypeHandler</td> 
  </tr> 
 </tbody> 
</table>

它是什么意思呢？如果数据库字段类型为 `JDBC类型`，同时Java字段的类型为 `Java类型`，那么就调用类型处理器 `类型处理器`。

# 三、自定义处理器 #

基于上面这个逻辑，我们可以增加一种处理器来处理我们开头所描述的问题。我们可以在Java中，以String类型接收数据库的DateTime类型数据。因为现在的接口以restful风格居多，用String类型方便传输。 最后的毫秒数通过自定义的处理器统一截取去除即可。

<table> 
 <thead> 
  <tr> 
   <th>JDBC 类型</th> 
   <th>Java 类型</th> 
   <th>类型处理器</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>TIMESTAMP</td> 
   <td>java.lang.String</td> 
   <td>CustomTypeHandler</td> 
  </tr> 
 </tbody> 
</table>

@MappedJdbcTypes注解表示JDBC的类型，@MappedTypes表示Java属性的类型。

@MappedJdbcTypes({ JdbcType.TIMESTAMP })
    @MappedTypes({ String.class })
    public class CustomTypeHandler 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 substring(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);
       }
       private String substring(String value) {
           if (!"".endsWith(value) && value != null) {
               return value.substring(0, value.length() - 2);
           }
           return value;
       }
    }

通过以上方式，我们就可以放心的在Java中以String接收数据库的时间类型数据了。

# 四、源码分析 #

1、注册

public final class TypeHandlerRegistry {
       //typeHandler为当前自定义类型处理器
       public <T> void register(TypeHandler<T> typeHandler) {
           boolean mappedTypeFound = false;
           //mappedTypes即String
           MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
           if (mappedTypes != null) {
               for (Class<?> handledType : mappedTypes.value()) {
                   register(handledType, typeHandler);
               }
           }
       }
    }

public final class TypeHandlerRegistry {
       private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
           //JDBC的类型，即TIMESTAMP
           MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().
                   getAnnotation(MappedJdbcTypes.class);
           if (mappedJdbcTypes != null) {
               for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
                   //TYPE_HANDLER_MAP是Java类型中的默认处理器。
                   //以String为例，它默认可以处理VARCHAR、CHAR、NVARCHAR、CLOB、NCLOB、NULL
                   Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
                   //给String添加一种处理器为typeHandler
                   map.put(jdbcType, typeHandler);
                   //注册处理器实例
                   ALL_TYPE_HANDLERS_MAP.put(typeHandler.getClass(), typeHandler);
               }
           }
       }
    }

# 2、调用 #

注册完毕之后，它在什么地方生效呢？关键在于能否可以找到这个处理器。看完上面的注册过程，查找其实很简单。先从TYPEHANDLERMAP根据JavaType，获取String类型的全部处理器，再从中过滤出JDBC类型为TIMESTAMP的即可。

private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
       //根据JavaType获取String类型的全部处理器
       Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
       TypeHandler<?> handler = null;
       if (jdbcHandlerMap != null) {
           //再根据jdbcType获取到TIMESTAMP的处理器
           handler = jdbcHandlerMap.get(jdbcType);
       }
       return (TypeHandler<T>) handler;
    }

拿到自定义的处理器，我们自己就随便搞喽~

不过，在Mybatis-3.2.7版本中，比较坑。在调用getTypeHandler方法时，它并没有传jdbcType这个参数，所以这个参数默认为NULL了。 那么，在执行 `jdbcHandlerMap.get(jdbcType)`的时候，会找不到自定义的处理器，而是找到了NULL的处理器，即StringHandler。案发现场在下面:

public class ResultSetWrapper {
       public TypeHandler<?> getTypeHandler(Class<?> propertyType, String columnName) {
           //3.4.6
           JdbcType jdbcType = getJdbcType(columnName);
           handler = typeHandlerRegistry.getTypeHandler(propertyType, jdbcType);
           //3.2.7
           handler = typeHandlerRegistry.getTypeHandler(propertyType);
       }
    }

# 五、总结 #

自定义处理器的应用场景很广泛，比如对某些敏感字段加密、状态值的转换(正常、注销、 已付款、未发货)等。回顾一下你的项目中有哪些地方实现的不太理想，可以考虑用它来做。

# 六、后续 #

在笔者写完这篇文章后，在另外一台电脑做测试的时候，发现尽管没有对时间类型做处理，但也不会出现.0的问题。这使我睡觉都没安稳。。。难道自己认知有误，文章写错了？笔者决定先抛开Mybatis，用最原始的JDBC做测试。

public static void main(String[] args) throws Exception {
       Connection conn = getConnection();
       Statement stat = conn.createStatement();
       String sql = "select * from user";
       ResultSet rs = stat.executeQuery(sql);
       while(rs.next()){
           String username = rs.getString("username");
           String createtime = rs.getString("createtime");
           System.out.print("姓名: " + username);
           System.out.print("  创建时间: " + createtime);
           System.out.print("\n");
       }
    }

结果让我很意外，用原始的JDBC查询数据，并没有任何其他操作，也没有.0的问题。

1.  `姓名: 关小羽    创建时间: 2018-10-15 17:04:11`
2.  `姓名: 小露娜    创建时间: 2018-10-15 17:10:46`
3.  `姓名: 亚麻瑟    创建时间: 2018-10-15 17:10:46`
4.  `姓名: 小鲁班    创建时间: 2018-10-16 16:10:47`

上面的代码量很小，显然问题出在 `ResultSet`对象上。通过跟踪源码，最后笔者发现两台机器的mysql-connector-java版本不一样。一个是5.1.31，一个是6.0.6。我们把版本换成5.1.31，执行上面的main方法再看结果。

1.  `姓名: 关小羽    创建时间: 2018-10-15 17:04:11.0`
2.  `姓名: 小露娜    创建时间: 2018-10-15 17:10:46.0`
3.  `姓名: 亚麻瑟    创建时间: 2018-10-15 17:10:46.0`
4.  `姓名: 小鲁班    创建时间: 2018-10-16 16:10:47.0`

好了，让我们看看它们的差别在哪里吧。其实就是因为5.1.31多做了一步操作，它针对时间类型的数据又处理了一次，导致问题产生。

5.1.31

package com.mysql.jdbc;
    public class ResultSetImpl implements ResultSetInternalMethods {
       protected String getStringInternal(int columnIndex, boolean checkDateTypes)
           // JDBC is 1-based, Java is not !?
           int internalColumnIndex = columnIndex - 1;
           Field metadata = this.fields[internalColumnIndex];      
           String stringVal = null;    
           String encoding = metadata.getCharacterSet();
           //stringVal为已经从数据库取到的值2018-10-16 16:10:47
           stringVal = this.thisRow.getString(internalColumnIndex, encoding, this.connection);
           // Handles timezone conversion and zero-date behavior
           //Mysql针对时间类型又做了一次处理
           if (checkDateTypes && !this.connection.getNoDatetimeStringSync()) {
               switch (metadata.getSQLType()) {
               case Types.TIME:
                   ......略
               case Types.DATE:
                   ......略
               case Types.TIMESTAMP:
                   //数据库的DateTime类型会走到这里
                   //MySQL把它又转成了Timestamp类型,  .0的问题从这里产生
                   Timestamp ts = getTimestampFromString(columnIndex,
                           null, stringVal, this.getDefaultTimeZone(), false);
                   return ts.toString();
               default:
                   break;
               }
           }
           return stringVal;
       }
    }

6.0.6

package com.mysql.cj.jdbc.result;
    public class ResultSetImpl extends MysqlaResultset
                   implements ResultSetInternalMethods, WarningListener {
       public String getString(int columnIndex) throws SQLException {
           Field f = this.columnDefinition.getFields()[columnIndex - 1];
           ValueFactory<String> vf = new StringValueFactory(f.getEncoding());
           // return YEAR values as Dates if necessary
           if (f.getMysqlTypeId() == MysqlaConstants.FIELD_TYPE_YEAR && this.yearIsDateType) {
               vf = new YearToDateValueFactory<>(vf);
           }
           String stringVal = this.thisRow.getValue(columnIndex - 1, vf);
           return stringVal;
       }
    }

如果大家项目里面有.0问题产生，可以通过升级mysql-java版本解决。如果不能动版本，再考虑自定义的类型处理器。