绵阳梓潼网站制作公司

Mybatis自定义typeHandler实现类型转化

 

创新互联公司专注于青铜峡网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供青铜峡营销型网站建设，青铜峡网站制作、青铜峡网页设计、青铜峡网站官网定制、小程序制作服务，打造青铜峡网络公司原创品牌,更为您提供青铜峡网站排名全网营销落地服务。

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

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

1.2.1  TypeHandler接口

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

Java代码  Mybatis自定义typeHandler实现类型转化

  1. public interface TypeHandler {  

  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代码  Mybatis自定义typeHandler实现类型转化

  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代码  Mybatis自定义typeHandler实现类型转化

  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 {  

  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代码  Mybatis自定义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的方式时将讲到。

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

Java代码  Mybatis自定义typeHandler实现类型转化

  1. public class StringArrayTypeHandler extends BaseTypeHandler {  

  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代码  Mybatis自定义typeHandler实现类型转化

  1. @MappedJdbcTypes({JdbcType.VARCHAR})  

  2. public class StringArrayTypeHandler implements TypeHandler {  

  3.     //..中间的实现代码省略了  

  4.     //..  

  5. }  

 

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

Xml代码  Mybatis自定义typeHandler实现类型转化

  1.   

  2.      

  3.   

 

       则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代码  Mybatis自定义typeHandler实现类型转化

  1. @MappedTypes({String[].class})  

  2. @MappedJdbcTypes({JdbcType.VARCHAR})  

  3. public class StringArrayTypeHandler implements TypeHandler {  

  4.    

  5.      

  6.    

  7. }  

 

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

Xml代码  Mybatis自定义typeHandler实现类型转化

  1.   

  2.      

  3.   

 

     则这个时候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代码  Mybatis自定义typeHandler实现类型转化

  1.   

  3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  

  4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  

  5.   

  6.    

  7.       

  8.       

  9.          

  10.       

  11.       

  12.          

  13.       

  14.       

  15.          

  16.              

  17.              

  18.                 

  19.                 

  20.                 

  21.                 

  22.              

  23.          

  24.       

  25.       

  26.          

  27.          

  28.       

  29.   

 

       注意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代码  Mybatis自定义typeHandler实现类型转化

  1.   

  2.      

  3.   

 

看这样一个UserMapper.xml定义：

Xml代码  Mybatis自定义typeHandler实现类型转化

  1.   

  3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  

  4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  

  5.    

  6.   

  7.    

  8.       

  9.          

  10.          

  11.       

  12.    

  13.       

  14.        insert into t_user(name, age, interests) values(#{name}, #{age}, #{interests, javaType=[Ljava.lang.String;, jdbcType=VARCHAR})  

  15.       

  16.      

  17.       

  18.        update t_user set name=#{name}, age=#{age}, interests=#{interests} where id=#{id}  

  19.       

  20.      

  21.       

  22.        select * from t_user where id=#{id}  

  23.       

  24.      

  25.       

  26.        delete from t_user where id=#{id}  

  27.       

  28.   

 

       我们可以看到在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代码  Mybatis自定义typeHandler实现类型转化

  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代码  Mybatis自定义typeHandler实现类型转化

  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代码  Mybatis自定义typeHandler实现类型转化

  1.   

  3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  

  4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  

  5.   

  6.       

  7.          

  8.          

  9.       

  10.    

  11.       

  12.        select * from t_user where id=#{id}  

  13.       

  14.   

 

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

Text代码  Mybatis自定义typeHandler实现类型转化

  1. User [age=30, id=20, interests=null, name=张三]  

 

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

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

Xml代码  Mybatis自定义typeHandler实现类型转化

  1.   

  3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  

  4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  

  5.   

  6.       

  7.       

  8.          

  9.       

  10.       


  11. 网页题目：Mybatis自定义typeHandler实现类型转化
    URL标题：http://myzitong.com/article/iiieei.html

其他资讯