Mybatis类型转换介绍

转载 2015年07月10日 14:30:17

Mybatis类型转换介绍

1.1     目录

1.2     建立TypeHandler

1.2.1    TypeHandler接口

1.2.2    BaseTypeHandler抽象类

1.3     注册TypeHandler

1.4     Mybatis自动获取TypeHandler

1.5     Mybatis中自动注册的TypeHandler

 

 

1.2     建立TypeHandler

我们知道javajava的数据类型,数据库有数据库的数据类型,那么我们在往数据库中插入数据的时候是如何把java类型当做数据库类型插入数据库,在从数据库读取数据的时候又是如何把数据库类型当做java类型来处理呢?这中间必然要经过一个类型转换。在Mybatis中我们可以定义一个叫做TypeHandler类型处理器的东西,通过它可以实现Java类型跟数据库类型的相互转换。下面将就如何建立自己的TypeHandler做一个简要介绍。

1.2.1  TypeHandler接口

       Mybatis中要实现自己的TypeHandler就需要实现Mybatis为我们提供的TypeHandler接口。在TypeHandler中定义了四个方法:

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. }  

 

       现在假设我们有一个实体对象User,其中有一个属性interestsString数组类型,如下所示:

Java代码   收藏代码
  1. public class User {  
  2.    
  3.     private int id;  
  4.     private String name;  
  5.     private int age;  
  6.     private String[] interests;  
  7.    
  8.     public int getId() {  
  9.        return id;  
  10.     }  
  11.    
  12.     public void setId(int id) {  
  13.        this.id = id;  
  14.     }  
  15.    
  16.     public String getName() {  
  17.        return name;  
  18.     }  
  19.    
  20.     public void setName(String name) {  
  21.        this.name = name;  
  22.     }  
  23.    
  24.     public int getAge() {  
  25.        return age;  
  26.     }  
  27.    
  28.     public void setAge(int age) {  
  29.        this.age = age;  
  30.     }  
  31.    
  32.     public String[] getInterests() {  
  33.        return interests;  
  34.     }  
  35.    
  36.     public void setInterests(String[] interests) {  
  37.        this.interests = interests;  
  38.     }  
  39.    
  40.     @Override  
  41.     public String toString() {  
  42.        return "User [age=" + age + ", id=" + id + ", interests="  
  43.               + Arrays.toString(interests) + ", name=" + name + "]";  
  44.     }  
  45.      
  46. }  

 

我们需要把它以拼接字符串的形式存到数据库中,然后在取出来的时候又把它还原为一个String数组。这个时候我们就可以给它定义一个TypeHandler专门来处理String数组类型和数据库VARCHAR类型的相互转换。在这里我们建立一个名叫StringArrayTypeHandlerTypeHandler,代码如下所示:

Java代码   收藏代码
  1. package com.tiantian.mybatis.handler;  
  2.    
  3. import java.sql.CallableStatement;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7. import java.sql.Types;  
  8.    
  9. import org.apache.ibatis.type.JdbcType;  
  10. import org.apache.ibatis.type.TypeHandler;  
  11.    
  12. public class StringArrayTypeHandler implements TypeHandler<String[]> {  
  13.    
  14.        public String[] getResult(ResultSet rs, String columnName)  
  15.                      throws SQLException {  
  16.               String columnValue = rs.getString(columnName);  
  17.               return this.getStringArray(columnValue);  
  18.        }  
  19.    
  20.        public String[] getResult(ResultSet rs, int columnIndex)  
  21.                      throws SQLException {  
  22.               String columnValue = rs.getString(columnIndex);  
  23.               return this.getStringArray(columnValue);  
  24.        }  
  25.    
  26.        public String[] getResult(CallableStatement cs, int columnIndex)  
  27.                      throws SQLException {  
  28.               // TODO Auto-generated method stub  
  29.               String columnValue = cs.getString(columnIndex);  
  30.               return this.getStringArray(columnValue);  
  31.        }  
  32.    
  33.        public void setParameter(PreparedStatement ps, int i, String[] parameter,  
  34.                      JdbcType jdbcType) throws SQLException {  
  35.               if (parameter == null)  
  36.                      ps.setNull(i, Types.VARCHAR);  
  37.               else {  
  38.                      StringBuffer result = new StringBuffer();  
  39.                      for (String value : parameter)  
  40.                             result.append(value).append(",");  
  41.                      result.deleteCharAt(result.length()-1);  
  42.                      ps.setString(i, result.toString());  
  43.               }  
  44.        }  
  45.    
  46.        private String[] getStringArray(String columnValue) {  
  47.               if (columnValue == null)  
  48.                      return null;  
  49.               return columnValue.split(",");  
  50.        }  
  51.    
  52. }  

 

1.2.2  BaseTypeHandler抽象类

       在实现自己的TypeHandler时,除了上面提到的实现最原始的接口之外,Mybatis还为我们提供了一个实现了TypeHandler接口的抽象类BaseTypeHandler。所以我们也可以通过继承BaseTypeHandler来实现自己的TypeHandler

       我们先来看一下BaseTypeHandler类的定义:

Java代码   收藏代码
  1. public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {  
  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. }  

 

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

       当通过继承BaseTypeHandler来实现自己的TypeHandler时,我们的StringArrayTypeHandler应该这样写:

Java代码   收藏代码
  1. public class StringArrayTypeHandler extends BaseTypeHandler<String[]> {  
  2.    
  3.     @Override  
  4.     public String[] getNullableResult(ResultSet rs, String columnName)  
  5.            throws SQLException {  
  6.        return getStringArray(rs.getString(columnName));  
  7.     }  
  8.    
  9.     @Override  
  10.     public String[] getNullableResult(ResultSet rs, int columnIndex)  
  11.            throws SQLException {  
  12.        return this.getStringArray(rs.getString(columnIndex));  
  13.     }  
  14.    
  15.     @Override  
  16.     public String[] getNullableResult(CallableStatement cs, int columnIndex)  
  17.            throws SQLException {  
  18.        return this.getStringArray(cs.getString(columnIndex));  
  19.     }  
  20.    
  21.     @Override  
  22.     public void setNonNullParameter(PreparedStatement ps, int i,  
  23.            String[] parameter, JdbcType jdbcType) throws SQLException {  
  24.        //由于BaseTypeHandler中已经把parameter为null的情况做了处理,所以这里我们就不用再判断parameter是否为空了,直接用就可以了  
  25.        StringBuffer result = new StringBuffer();  
  26.        for (String value : parameter)  
  27.            result.append(value).append(",");  
  28.        result.deleteCharAt(result.length()-1);  
  29.        ps.setString(i, result.toString());  
  30.     }  
  31.      
  32.     private String[] getStringArray(String columnValue) {  
  33.        if (columnValue == null)  
  34.            return null;  
  35.        return columnValue.split(",");  
  36.     }  
  37. }  

 

 

1.3     注册TypeHandler

       建立了自己的TypeHandler之后就需要把它注册到Mybatis的配置文件中,让Mybatis能够识别并使用它。注册TypeHandler主要有两种方式,一种是通过在Mybatis配置文件中定义typeHandlers元素的子元素typeHandler来注册;另一种是通过在Mybatis配置文件中定义typeHandlers元素的子元素package来注册。使用typeHandler子元素注册时一次只能注册一个TypeHandler,而使用package子元素注册时,Mybatis会把指定包里面的所有TypeHandler都注册为TypeHandler。使用typeHandler子元素注册时我们需要通过它的handler属性来指明当前要注册的TypeHandler的全名称,这个属性是必须要的。另外还有两个附加属性可以指定,一个是javaType,用以指定对应的java类型;另一个是jdbcType,用以指定对应的jdbc类型。使用package子元素注册时需要我们通过它的name属性来指定要扫描的包,如果这个时候我们也需要指定对应TypeHandlerjavaTypejdbcType的话就需要我们在TypeHandler类上使用注解来定义了。Mybatis注册TypeHandler最基本的方式就是建立一个javaTypejdbcTypeTypeHandler的对应关系。在使用typeHandler子元素进行注册的时候,有三种类型的注册方式:

1.如果我们指定了javaTypejdbcType,那么Mybatis会注册一个对应javaTypejdbcTypeTypeHandler

2.如果我们只指定了javaType属性,那么这个时候又分两种情况:

1)如果我们通过注解的形式在TypeHandler类上用@MappedJdbcTypes指定了对应的jdbcType,那么Mybatis会一一注册指定的javaTypejdbcTypeTypeHandler的组合,也包括使用这种形式指定了jdbcTypenull的情况。现假设我们有如下这样一个StringArrayTypeHandler

Java代码   收藏代码
  1. @MappedJdbcTypes({JdbcType.VARCHAR})  
  2. public class StringArrayTypeHandler implements TypeHandler<String[]> {  
  3.     //..中间的实现代码省略了  
  4.     //..  
  5. }  

 

       然后我们在Mybatis的配置文件中这样注册它:

Xml代码   收藏代码
  1. <typeHandlers>  
  2.    <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>  
  3. </typeHandlers>  

 

       Mybatis在实际注册的时候是以javaTypeString数组,jdbcTypeVARCHAR来注册StringArrayTypeHandler的。

2)如果没有使用@MappedJdbcTypes注解指定对应的jdbcType,那么这个时候Mybatis会把jdbcType置为null,然后注册一个javaTypenullTypeHandler的组合。

3.既没有指定javaType属性,又没有指定jdbcType属性,或者只指定了jdbcType属性。这种情况又分三种类型:

1)如果TypeHandler类上使用了注解@MappedTypes指定了对应的javaType,那么Mybatis将一一利用对应的javaTypeTypeHandler去以2的方式进行注册。现假设我们定义了这样一个StringArrayTypeHandler

Java代码   收藏代码
  1. @MappedTypes({String[].class})  
  2. @MappedJdbcTypes({JdbcType.VARCHAR})  
  3. public class StringArrayTypeHandler implements TypeHandler<String[]> {  
  4.    
  5.      
  6.    
  7. }  

 

       然后,在Mybatis的配置文件中注册它时既不指定它的javaType属性也不指定它的jdbcType属性,代码如下:

Xml代码   收藏代码
  1. <typeHandlers>  
  2.    <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler"/>  
  3. </typeHandlers>  

 

     则这个时候Mybatis在注册该StringArrayTypeHandler的时候首先会判断它上面有没有标注@MappedTypes,如果有则把它的MappedTypes一一拿出来作为javaType,然后以方式2进行注册。所以这里实际上Mybatis注册的还是javaTypeString数组,jdbcTypeVARCHAR这样一个组合的TypeHandler

2TypeHandler类上没有使用@MappedTypes指定对应的javaType时,如果当前的TypeHandler继承了TypeReference抽象类,Mybatis会利用TypeReferencegetRawType()方法取到当前TypeHandler泛型对应的javaType类型,然后利用取得的javaTypeTypeHandler2的方式进行注册,同时还包括一个javaTypenull以方式2进行的注册。TypeReferenceMybatis中定义的一个抽象类,主要是用来获取对应的泛型类型。

3TypeHandler类上既没有标注@MappedTypes,又没有继承TypeReference抽象类。这种情况Mybatis会以nullnull的组合注册该TypeHandler

使用package子元素注册的TypeHandler会以上面的方式3进行注册。

这里我们如下注册我们的TypeHandler

Xml代码   收藏代码
  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.    
  7.     <properties resource="config/jdbc.properties"></properties>  
  8.     <typeAliases>  
  9.        <package name="com.tiantian.mybatis.model"/>  
  10.     </typeAliases>  
  11.     <typeHandlers>  
  12.        <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>  
  13.     </typeHandlers>  
  14.     <environments default="development">  
  15.        <environment id="development">  
  16.            <transactionManager type="JDBC" />  
  17.            <dataSource type="POOLED">  
  18.               <property name="driver" value="${jdbc.driver}" />  
  19.               <property name="url" value="${jdbc.url}" />  
  20.               <property name="username" value="${jdbc.username}" />  
  21.               <property name="password" value="${jdbc.password}" />  
  22.            </dataSource>  
  23.        </environment>  
  24.     </environments>  
  25.     <mappers>  
  26.        <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>  
  27.        <package name="com.tiantian.mybatis.mapperinterface"/>  
  28.     </mappers>  
  29. </configuration>  

 

       注意String数组的全类名称是“[Ljava.lang.String;”,所以上面在注册StringArrayTypeHandler时定义的javaType属性为“[Ljava.lang.String;”。

1.4     Mybatis自动获取TypeHandler

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

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

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

 

看这样一个UserMapper.xml定义:

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>  

 

       我们可以看到在idUserResultresultMap中,我们定义了一个对应字段interests的映射关系,并且定义了其javaType为“[Ljava.lang.String;”,jdbcTypeVARCHAR,这个时候Mybatis就会到已经注册了的TypeHandler中寻找到能处理javaTypejdbcType对应的类型转换的TypeHandler来进行处理。在这里就会找到我们注册的StringArrayTypeHandler。在上面idinsertUserinsert语句中,我们也为变量interests指定了它的javaTypejdbcType属性,这时候Mybatis也会寻找javaTypejdbcType对应的TypeHandler。上面这样定义是Mybatis最基本也是最完整地获取到对应的TypeHandler的方法。这里我们来对UserMapper(它的代码我就不贴出来了,有Mybatis基础的都应该知道它的代码)的findById来做一个测试:

Java代码   收藏代码
  1. @Test   
  2. public void testFind() {  
  3.    SqlSession sqlSession = sqlSessionFactory.openSession();  
  4.    try {  
  5.        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  6.        User user = userMapper.findById(20);  
  7.        System.out.println(user);  
  8.    } finally {  
  9.        sqlSession.close();  
  10.    }  
  11. }  

 

       其输出结果如下:

Text代码   收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三]  

 

我们可以看到Mybatis已经把我们存放在数据库中VARCHAR类型的字段interests转换为User类字符串数组类型的interests属性,这说明我们定义的StringArrayTypeHandler发生作用了。

除了上面的完整指定一个变量对应的javaTypejdbcType,让Mybatis能够完美的找到对应的TypeHandler之外。我们平常在使用的时候可能还有以下方式:

       1.只指定变量对应的javaType类型。这个时候Mybatis会拿着这个javaTypejdbcTypenull的组合到注册的TypeHandler中寻找对应的TypeHandler。这里我们同样来做一个测试:

       1)不动StringArrayTypeHandler的注册信息,把我们的UserMapper.xml改为如下形式:

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>  

 

       这时候再运行上面的测试程序,输出结果如下:

Text代码   收藏代码
  1. User [age=30, id=20, interests=null, name=张三]  

 

       我们可以看到输出的interestsnull,这说明Mybatis没有使用我们定义的StringArrayTypeHandler来转换interests

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

Xml代码   收藏代码
  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>  

 

       这个时候再运行上面的测试代码,输出结果如下:

Text代码   收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三]  

 

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

       2.只指定变量对应的jdbcType类型。这个时候Mybatis会利用我们指定的返回类型和对应的属性取该属性在返回类型中对应的javaType,之后再拿着该javaType和我们指定的jdbcType到注册的TypeHandler中获取对应的TypeHandler。这里我们来看这样一个测试:

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

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>  

 

       这个时候继续运行上面的测试代码,输出结果如下:

Text代码   收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三]  

 

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

       3.javaType类型和jdbcType类型都不指定。这个时候Mybatis会以方式2中的方式获取到对应的javaType类型,然后再以方式1获取到对应的TypeHandler。这里我们也来做一个测试:

       1)首先,注册一个javaTypeString数组,jdbcType不指定即为nullTypeHandlerStringArrayTypeHandler,代码如下:

Xml代码   收藏代码
  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>  

 

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

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"/>  
  9.     </resultMap>  
  10.     <select id="findById" parameterType="int" resultMap="UserResult">  
  11.        select * from t_user where id=#{id}  
  12.     </select>  
  13. </mapper>  

 

       这个时候再运行上面的测试代码,输出如下:

Text代码   收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三]  

 

       这种情况是这样的:我们以javaTypeString数组和jdbcTypenull注册了一个StringArrayTypeHandler,然后在定义interests字段的映射关系时我们没有指明其对应的javaTypejdbcType,这个时候Mybatis会利用我们指定的User类型和interests属性获取到User类的interests属性对应的java类型,即String数组,然后结合jdbcTypenull去寻找注册的TypeHandler,这样就找到了StringArrayTypeHandler。经StringArrayTypeHandler的处理就把jdbcTypeVARCHAR的数据转换为javaTypeString数组的数据,所以输出结果如上所示。

       4.还有一种形式是我们直接通过变量的typeHandler属性指定其对应的TypeHandler,这个时候Mybatis就会使用该用户自己指定的TypeHandler来进行类型转换,而不再以javaTypejdbcType组合的方式获取对应的TypeHandler。这里我们也来做一个测试:

       1)首先在Mybatis的配置文件中以javaTypejdbcType配套的方式注册一个StringArrayTypeHandler,代码如下:

Xml代码   收藏代码
  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按照变量的javaTypejdbcType来取对应的TypeHandler的话,这里注册的StringArrayTypeHandler只有在指定变量的javaType为字符串数组而jdbcTypeVARCHAR的情况下才能被获取到。

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

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" typeHandler="com.tiantian.mybatis.handler.StringArrayTypeHandler"/>  
  9.     </resultMap>  
  10.     <select id="findById" parameterType="int" resultMap="UserResult">  
  11.        select * from t_user where id=#{id}  
  12.     </select>  
  13. </mapper>  

 

       运行上面的测试代码,输出结果:

Text代码   收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三]  

 

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

1.5     Mybatis中自动注册的TypeHandler

       对于一些常用类型的自动转换Mybatis已经为我们建立了相关的TypeHandler,并且会自动注册它们,这主要包括:

Java代码   收藏代码
  1. register(Boolean.classnew BooleanTypeHandler());  
  2. register(boolean.classnew BooleanTypeHandler());  
  3. register(Byte.classnew ByteTypeHandler());  
  4. register(byte.classnew ByteTypeHandler());  
  5. register(Short.classnew ShortTypeHandler());  
  6. register(short.classnew ShortTypeHandler());  
  7. register(Integer.classnew IntegerTypeHandler());  
  8. register(int.classnew IntegerTypeHandler());  
  9. register(Long.classnew LongTypeHandler());  
  10. register(long.classnew LongTypeHandler());  
  11. register(Float.classnew FloatTypeHandler());  
  12. register(float.classnew FloatTypeHandler());  
  13. register(Double.classnew DoubleTypeHandler());  
  14. register(double.classnew DoubleTypeHandler());  
  15. register(String.classnew StringTypeHandler());  
  16. register(String.class, JdbcType.CHAR, new StringTypeHandler());  
  17. register(String.class, JdbcType.CLOB, new ClobTypeHandler());  
  18. register(String.class, JdbcType.VARCHAR, new StringTypeHandler());  
  19. register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());  
  20. register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());  
  21. register(String.class, JdbcType.NCHAR, new NStringTypeHandler());  
  22. register(String.class, JdbcType.NCLOB, new NClobTypeHandler());  
  23. register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());  
  24. register(BigInteger.classnew BigIntegerTypeHandler());  
  25. register(BigDecimal.classnew BigDecimalTypeHandler());  
  26. register(Byte[].classnew ByteObjectArrayTypeHandler());  
  27. register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());  
  28. register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());  
  29. register(byte[].classnew ByteArrayTypeHandler());  
  30. register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());  
  31. register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());  
  32. register(Object.class, UNKNOWN_TYPE_HANDLER);  
  33. register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);  
  34. register(Date.classnew DateTypeHandler());  
  35. register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());  
  36. register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());  
  37. register(java.sql.Date.classnew SqlDateTypeHandler());  
  38. register(java.sql.Time.classnew SqlTimeTypeHandler());  
  39. register(java.sql.Timestamp.classnew SqlTimestampTypeHandler());  
  40. register(Character.classnew CharacterTypeHandler());  
  41. register(char.classnew CharacterTypeHandler());  

Mybatis类型转换介绍

1.1     目录 1.2     建立TypeHandler 1.2.1    TypeHandler接口 1.2.2    BaseTypeHandler抽象类 1.3     注册TypeHa...

mysql varchar类型转换int类型

select * from gyzd_yysinfo order by cast(yysid as SIGNED INTEGER)或者select * from gyzd_yysinfo order ...

给定A, B两个整数,不使用除法和取模运算,求A/B的商和余数

给定A, B两个整数,不使用除法和取模运算,求A/B的商和余数。 1.   最基本的算法是,从小到大遍历: for (i = 2 to A -1)          if (i * B > A)...

配置SOIL库,实现纹理加载

SOIL 是一个用于向OpenGL中加载

SceneManager.LoadScene的使用方法

SceneManager.LoadScene的使用方法
  • XYK0318
  • XYK0318
  • 2016年03月17日 09:52
  • 18766

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

C语言dup和dup2函数

功能:复制文件描述符 头文件:#include 函数原型:int dup(int oldfd)           int dup2(int oldfd,int newfd) 功能详解:dup和d...

weui loading效果实现

界面 --> ...

Logger日志级别说明及设置方法、说明

Logger日志级别说明及设置方法、说明

DELPHI ClientData使用详解

转自http://hi.baidu.com/%B6%C0%C7%E9%B1%F9%D0%C4/blog/item/de918639d9fde2ff55e723fa.html 在三层结构中,TClie...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Mybatis类型转换介绍
举报原因:
原因补充:

(最多只允许输入30个字)