• Mybatis TypeHandler 介绍及使用

    Mybatis TypeHandler类型转换器是负责Java类和jdbc类型之间的转换

    主要涉及到下面这几个类：

    • TypeHandler 类型转换器的顶层接口
    • BaseTypeHandler 抽象类继承自TypeHandler，Mybatis中所有的类型转换器实现均继承他。
    • TypeHandlerRegistry 类型转换器注册器，负责存储类型转换器。
    • TypeAliasRegistry 类型别名转换器，用来存储类型与别名的对应关系。

    1 TypeHandler

    TypeHandler是类型转换器的顶层接口，其定义了类型转换器应该具有的功能，

    TypeHandler主要解决了两个问题：

    1. 可以指定我们在Java实体类所包含的自定义类型存入数据库后的类型是什么
    2. 从数据库中取出该数据后自动转换为我们自定义的Java类型

    其源码如下：

    1. public interface TypeHandler<T> {  
    2.    
    3.     /** 
    4.      * 用于定义在Mybatis设置参数时该如何把Java类型的参数转换为对应的数据库类型 
    5.      * @param ps 当前的PreparedStatement对象 
    6.      * @param i 当前参数的位置 
    7.      * @param parameter 当前参数的Java对象 
    8.      * @param jdbcType 当前参数的数据库类型 
    9.      * @throws SQLException 
    10.      */  
    11.     void setParameter(PreparedStatement ps, int i, T parameter,  
    12.            JdbcType jdbcType) throws SQLException;  
    13.    
    14.     /** 
    15.      * 用于在Mybatis获取数据结果集时如何把数据库类型转换为对应的Java类型 
    16.      * @param rs 当前的结果集 
    17.      * @param columnName 当前的字段名称 
    18.      * @return 转换后的Java对象 
    19.      * @throws SQLException 
    20.      */  
    21.     T getResult(ResultSet rs, String columnName) throws SQLException;  
    22.    
    23.     /** 
    24.      * 用于在Mybatis通过字段位置获取字段数据时把数据库类型转换为对应的Java类型 
    25.      * @param rs 当前的结果集 
    26.      * @param columnIndex 当前字段的位置 
    27.      * @return 转换后的Java对象 
    28.      * @throws SQLException 
    29.      */  
    30.     T getResult(ResultSet rs, int columnIndex) throws SQLException;  
    31.    
    32.     /** 
    33.      * 用于Mybatis在调用存储过程后把数据库类型的数据转换为对应的Java类型 
    34.      * @param cs 当前的CallableStatement执行后的CallableStatement 
    35.      * @param columnIndex 当前输出参数的位置 
    36.      * @return 
    37.      * @throws SQLException 
    38.      */  
    39.     T getResult(CallableStatement cs, int columnIndex) throws SQLException;  
    40.    
    41. }

    2 BaseTypeHandler

    BaseTypeHandler是一个抽象类，改类实现了TypeHandler中的方法并实现了异常捕获。继承改类我们可以很容易的实现一个自定义类型转换器，其源码如下：

    1. public abstract class BaseTypeHandler extends TypeReference implements TypeHandler {  
    2.    
    3.   protected Configuration configuration;  
    4.    
    5.   public void setConfiguration(Configuration c) {  
    6.     this.configuration = c;  
    7.   }  
    8.    
    9.   public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {  
    10.     if (parameter == null) {  
    11.       if (jdbcType == null) {  
    12.         throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");  
    13.       }  
    14.       try {  
    15.         ps.setNull(i, jdbcType.TYPE_CODE);  
    16.       } catch (SQLException e) {  
    17.         throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . " +  
    18.              "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. " +  
    19.              "Cause: " + e, e);  
    20.       }  
    21.     } else {  
    22.       setNonNullParameter(ps, i, parameter, jdbcType);  
    23.     }  
    24.   }  
    25.    
    26.   public T getResult(ResultSet rs, String columnName) throws SQLException {  
    27.     T result = getNullableResult(rs, columnName);  
    28.     if (rs.wasNull()) {  
    29.       return null;  
    30.     } else {  
    31.       return result;  
    32.     }  
    33.   }  
    34.    
    35.   public T getResult(ResultSet rs, int columnIndex) throws SQLException {  
    36.     T result = getNullableResult(rs, columnIndex);  
    37.     if (rs.wasNull()) {  
    38.       return null;  
    39.     } else {  
    40.       return result;  
    41.     }  
    42.   }  
    43.    
    44.   public T getResult(CallableStatement cs, int columnIndex) throws SQLException {  
    45.     T result = getNullableResult(cs, columnIndex);  
    46.     if (cs.wasNull()) {  
    47.       return null;  
    48.     } else {  
    49.       return result;  
    50.     }  
    51.   }  
    52.    
    53.   public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;  
    54.    
    55.   public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;  
    56.    
    57.   public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;  
    58.    
    59.   public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;  
    60.    
    61. }

    我们可以看到BaseTypeHandler对TypeHandler接口的四个方法做了一个简单的选择，把null值的情况都做了一个过滤，核心的取值和设值的方法还是抽象出来了供子类来实现。使用BaseTypeHandler还有一个好处是它继承了另外一个叫做TypeReference的抽象类，通过TypeReference的getRawType()方法可以获取到当前TypeHandler所使用泛型的原始类型。这对Mybatis在注册TypeHandler的时候是非常有好处的。在没有指定javaType的情况下，Mybatis在注册TypeHandler时可以通过它来获取当前TypeHandler所使用泛型的原始类型作为要注册的TypeHandler的javaType类型，这个在讲到Mybatis注册TypeHandler的方式时将讲到。

    3 注册TypeHandler

    为什么Java自带的类型在存取的时候不会出错，我们自定义的类型就会出错？那是因为mybatis已经将这些类型的TypeHandler提前写好了，并且注册好了

    具体注册了哪些，我们可以看TypeHandlerRegistry这个类：

    1. public TypeHandlerRegistry(Configuration configuration) {
    2.     this.unknownTypeHandler = new UnknownTypeHandler(configuration);
    3.  
    4.     register(Boolean.class, new BooleanTypeHandler());
    5.     register(boolean.class, new BooleanTypeHandler());
    6.     register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    7.     register(JdbcType.BIT, new BooleanTypeHandler());
    8.  
    9.     register(Byte.class, new ByteTypeHandler());
    10.     register(byte.class, new ByteTypeHandler());
    11.     register(JdbcType.TINYINT, new ByteTypeHandler());
    12.  
    13.     register(Short.class, new ShortTypeHandler());
    14.     register(short.class, new ShortTypeHandler());
    15.     register(JdbcType.SMALLINT, new ShortTypeHandler());
    16.  
    17.     register(Integer.class, new IntegerTypeHandler());
    18.     register(int.class, new IntegerTypeHandler());
    19.     register(JdbcType.INTEGER, new IntegerTypeHandler());
    20.  
    21.     register(Long.class, new LongTypeHandler());
    22.     register(long.class, new LongTypeHandler());
    23.  
    24.     register(Float.class, new FloatTypeHandler());
    25.     register(float.class, new FloatTypeHandler());
    26.     register(JdbcType.FLOAT, new FloatTypeHandler());
    27.  
    28.     register(Double.class, new DoubleTypeHandler());
    29.     register(double.class, new DoubleTypeHandler());
    30.     register(JdbcType.DOUBLE, new DoubleTypeHandler());
    31.  
    32.     register(Reader.class, new ClobReaderTypeHandler());
    33.     register(String.class, new StringTypeHandler());
    34.     register(String.class, JdbcType.CHAR, new StringTypeHandler());
    35.     register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    36.     register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    37.     register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
    38.     register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    39.     register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    40.     register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    41.     register(JdbcType.CHAR, new StringTypeHandler());
    42.     register(JdbcType.VARCHAR, new StringTypeHandler());
    43.     register(JdbcType.CLOB, new ClobTypeHandler());
    44.     register(JdbcType.LONGVARCHAR, new StringTypeHandler());
    45.     register(JdbcType.NVARCHAR, new NStringTypeHandler());
    46.     register(JdbcType.NCHAR, new NStringTypeHandler());
    47.     register(JdbcType.NCLOB, new NClobTypeHandler());
    48.  
    49.     register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    50.     register(JdbcType.ARRAY, new ArrayTypeHandler());
    51.  
    52.     register(BigInteger.class, new BigIntegerTypeHandler());
    53.     register(JdbcType.BIGINT, new LongTypeHandler());
    54.  
    55.     register(BigDecimal.class, new BigDecimalTypeHandler());
    56.     register(JdbcType.REAL, new BigDecimalTypeHandler());
    57.     register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    58.     register(JdbcType.NUMERIC, new BigDecimalTypeHandler());
    59.  
    60.     register(InputStream.class, new BlobInputStreamTypeHandler());
    61.     register(Byte[].class, new ByteObjectArrayTypeHandler());
    62.     register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    63.     register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    64.     register(byte[].class, new ByteArrayTypeHandler());
    65.     register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    66.     register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    67.     register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    68.     register(JdbcType.BLOB, new BlobTypeHandler());
    69.  
    70.     register(Object.class, unknownTypeHandler);
    71.     register(Object.class, JdbcType.OTHER, unknownTypeHandler);
    72.     register(JdbcType.OTHER, unknownTypeHandler);
    73.  
    74.     register(Date.class, new DateTypeHandler());
    75.     register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    76.     register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    77.     register(JdbcType.TIMESTAMP, new DateTypeHandler());
    78.     register(JdbcType.DATE, new DateOnlyTypeHandler());
    79.     register(JdbcType.TIME, new TimeOnlyTypeHandler());
    80.  
    81.     register(java.sql.Date.class, new SqlDateTypeHandler());
    82.     register(java.sql.Time.class, new SqlTimeTypeHandler());
    83.     register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());
    84.  
    85.     register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());
    86.  
    87.     register(Instant.class, new InstantTypeHandler());
    88.     register(LocalDateTime.class, new LocalDateTimeTypeHandler());
    89.     register(LocalDate.class, new LocalDateTypeHandler());
    90.     register(LocalTime.class, new LocalTimeTypeHandler());
    91.     register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());
    92.     register(OffsetTime.class, new OffsetTimeTypeHandler());
    93.     register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());
    94.     register(Month.class, new MonthTypeHandler());
    95.     register(Year.class, new YearTypeHandler());
    96.     register(YearMonth.class, new YearMonthTypeHandler());
    97.     register(JapaneseDate.class, new JapaneseDateTypeHandler());
    98.  
    99.     // issue #273
    100.     register(Character.class, new CharacterTypeHandler());
    101.     register(char.class, new CharacterTypeHandler());
    102.   }

    4. 实现自定义的TypeHandler

    我们可以直接继承BaseTypeHandler来实现我们自己的类型转换器

    我们要实现把json字符串转换成为我们的对象，可以这么实现：

    1. public class JsonTypeHandler extends BaseTypeHandler {
    2. 	
    3.     private final Class type;
    4.  
    5.     public JsonTypeHandler(Class type) {
    6.         if (type == null) {
    7.             throw new IllegalArgumentException("输入参数不能为空");
    8.         }
    9.         this.type = type;
    10.     }
    11.  
    12.     @Override
    13.     public void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType)
    14.             throws SQLException {
    15.         try {
    16.         	String json = JsonUtil.toJson(parameter);
    17.             ps.setString(i, json);
    18.         } catch (Exception e) {
    19.             throw new RuntimeException("Json对象转换成String失败", e);
    20.         }
    21.     }
    22.  
    23.     @Override
    24.     public T getNullableResult(ResultSet rs, String columnName) throws SQLException {
    25.         String json = rs.getString(columnName);
    26.         return convertJsonToObject(json);
    27.     }
    28.  
    29.     @Override
    30.     public T getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    31.         String json = rs.getString(columnIndex);
    32.         return convertJsonToObject(json);
    33.     }
    34.  
    35.     @Override
    36.     public T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    37.         String json = cs.getString(columnIndex);
    38.         return convertJsonToObject(json);
    39.     }
    40.  
    41.     private T convertJsonToObject(String json) {
    42.         try {
    43.             return JsonUtil.fromJson(json, type);
    44.         } catch (Exception e) {
    45.             throw new RuntimeException("json转换成Java对象失败", e);
    46.         }
    47.     }
    48. }

    因为我们使用的是Spring boot工程，只需要把JsonTypeHandler放到Spring boot可以扫描的目录下即可。

    在XML中使用：

    1. <resultMap id="BaseResultMap" type="com.db.model.SettlementBill">
    2. 	    <id column="id" jdbcType="INTEGER" property="id" />
    3. 	    <result column="receipts_code" jdbcType="VARCHAR" property="receiptsCode" />
    4. 	    <result column="finance_info" jdbcType="VARCHAR"  property="financeDetailVO1" 
    5. 		     javaType="com.db.model.SettlementBill"
    6. 		     typeHandler="com.mybatis.handler.JsonArrayTypeHandler" 
    7. 	     />
    8. 	</resultMap>
    9.   
    10.   
    11.   <select id="test" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    12.     select  id, receipts_code, finance_info from settlement_bill where id = #{id,jdbcType=INTEGER}
    13.   </select>

    Mybatis Plus中的使用方式：

    1. @TableName(value = "settlement_bill", autoResultMap = true)
    2. @Data
    3. public class SettlementBill extends CxmBaseModel implements Serializable {
    4. 	@TableId(value = "id", type = IdType.AUTO)
    5. 	private Integer id;
    6. 	
    7. 	@TableField(value = "finance_info",typeHandler = JsonTypeHandler.class)
    8.     private BatchFinanceDetailVO1 financeDetailVO1;
    9. }

    5. Mybatis自动获取TypeHandle

    在介绍了Mybatis是如何注册TypeHandler之后就介绍一下Mybatis是如何获取对应的TypeHandler进行类型转换的。

    如果我们在Mapper.xml文件中配置某一个属性或变量的映射关系时指定了该属性对应的javaType和jdbcType，则Mybatis会从注册好的TypeHandler中寻找对应的javaType和jdbcType组合的TypeHandler进行处理，这也是Mybatis最基本的获取TypeHandler进行类型转换的方式。

    1.javaType和jdbcType都指定

    假设Mybatis配置文件中有这么一段TypeHandler的注册信息：

    1. <typeHandlers>  
    2.    <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>  
    3. </typeHandlers>

    看这样一个UserMapper.xml定义：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5.    
    6. <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">  
    7.    
    8.     <resultMap id="UserResult" type="User">  
    9.        <id column="id" property="id"/>  
    10.        <result column="interests" property="interests" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>  
    11.     </resultMap>  
    12.    
    13.     <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyColumn="id">  
    14.        insert into t_user(name, age, interests) values(#{name}, #{age}, #{interests, javaType=[Ljava.lang.String;, jdbcType=VARCHAR})  
    15.     </insert>  
    16.      
    17.     <update id="updateUser" parameterType="User">  
    18.        update t_user set name=#{name}, age=#{age}, interests=#{interests} where id=#{id}  
    19.     </update>  
    20.      
    21.     <select id="findById" parameterType="int" resultMap="UserResult">  
    22.        select * from t_user where id=#{id}  
    23.     </select>  
    24.      
    25.     <delete id="deleteUser" parameterType="int">  
    26.        delete from t_user where id=#{id}  
    27.     </delete>  
    28. </mapper>

    我们可以看到在id为UserResult的resultMap中，我们定义了一个对应字段interests的映射关系，并且定义了其javaType为“[Ljava.lang.String;”，jdbcType为VARCHAR，这个时候Mybatis就会到已经注册了的TypeHandler中寻找到能处理javaType和jdbcType对应的类型转换的TypeHandler来进行处理。在这里就会找到我们注册的StringArrayTypeHandler。在上面id为insertUser的insert语句中，我们也为变量interests指定了它的javaType和jdbcType属性，这时候Mybatis也会寻找javaType和jdbcType对应的TypeHandler。上面这样定义是Mybatis最基本也是最完整地获取到对应的TypeHandler的方法。

    2. 只指定变量对应的javaType类型。

           这个时候Mybatis会拿着这个javaType和jdbcType为null的组合到注册的TypeHandler中寻找对应的TypeHandler。

    （1）不动StringArrayTypeHandler的注册信息，把我们的UserMapper.xml改为如下形式：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5. <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">  
    6.     <resultMap id="UserResult" type="User">  
    7.        <id column="id" property="id"/>  
    8.        <result column="interests" property="interests" javaType="[Ljava.lang.String;"/>  
    9.     </resultMap>  
    10.    
    11.     <select id="findById" parameterType="int" resultMap="UserResult">  
    12.        select * from t_user where id=#{id}  
    13.     </select>  
    14. </mapper>

    此时我们发现最终执行的结果interests为null，这说明Mybatis没有使用我们定义的StringArrayTypeHandler来转换interests。

    （2）UserMapper.xml还像上面那样定义，但是也只指定javaType属性来注册我们的StringArrayTypeHandler，代码如下：

    1.  
    2.     <typeHandlers>  
    3.        <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>  
    4.     </typeHandlers>

    这个时候再运行上面的测试代码，输出结果发现interests转换为User类字符串数组类型的interests属性。

         这是因为我们是以javaType和null注册的StringArrayTypeHandler，然后在需要转换interests时又是以相同的javaType和null来寻找的，所以就会找到我们注册的StringArrayTypeHandler来进行类型转换。

    3. 只指定变量对应的jdbcType类型

    这个时候Mybatis会利用我们指定的返回类型和对应的属性取该属性在返回类型中对应的javaType，之后再拿着该javaType和我们指定的jdbcType到注册的TypeHandler中获取对应的TypeHandler。

    保持之前指定javaType和jdbcType的方式注册StringArrayTypeHandler，然后在定义interests变量的时候不指定javaType，只指定jdbcType，这个时候UserMapper.xml如下所示：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5. <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">  
    6.     <resultMap id="UserResult" type="User">  
    7.        <id column="id" property="id"/>  
    8.        <result column="interests" property="interests" jdbcType="VARCHAR"/>  
    9.     </resultMap>  
    10.     <select id="findById" parameterType="int" resultMap="UserResult">  
    11.        select * from t_user where id=#{id}  
    12.     </select>  
    13. </mapper>

            这个时候Mybatis是这样获取TypeHandler的：首先它发现我们的interests没有指定javaType，这个时候它就会通过我们指定的类型User和属性interests获取User类的interests属性对应的java类型，即String数组，再拿着获取到的javaType和我们指定的jdbcType即VARCHAR去寻找对应的TypeHandler，这个时候就找到了我们之前以String数组和VARCHAR注册好的StringArrayTypeHandler来处理interests的类型转换。

    4. javaType类型和jdbcType类型都不指定

    这个时候Mybatis会以方式2中的方式获取到对应的javaType类型，然后再以方式1获取到对应的TypeHandler。

            首先，注册一个javaType为String数组，jdbcType不指定即为null的TypeHandler—StringArrayTypeHandler，代码如下：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE configuration  
    3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  
    5. <configuration>  
    6.     <properties resource="config/jdbc.properties"></properties>  
    7.     <typeAliases>  
    8.        <package name="com.tiantian.mybatis.model"/>  
    9.     </typeAliases>  
    10.     <typeHandlers>  
    11.        <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>  
    12.     </typeHandlers>  
    13.     <environments default="development">  
    14.        <environment id="development">  
    15.            <transactionManager type="JDBC" />  
    16.            <dataSource type="POOLED">  
    17.               <property name="driver" value="${jdbc.driver}" />  
    18.               <property name="url" value="${jdbc.url}" />  
    19.               <property name="username" value="${jdbc.username}" />  
    20.               <property name="password" value="${jdbc.password}" />  
    21.            </dataSource>  
    22.        </environment>  
    23.     </environments>  
    24.     <mappers>  
    25.        <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>  
    26.     </mappers>  
    27. </configuration>

             然后，定义我们的interests字段的映射关系时既不指定javaType，又不指定jdbcType，代码如下：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5. <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">  
    6.     <resultMap id="UserResult" type="User">  
    7.        <id column="id" property="id"/>  
    8.        <result column="interests" property="interests"/>  
    9.     </resultMap>  
    10.     <select id="findById" parameterType="int" resultMap="UserResult">  
    11.        select * from t_user where id=#{id}  
    12.     </select>  
    13. </mapper>

            此时我们以javaType为String数组和jdbcType为null注册了一个StringArrayTypeHandler，然后在定义interests字段的映射关系时我们没有指明其对应的javaType和jdbcType，这个时候Mybatis会利用我们指定的User类型和interests属性获取到User类的interests属性对应的java类型，即String数组，然后结合jdbcType为null去寻找注册的TypeHandler，这样就找到了StringArrayTypeHandler。经StringArrayTypeHandler的处理就把jdbcType为VARCHAR的数据转换为javaType为String数组的数据。
     

    5. 直接通过变量的typeHandler属性指定其对应的TypeHandler

    还有一种形式是我们直接通过变量的typeHandler属性指定其对应的TypeHandler，这个时候Mybatis就会使用该用户自己指定的TypeHandler来进行类型转换，而不再以javaType和jdbcType组合的方式获取对应的TypeHandler。

    首先在Mybatis的配置文件中以javaType和jdbcType配套的方式注册一个StringArrayTypeHandler，代码如下：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE configuration  
    3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  
    5. <configuration>  
    6.     <properties resource="config/jdbc.properties"></properties>  
    7.     <typeAliases>  
    8.        <package name="com.tiantian.mybatis.model"/>  
    9.     </typeAliases>  
    10.     <typeHandlers>  
    11.        <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>  
    12.     </typeHandlers>  
    13.     <environments default="development">  
    14.        <environment id="development">  
    15.            <transactionManager type="JDBC" />  
    16.            <dataSource type="POOLED">  
    17.               <property name="driver" value="${jdbc.driver}" />  
    18.               <property name="url" value="${jdbc.url}" />  
    19.               <property name="username" value="${jdbc.username}" />  
    20.               <property name="password" value="${jdbc.password}" />  
    21.            </dataSource>  
    22.        </environment>  
    23.     </environments>  
    24.     <mappers>  
    25.        <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>  
    26.     </mappers>  
    27. </configuration>

    按照前面说的Mybatis按照变量的javaType和jdbcType来取对应的TypeHandler的话，这里注册的StringArrayTypeHandler只有在指定变量的javaType为字符串数组而jdbcType为VARCHAR的情况下才能被获取到。

    然后我们在UserMapper.xml文件中不指定interests字段对应的javaType和jdbcType，但是通过typeHandler属性指定将以StringArrayTypeHandler来进行类型转换，代码如下：

    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5. <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">  
    6.     <resultMap id="UserResult" type="User">  
    7.        <id column="id" property="id"/>  
    8.        <result column="interests" property="interests" 
    9. typeHandler="com.tiantian.mybatis.handler.StringArrayTypeHandler"/>  
    10.     </resultMap>  
    11.     <select id="findById" parameterType="int" resultMap="UserResult">  
    12.        select * from t_user where id=#{id}  
    13.     </select>  
    14. </mapper>

    这是因为我们指定了进行interests字段的映射关系时使用StringArrayTypeHandler来进行类型转换。当指定了某一个字段或变量进行映射关系时所使用的TypeHandler时，Mybatis在需要进行类型转换时就使用给定的TypeHandler进行类型转换，而不会再通过javaType和jdbcType的组合去注册好的TypeHandler中寻找对应的TypeHandler。

  • 相关阅读:
    Java三大版本及 JVM JDK JRE 及 SDK API
    x86 架构的机载计算机，它来了！
    Echarts ----写属性设置
    flutter系列之:做一个下载按钮的动画
    创建 gstreamer 插件的几种方式
    编程题练习@9-13
    冒泡排序c++
    PIMPL技巧
    苏州金龙客车为新疆哪吒车队提供车辆交车
    华为云云耀云服务器L实例评测|利用服务器打造可视化运维管理中心
  • 原文地址：https://blog.csdn.net/Crystalqy/article/details/133923124