Mybatis类型转换介绍

最新推荐文章于 2023-02-01 20:59:29 发布
最新推荐文章于 2023-02-01 20:59:29 发布
阅读量2.7k 收藏 1
点赞数
分类专栏： 数据库 MyiBatis 文章标签： Mybatis类型转换介绍
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xo_zhang/article/details/8936182
版权

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> {
  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;
  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;
  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;
  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;
  41. } 
public interface TypeHandler<T> {     /**     * 用于定义在Mybatis设置参数时该如何把Java类型的参数转换为对应的数据库类型     * @param ps 当前的PreparedStatement对象     * @param i 当前参数的位置     * @param parameter 当前参数的Java对象     * @param jdbcType 当前参数的数据库类型     * @throws SQLException     */    void setParameter(PreparedStatement ps, int i, T parameter,           JdbcType jdbcType) throws SQLException;     /**     * 用于在Mybatis获取数据结果集时如何把数据库类型转换为对应的Java类型     * @param rs 当前的结果集     * @param columnName 当前的字段名称     * @return 转换后的Java对象     * @throws SQLException     */    T getResult(ResultSet rs, String columnName) throws SQLException;     /**     * 用于在Mybatis通过字段位置获取字段数据时把数据库类型转换为对应的Java类型     * @param rs 当前的结果集     * @param columnIndex 当前字段的位置     * @return 转换后的Java对象     * @throws SQLException     */    T getResult(ResultSet rs, int columnIndex) throws SQLException;     /**     * 用于Mybatis在调用存储过程后把数据库类型的数据转换为对应的Java类型     * @param cs 当前的CallableStatement执行后的CallableStatement     * @param columnIndex 当前输出参数的位置     * @return     * @throws SQLException     */    T getResult(CallableStatement cs, int columnIndex) throws SQLException; }

现在假设我们有一个实体对象User，其中有一个属性interests是String数组类型，如下所示：

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

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

Java代码 复制代码 收藏代码
  1. package com.tiantian.mybatis.handler;
  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;
  9. import org.apache.ibatis.type.JdbcType;
  10. import org.apache.ibatis.type.TypeHandler;
  12. public class StringArrayTypeHandler implements TypeHandler<String[]> {
  14. public String[] getResult(ResultSet rs, String columnName)
  15. throws SQLException {
  16. String columnValue = rs.getString(columnName);
  17. return this.getStringArray(columnValue);
  18. }
  20. public String[] getResult(ResultSet rs, int columnIndex)
  21. throws SQLException {
  22. String columnValue = rs.getString(columnIndex);
  23. return this.getStringArray(columnValue);
  24. }
  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. }
  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. }
  46. private String[] getStringArray(String columnValue) {
  47. if (columnValue == null)
  48. return null;
  49. return columnValue.split(",");
  50. }
  52. } 
package com.tiantian.mybatis.handler; import java.sql.CallableStatement;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Types; import org.apache.ibatis.type.JdbcType;import org.apache.ibatis.type.TypeHandler; public class StringArrayTypeHandler implements TypeHandler<String[]> {        public String[] getResult(ResultSet rs, String columnName)                     throws SQLException {              String columnValue = rs.getString(columnName);              return this.getStringArray(columnValue);       }        public String[] getResult(ResultSet rs, int columnIndex)                     throws SQLException {              String columnValue = rs.getString(columnIndex);              return this.getStringArray(columnValue);       }        public String[] getResult(CallableStatement cs, int columnIndex)                     throws SQLException {              // TODO Auto-generated method stub              String columnValue = cs.getString(columnIndex);              return this.getStringArray(columnValue);       }        public void setParameter(PreparedStatement ps, int i, String[] parameter,                     JdbcType jdbcType) throws SQLException {              if (parameter == null)                     ps.setNull(i, Types.VARCHAR);              else {                     StringBuffer result = new StringBuffer();                     for (String value : parameter)                            result.append(value).append(",");                     result.deleteCharAt(result.length()-1);                     ps.setString(i, result.toString());              }       }        private String[] getStringArray(String columnValue) {              if (columnValue == null)                     return null;              return columnValue.split(",");       } }

1.2.2 BaseTypeHandler抽象类

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

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

Java代码 复制代码 收藏代码
  1. public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {
  3. protected Configuration configuration;
  5. public void setConfiguration(Configuration c) {
  6. this.configuration = c;
  7. }
  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. }
  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. }
  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. }
  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. }
  53. public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;
  55. public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;
  57. public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;
  59. public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;
  61. } 
public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {   protected Configuration configuration;   public void setConfiguration(Configuration c) {    this.configuration = c;  }   public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {    if (parameter == null) {      if (jdbcType == null) {        throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");      }      try {        ps.setNull(i, jdbcType.TYPE_CODE);      } catch (SQLException e) {        throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . " +             "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. " +             "Cause: " + e, e);      }    } else {      setNonNullParameter(ps, i, parameter, jdbcType);    }  }   public T getResult(ResultSet rs, String columnName) throws SQLException {    T result = getNullableResult(rs, columnName);    if (rs.wasNull()) {      return null;    } else {      return result;    }  }   public T getResult(ResultSet rs, int columnIndex) throws SQLException {    T result = getNullableResult(rs, columnIndex);    if (rs.wasNull()) {      return null;    } else {      return result;    }  }   public T getResult(CallableStatement cs, int columnIndex) throws SQLException {    T result = getNullableResult(cs, columnIndex);    if (cs.wasNull()) {      return null;    } else {      return result;    }  }   public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;   public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;   public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;   public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException; }

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

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. } 
@MappedJdbcTypes({JdbcType.VARCHAR})public class StringArrayTypeHandler implements TypeHandler<String[]> {    //..中间的实现代码省略了    //..}

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

Xml代码 复制代码 收藏代码
  1. <typeHandlers>
  2. <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>
  3. </typeHandlers> 
    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>    </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[]> {
  7. } 
@MappedTypes({String[].class})@MappedJdbcTypes({JdbcType.VARCHAR})public class StringArrayTypeHandler implements TypeHandler<String[]> {     }

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

Xml代码 复制代码 收藏代码
  1. <typeHandlers>
  2. <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler"/>
  3. </typeHandlers> 
    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler"/>    </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>
  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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>     <properties resource="config/jdbc.properties"></properties>    <typeAliases>       <package name="com.tiantian.mybatis.model"/>    </typeAliases>    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>    </typeHandlers>    <environments default="development">       <environment id="development">           <transactionManager type="JDBC" />           <dataSource type="POOLED">              <property name="driver" value="${jdbc.driver}" />              <property name="url" value="${jdbc.url}" />              <property name="username" value="${jdbc.username}" />              <property name="password" value="${jdbc.password}" />           </dataSource>       </environment>    </environments>    <mappers>       <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>       <package name="com.tiantian.mybatis.mapperinterface"/>    </mappers></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> 
    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>    </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">
  6. <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">
  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>
  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>
  17. <update id="updateUser" parameterType="User">
  18. update t_user set name=#{name}, age=#{age}, interests=#{interests} where id=#{id}
  19. </update>
  21. <select id="findById" parameterType="int" resultMap="UserResult">
  22. select * from t_user where id=#{id}
  23. </select>
  25. <delete id="deleteUser" parameterType="int">
  26. delete from t_user where id=#{id}
  27. </delete>
  28. </mapper> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.tiantian.mybatis.mapper.UserMapper">     <resultMap id="UserResult" type="User">       <id column="id" property="id"/>       <result column="interests" property="interests" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>    </resultMap>     <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyColumn="id">       insert into t_user(name, age, interests) values(#{name}, #{age}, #{interests, javaType=[Ljava.lang.String;, jdbcType=VARCHAR})    </insert>       <update id="updateUser" parameterType="User">       update t_user set name=#{name}, age=#{age}, interests=#{interests} where id=#{id}    </update>       <select id="findById" parameterType="int" resultMap="UserResult">       select * from t_user where id=#{id}    </select>       <delete id="deleteUser" parameterType="int">       delete from t_user where id=#{id}    </delete></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. } 
    @Test    public void testFind() {       SqlSession sqlSession = sqlSessionFactory.openSession();       try {           UserMapper userMapper = sqlSession.getMapper(UserMapper.class);           User user = userMapper.findById(20);           System.out.println(user);       } finally {           sqlSession.close();       }    }

其输出结果如下：

Text代码 复制代码 收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三] 
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>
  11. <select id="findById" parameterType="int" resultMap="UserResult">
  12. select * from t_user where id=#{id}
  13. </select>
  14. </mapper> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.tiantian.mybatis.mapper.UserMapper">    <resultMap id="UserResult" type="User">       <id column="id" property="id"/>       <result column="interests" property="interests" javaType="[Ljava.lang.String;"/>    </resultMap>     <select id="findById" parameterType="int" resultMap="UserResult">       select * from t_user where id=#{id}    </select></mapper>

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

Text代码 复制代码 收藏代码
  1. User [age=30, id=20, interests=null, name=张三] 
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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>    <properties resource="config/jdbc.properties"></properties>    <typeAliases>       <package name="com.tiantian.mybatis.model"/>    </typeAliases>    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>    </typeHandlers>    <environments default="development">       <environment id="development">           <transactionManager type="JDBC" />           <dataSource type="POOLED">              <property name="driver" value="${jdbc.driver}" />              <property name="url" value="${jdbc.url}" />              <property name="username" value="${jdbc.username}" />              <property name="password" value="${jdbc.password}" />           </dataSource>       </environment>    </environments>    <mappers>       <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>    </mappers></configuration>

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

Text代码 复制代码 收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三] 
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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.tiantian.mybatis.mapper.UserMapper">    <resultMap id="UserResult" type="User">       <id column="id" property="id"/>       <result column="interests" property="interests" jdbcType="VARCHAR"/>    </resultMap>    <select id="findById" parameterType="int" resultMap="UserResult">       select * from t_user where id=#{id}    </select></mapper>

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

Text代码 复制代码 收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三] 
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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>    <properties resource="config/jdbc.properties"></properties>    <typeAliases>       <package name="com.tiantian.mybatis.model"/>    </typeAliases>    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;"/>    </typeHandlers>    <environments default="development">       <environment id="development">           <transactionManager type="JDBC" />           <dataSource type="POOLED">              <property name="driver" value="${jdbc.driver}" />              <property name="url" value="${jdbc.url}" />              <property name="username" value="${jdbc.username}" />              <property name="password" value="${jdbc.password}" />           </dataSource>       </environment>    </environments>    <mappers>       <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>    </mappers></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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.tiantian.mybatis.mapper.UserMapper">    <resultMap id="UserResult" type="User">       <id column="id" property="id"/>       <result column="interests" property="interests"/>    </resultMap>    <select id="findById" parameterType="int" resultMap="UserResult">       select * from t_user where id=#{id}    </select></mapper>

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

Text代码 复制代码 收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三] 
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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>    <properties resource="config/jdbc.properties"></properties>    <typeAliases>       <package name="com.tiantian.mybatis.model"/>    </typeAliases>    <typeHandlers>       <typeHandler handler="com.tiantian.mybatis.handler.StringArrayTypeHandler" javaType="[Ljava.lang.String;" jdbcType="VARCHAR"/>    </typeHandlers>    <environments default="development">       <environment id="development">           <transactionManager type="JDBC" />           <dataSource type="POOLED">              <property name="driver" value="${jdbc.driver}" />              <property name="url" value="${jdbc.url}" />              <property name="username" value="${jdbc.username}" />              <property name="password" value="${jdbc.password}" />           </dataSource>       </environment>    </environments>    <mappers>       <mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>    </mappers></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> 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.tiantian.mybatis.mapper.UserMapper">    <resultMap id="UserResult" type="User">       <id column="id" property="id"/>       <result column="interests" property="interests" typeHandler="com.tiantian.mybatis.handler.StringArrayTypeHandler"/>    </resultMap>    <select id="findById" parameterType="int" resultMap="UserResult">       select * from t_user where id=#{id}    </select></mapper>

运行上面的测试代码，输出结果：

Text代码 复制代码 收藏代码
  1. User [age=30, id=20, interests=[Music, Movie, NBA], name=张三] 
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());
xo_zhang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis类型转换器使用
Linging_24的博客
04-23 5052
1、mybatis类型转换器，就是Java类型与数据库的类型之间转换的一个中介，由这个转换器可以对类型进行映射，mybatis对于基础类型都有默认类型转换器，你可以自定义类型转换器替代默认的转换器，大多数情况下你无需替代它，但是对于Java中的复杂类型，比如对象想要映射成数据库的json字符串，那么你就可以自定义类型转换器。 mybatis自定义类型转换器可以继承TypeHandler或BaseTypeHandler两个接口，并实现其中的方法。 BaseTypeHandler继承TypeHandler，它们
mybatis 关键字in值数组和字符串与java中将字符串转数组
最新发布
h_DK888的博客
04-30 180
【代码】mybatis 关键字in值数组和字符串与java中将字符串转数组。
Mybatis之类型转换器TypeHandler的初步了解及具体使用方法
weixin_43448760的博客
12-20 6510
Mybatis之类型转换器TypeHandler的初步了解及具体使用方法
MyBatis惊天bug！居然将字符串解析成数值类型！
JavaEdge全是干货的技术号
08-31 2557
mybatis会自动映射字段，在mapper.xml文件中，可以不写jdbcType显式指定数据类型，它会自动解析成相对应的Java数据类型，但是今天写代码就遇到了问题： 业务场景是需要根据不同权限的用户查询不同数据，又因为一些历史原因，所以就直接将用户ID当字符串类型的参数传递进来。 List<String> getOwnAssignedOrderNo(@Param("backendId") String backendId, @Param("userId") String userId);
一文搞懂MyBatis中的TypeHandler
DogLee奋斗屋
02-01 1553
结合示例工程，对Mybatis中的类型处理器TypeHandler的定义，实现方式，生效条件进行了深入分析。
Mybatis类型转换介绍 TypeHandler
08-10
在Mybatis中，TypeHandler起着至关重要的作用，它是Mybatis处理Java类型与JDBC类型之间转换的桥梁。这篇博文将深入探讨Mybatis的TypeHandler机制及其在实际开发中的应用。 TypeHandler的主要职责是将Java类型的参数...
MyBatis自定义类型转换器实现加解密
09-01
在MyBatis中，自定义类型转换器是用于处理特定数据类型与数据库字段之间的转换，以便在持久化操作中满足特定需求，如本例中的加解密。在需求场景中，如果你希望数据库中存储的数据（如敏感信息）在存储前进行加密，...
mybatis 对clob类型转换
10-30
在使用MyBatis框架进行数据操作时，我们可能会遇到CLOB类型数据的读写问题，尤其是在转换和插入数据库时。本篇将详细探讨MyBatis中处理CLOB类型数据的转换以及解决可能出现的异常情况。 首先，MyBatis是Java中的一...
Mybatis实现自定义类型转换器TypeHandler的方法
09-01
下面将详细介绍如何在MyBatis中实现自定义类型转换器。 首先，我们需要了解MyBatis的基本概念。MyBatis是一个优秀的持久层框架，它允许开发者编写SQL查询、存储过程，并进行高级映射。MyBatis消除了手动设置参数和...
Mybatis自定义类型转换器的使用技巧
08-26
在这篇文章中，我们将详细介绍Mybatis自定义类型转换器的使用技巧，通过示例代码来演示其使用方法。 首先，Mybatis中的类型转换器是什么？类型转换器是Mybatis中的一种机制，用于将Java对象转换为数据库中的数据...
字符串转数组，mybatis中in查询
qq_43077857的博客
06-23 864
然后 in查询
mybatis not in 及 数组转字符串，字符串转数组不带中括号问题[]解决
qq_42419105的博客
12-04 2881
废话不多说，直接上代码 先看mybatis not in ，如图： 两张图做一下对比 这里主要也就是 $和#取值的区别，通常很少用到$，但是用的时候一定要注意 接下来看字符串和数组的转换 字符串转数组： String str = "0,1,2"; // ,表示转为数组后用,分割 String[] arr = str.split(","); //打印结果 [...
mybatis字符串转成数字_计算机储存数字和字符的方法你了解多少？
weixin_39595621的博客
12-04 1250
前语：不要为了读文章而读文章，一定要带着问题来读文章，勤思考。本文链接：http://1t.click/J7E前言最近在学习中涉及到计算机储存、传输数字和字符等操作，由于对字节、2进制、10进制、16进制、ASCII码的概念以及它们之间的关系和转换理解的不够透彻，导致在通讯、MD5消息摘要算法等时候出现问题，是因为数据转成计算机认识的01的这个环节出现问题。由于这个问题并不是那么容易发...
mybatis 存储blob数据
热门推荐
archer的技术故事
11-08 1万+
mybatis 存储blob数据 存储blob数据的主要过程： 1、读取文件（本地或者前台传给后台）。 2、文件转换成byte[]。 3、存储到数据库中。 下面是一个例子程序，采用的是springmvc，spring，mybatis框架： customer.java public class Customer { private String cuscode;
mybatis 自定义 TypeHandler
Lou_Lan的博客
10-20 3890
文章目录概述提问回答一、如何自定义typeHandler二、如何配置使用typeHandler？以及mybatis-plus自带方法如何使用？三、@MappedJdbcTypes和@MappedTypes的作用是什么四、typeHandler如何配置单个字段使用？以及如何配置全局使用？全局使用单个字段的使用五、如何进行身份证，密码，手机号，邮箱等等的脱敏处理 概述   TypeHandler顾名思义就是类型处理器，这里类型指的是数据库类型和java类型之间的处理。   通常情况下我们使用mybatis的时候
一文帮你搞定MyBatis的类型转换模块，深度好文，欢迎一键三连!!!
波波烤鸭的博客
07-30 3585
  本文来给大家详细的分析下MyBatis的基础支持层中的类型转换模块。 类型转换模块   MyBatis是一个持久层框架ORM框架，实现数据库中数据和Java对象中的属性的双向映射，那么不可避免的就会碰到类型转换的问题，在PreparedStatement为SQL语句绑定参数时，需要从Java类型转换为JDBC类型，而从结果集中获取数据时，则需要从JDBC类型转换为Java类型，所以我们来看下在MyBatis中是如何实现类型的转换的。 String sql = "SELECT id,user.
MyBatis 包含的jdbcType类型/javaType和jdbcType对应和CRUD例子
Lord丶灰烬的博客
07-07 2113
MyBatis 通过包含的jdbcType类型 BIT         FLOAT      CHAR           TIMESTAMP       OTHER       UNDEFINED TINYINT     REAL       VARCHAR        BINARY          BLOB        NVARCHAR SMALLINT    DOUB
自己的List的TypeHandler案例
威尼斯的泪
03-19 2640
package cn.***.api.mappers.handler; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import j...
mybatis类型转换json格式
09-17
MyBatis中使用注解@Results和@ResultMap可以进行类型转换为json格式。在@Results中可以使用@Result的type属性指定转换为json，例如：@Result(property = "orderIds", column = "order_id_list", typeHandler = JsonTypeHandler.class)。其中JsonTypeHandler是自定义的TypeHandler，用于将List类型转换为json格式存储到数据库中。在查询时，也需要使用对应的TypeHandler将json格式的数据转换为List类型。因此，通过使用自定义的TypeHandler，可以实现MyBatis的类型转换为json格式的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值