Mybatis类型转换介绍

最新推荐文章于 2023-05-18 15:54:15 发布
最新推荐文章于 2023-05-18 15:54:15 发布
阅读量442 收藏 1
点赞数
分类专栏： Myibatis

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

我们知道java有java的数据类型，数据库有数据库的数据类型，那么我们在往数据库中插入数据的时候是如何把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，其中有一个属性interests是String数组类型，如下所示：

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类型的相互转换。在这里我们建立一个名叫StringArrayTypeHandler的TypeHandler，代码如下所示：

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

 

       我们可以看到BaseTypeHandler对TypeHandler接口的四个方法做了一个简单的选择，把null值的情况都做了一个过滤，核心的取值和设值的方法还是抽象出来了供子类来实现。使用BaseTypeHandler还有一个好处是它继承了另外一个叫做TypeReference的抽象类，通过TypeReference的getRawType()方法可以获取到当前TypeHandler所使用泛型的原始类型。这对Mybatis在注册TypeHandler的时候是非常有好处的。在没有指定javaType的情况下，Mybatis在注册TypeHandler时可以通过它来获取当前TypeHandler所使用泛型的原始类型作为要注册的TypeHandler的javaType类型，这个在讲到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属性来指定要扫描的包，如果这个时候我们也需要指定对应TypeHandler的javaType和jdbcType的话就需要我们在TypeHandler类上使用注解来定义了。Mybatis注册TypeHandler最基本的方式就是建立一个javaType、jdbcType和TypeHandler的对应关系。在使用typeHandler子元素进行注册的时候，有三种类型的注册方式：

1.如果我们指定了javaType和jdbcType，那么Mybatis会注册一个对应javaType和jdbcType的TypeHandler。

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

（1）如果我们通过注解的形式在TypeHandler类上用@MappedJdbcTypes指定了对应的jdbcType，那么Mybatis会一一注册指定的javaType、jdbcType和TypeHandler的组合，也包括使用这种形式指定了jdbcType为null的情况。现假设我们有如下这样一个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在实际注册的时候是以javaType为String数组，jdbcType为VARCHAR来注册StringArrayTypeHandler的。

（2）如果没有使用@MappedJdbcTypes注解指定对应的jdbcType，那么这个时候Mybatis会把jdbcType置为null，然后注册一个javaType、null和TypeHandler的组合。

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

（1）如果TypeHandler类上使用了注解@MappedTypes指定了对应的javaType，那么Mybatis将一一利用对应的javaType和TypeHandler去以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注册的还是javaType为String数组，jdbcType为VARCHAR这样一个组合的TypeHandler。

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

（3）TypeHandler类上既没有标注@MappedTypes，又没有继承TypeReference抽象类。这种情况Mybatis会以null和null的组合注册该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文件中配置某一个属性或变量的映射关系时指定了该属性对应的javaType和jdbcType，则Mybatis会从注册好的TypeHandler中寻找对应的javaType和jdbcType组合的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>  

 

       我们可以看到在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的方法。这里我们来对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发生作用了。

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

       1.只指定变量对应的javaType类型。这个时候Mybatis会拿着这个javaType和jdbcType为null的组合到注册的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=张三]  

 

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

       （2）UserMapper.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=张三]  

 

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

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

       保持之前指定javaType和jdbcType的方式注册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和我们指定的jdbcType即VARCHAR去寻找对应的TypeHandler，这个时候就找到了我们之前以String数组和VARCHAR注册好的StringArrayTypeHandler来处理interests的类型转换。

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

       （1）首先，注册一个javaType为String数组，jdbcType不指定即为null的TypeHandler—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>  

 

       （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=张三]  

 

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

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

       （1）首先在Mybatis的配置文件中以javaType和jdbcType配套的方式注册一个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按照变量的javaType和jdbcType来取对应的TypeHandler的话，这里注册的StringArrayTypeHandler只有在指定变量的javaType为字符串数组而jdbcType为VARCHAR的情况下才能被获取到。

       （2）然后我们在UserMapper.xml文件中不指定interests字段对应的javaType和jdbcType，但是通过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进行类型转换，而不会再通过javaType和jdbcType的组合去注册好的TypeHandler中寻找对应的TypeHandler。

1.5     Mybatis中自动注册的TypeHandler

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

Java代码   收藏代码
  1. register(Boolean.class, new BooleanTypeHandler());  
  2. register(boolean.class, new BooleanTypeHandler());  
  3. register(Byte.class, new ByteTypeHandler());  
  4. register(byte.class, new ByteTypeHandler());  
  5. register(Short.class, new ShortTypeHandler());  
  6. register(short.class, new ShortTypeHandler());  
  7. register(Integer.class, new IntegerTypeHandler());  
  8. register(int.class, new IntegerTypeHandler());  
  9. register(Long.class, new LongTypeHandler());  
  10. register(long.class, new LongTypeHandler());  
  11. register(Float.class, new FloatTypeHandler());  
  12. register(float.class, new FloatTypeHandler());  
  13. register(Double.class, new DoubleTypeHandler());  
  14. register(double.class, new DoubleTypeHandler());  
  15. register(String.class, new 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.class, new BigIntegerTypeHandler());  
  25. register(BigDecimal.class, new BigDecimalTypeHandler());  
  26. register(Byte[].class, new ByteObjectArrayTypeHandler());  
  27. register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());  
  28. register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());  
  29. register(byte[].class, new 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.class, new DateTypeHandler());  
  35. register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());  
  36. register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());  
  37. register(java.sql.Date.class, new SqlDateTypeHandler());  
  38. register(java.sql.Time.class, new SqlTimeTypeHandler());  
  39. register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());  
  40. register(Character.class, new CharacterTypeHandler());  
  41. register(char.class, new CharacterTypeHandler());  
东北小硬人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springmybatis
09-05
MyBatis 目录(?)[-] mybatis实战教程mybatis in action之一开发环境搭建 mybatis实战教程mybatis in action之二以接口的方式编程 mybatis实战教程mybatis in action之三实现数据的增删改查 mybatis实战教程mybatis in action之四实现关联数据的查询 mybatis实战教程mybatis in action之五与spring3集成附源码 mybatis实战教程mybatis in action之六与Spring MVC 的集成 mybatis实战教程mybatis in action之七实现mybatis分页源码下载 mybatis实战教程mybatis in action之八mybatis 动态sql语句 mybatis实战教程mybatis in action之九mybatis 代码生成工具的使用 mybatis SqlSessionDaoSupport的使用附代码下载 转自：http://www.yihaomen.com/article/java/302.htm （读者注：其实这个应该叫做很基础的入门一下下，如果你看过Hibernate了那这个就非常的简单） （再加一条，其实大家可以看官方的教程更好些：http://mybatis.github.io/mybatis-3/，而且如果英文不是很好的那就看中文的：http://mybatis.github.io/mybatis-3/zh/sqlmap-xml.html） 写在这个系列前面的话: 以前曾经用过ibatis,这是mybatis的前身，当时在做项目时，感觉很不错，比hibernate灵活。性能也比hibernate好。而且也比较轻量级，因为当时在项目中，没来的及做很很多笔记。后来项目结束了，我也没写总结文档。已经过去好久了。但最近突然又对这个ORM 工具感兴趣。因为接下来自己的项目中很有可能采用这个ORM工具。所以在此重新温习了一下 mybatis, 因此就有了这个系列的 mybatis 教程. 什么是mybatis MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plan Old Java Objects，普通的Java对象）映射成数据库中的记录. orm工具的基本思想 无论是用过的hibernate,mybatis,你都可以法相他们有一个共同点： 1. 从配置文件(通常是XML配置文件中)得到 sessionfactory. 2. 由sessionfactory 产生 session 3. 在session 中完成对数据的增删改查和事务提交等. 4. 在用完之后关闭session 。 5. 在java 对象和 数据库之间有做mapping 的配置文件，也通常是xml 文件。 mybatis实战教程(mybatis in action)之一：开发环境搭建 mybatis 的开发环境搭建，选择: eclipse j2ee 版本，mysql 5.1 ,jdk 1.7,mybatis3.2.0.jar包。这些软件工具均可以到各自的官方网站上下载。 首先建立一个名字为 MyBaits 的 dynamic web project 1. 现阶段，你可以直接建立java 工程，但一般都是开发web项目，这个系列教程最后也是web的，所以一开始就建立web工程。 2. 将 mybatis-3.2.0-SNAPSHOT.jar，mysql-connector-java-5.1.22-bin.jar 拷贝到 web工程的lib目录. 3. 创建mysql 测试数据库和用户表,注意，这里采用的是 utf-8 编码 创建用户表,并插入一条测试数据 程序代码 程序代码 Create TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `userName` varchar(50) DEFAULT NULL, `userAge` int(11) DEFAULT NULL, `userAddress` varchar(200) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; Insert INTO `user` VALUES ('1', 'summer', '100', 'shanghai,pudong'
mybatis中接收array，如何配置handler
搬砖农民工的博客
09-08 1870
1.增加Handler数组转换类 编写ArrayAllTypeHandler 继承BaseTypeHandler就行了 import java.math.BigDecimal; import java.math.BigInteger; import java.net.URL; import java.sql.Array; import java.sql.CallableStatement; import java.sql.Date; import java.sql.PreparedStatement; im
mybatis中字符串数字
苍穹尘的博客
05-24 1万+
1、条件查询时，不指定jdbcType=VARCHAR，若入参是0012346595时将查不到数据。 <if test="filmCode != null and filmCode != ''"> and f.film_code= #{filmCode} </if> 原因：当不指定jdbcType为字符串时，字符串0012346595将会被转换为数值12346595，...
mybatis 处理数组类型及使用Json格式保存数据 JsonTypeHandler and ArrayTypeHandler
Joe192的博客
03-20 4126
mybatis 比 ibatis 改进了很多，特别是支持了注解，支持了plugin inteceptor，也给开发者带来了更多的灵活性，相比其他ORM，我还是挺喜欢mybatis的。
Mybatis类型转换介绍 TypeHandler
08-10
NULL 博文链接：https://zw7534313.iteye.com/blog/2221078
MyBatis自定义类型转换器实现加解密
09-01
主要介绍了MyBatis自定义类型转换器实现加解密的相关资料,需要的朋友可以参考下
mybatis 对clob类型转换
10-30
mybatis 对clob类型转换,解决clob类型数据插入数据库报异常问题
Mybatis实现自定义类型转换器TypeHandler的方法
09-01
Mybatis实现自定义的转换器非常的简单，只需要三步就可以实现自定义类型转换器TypeHandler，非常不错，具有参考借鉴价值，感兴趣的朋友一起看下吧
mybatis中实现枚举自动转换方法详解
08-29
在使用mybatis的时候经常会遇到枚举类型的转换，下面这篇文章主要给大家介绍了关于mybatis中实现枚举自动转换的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或工作具有一定的参考学习价值，需要的朋友们...
mybatis StringArrayTypeHandler
qq_44272797的博客
05-27 523
package com.ruoyi.common.data.typeHandler; import org.apache.ibatis.type.BaseTypeHandler; import org.apache.ibatis.type.JdbcType; import java.sql.CallableStatement; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLExceptio
MyBatis惊天bug！居然将字符串解析成数值类型！
JavaEdge全是干货的技术号
08-31 2530
mybatis会自动映射字段，在mapper.xml文件中，可以不写jdbcType显式指定数据类型，它会自动解析成相对应的Java数据类型，但是今天写代码就遇到了问题： 业务场景是需要根据不同权限的用户查询不同数据，又因为一些历史原因，所以就直接将用户ID当字符串类型的参数传递进来。 List<String> getOwnAssignedOrderNo(@Param("backendId") String backendId, @Param("userId") String userId);
Mybatis 返回数组 两种方式
热门推荐
Aa_duidui的博客
08-27 1万+
mysql没有数组这种类型,我们可以以数组格式的字符串加入到数据库,返回值是数组 1.Mapper.xml 返回数组 <resultMap type="返回实体类" id="result" > <result property="实体类字段名" column="mysql字段名" typeHandler="处理数据的文件"/> </resultMap> <select id="Mapper.java的方法名" parameterType="传参类型" r
java mapper层 mybatis 字符串被强转成数字 - 解决方案
Ryan_black的博客
06-04 1906
第一次碰到这种情况还是快上线的前几天,慌得雅痞. 报错信息: 本来就是字符串为什么突然给我强转成数字,就离谱 最后也是在一位远在他乡的朋友的帮助下和一位热心网友的帮助下,成功用两种方法尝试成功. 方法1(外单内双): 方法2(加toString()): 有朋友就是好~ ...
MyBatis 类型转换器
做一名持续学习的GIS Coder
05-18 2146
在数据库中采用varchar、text等字符串类型存储一个整形id集合，id间采用“,”分隔符分割，但在Java（MyBatis）实体中我们希望使用List ids来映射数据库中的字段。// 将List类型的属性转换成数据库中的字符串 StringBuilder sb = new StringBuilder();// 将数据库中的字符串转换成List类型的属性 String str = rs . getString(columnName);
java mybatis操作 postgresql array数组类型备忘
weixin_40434637的博客
10-13 1010
postgrey sql数据库字段类型varchar[],java使用String[]类型，自定义ArrayTypeHandler ArrayTypeHandler.java public class ArrayTypeHandler extends BaseTypeHandler<Object[]> { private static final String TYPE_NAME_VARCHAR = "varchar"; private static final String
mybatis字符串转成数字_贝程学院：前端面试js算法 - 字符串篇
weixin_39742727的博客
12-03 795
1. 计算字符串中某个字符的个数 var aaa='1231011211009181'; function count(str){ var arr=[]; for(var i=0;i<str.length;i++){ if(str.charAt(i)=='1'){ ...
Mybatis SQL字符串转换为数组
qq_42030055的博客
08-15 1万+
Mybatis SQL字符串转换为数组Mybatis SQL字符串转换为数组SQL语句操作合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图Mybat...
mybatis类型转换json格式
最新发布
09-17
MyBatis中使用注解@Results和@ResultMap可以进行类型转换为json格式。在@Results中可以使用@Result的type属性指定转换为json，例如：@Result(property = "orderIds", column = "order_id_list", typeHandler = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值