Mybatis 源码学习(9)-类型转换（TypeHandlerRegistry）

最新推荐文章于 2023-12-06 17:04:38 发布
最新推荐文章于 2023-12-06 17:04:38 发布
阅读量589 收藏
点赞数 1
分类专栏： Mybatis 源码学习 文章标签： java mybatis 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/teaandnoodle/article/details/103230095
版权

历史文章：
Mybatis 源码学习(8)-类型转换（TypeHandler）

定义 TypeHandler 后，Mybatis 还需要对这些 TypeHandler 进行管理，Mybatis 是通过 TypeHandlerRegistry 来实现 TypeHandler 的管理的。TypeHandlerRegistry 的初始化是在 Configuration 中，Configuration 包含一个 private final 字段，直接初始化了 TypeHandlerRegistry，而 TypeHandlerRegistry 的初始化阶段，会构建 JDBC 数据类型、Java 数据类型、TypeHandler 之间的关系，便于索引查询。

TypeHandlerRegistry 中的核心字段主要是几个关系 Map：

// JdbcType 与TypeHandler 之间的映射关系，JdbcType 是枚举类型，它与 JDBC 规范中的数据类型一一对应
// 该集合的作用是从 ResultSet 中读取数据时，将 JdbcType 转化为 Java 类型
// （由于 JdbcType 数量已知，因此该集合中的 TypeHandler 数据量固定）
private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = 
        new EnumMap<JdbcType, TypeHandler<?>>(JdbcType.class);

// Java 类型与 TypeHandler 之间的映射关系，但是由于 Java 类型可以转化为多种 JdbcType，
// 因此 value 也是一个 Map（因为 String 可以转化为 char、varchar、text 等数据库类型）
private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = 
        new ConcurrentHashMap<Type, Map<JdbcType, TypeHandler<?>>>();

// 全部 TypeHandler 的类型与 TypeHandler 实例之间的映射关系（可以认为是缓存）
private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = 
        new HashMap<Class<?>, TypeHandler<?>>();

// 空TypeHandler 集合的标志
private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = 
        Collections.emptyMap();

注册 TypeHandler 的方法：register

TypeHandler.register() 方法实现了 TypeHandler 的注册逻辑，其注册过程主要是解析 TypeHandler 并向以上 Map 中存储对应的解析结果。register 方法是一系列重载的方法，其中大部分方法是做数据类型转化，并调用其他重载方法，比较核心的方法有 6 个。
在这里插入图片描述
以上方法中，方法 4 是最核心的方法，该方法的参数包括：该 TypeHandler 能处理的 JavaType，JdbcType以及TypeHandler 对象，该方法的核心逻辑是向 TYPE_HANDLER_MAP 和 ALL_TYPE_HANDLERS_MAP 注册对应的 TypeHandler。

// 方法 4 的实现
private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
  // 是否明确指定能够处理的 javaType
  if (javaType != null) {
    // 获取 javaType 在 TYPE_HANDLER_MAP 中已注册的 TypeHandler
    Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
    // 如果之前尚未注册过 TypeHandler，则新建对应的 Map
    if (map == null || map == NULL_TYPE_HANDLER_MAP) {
      map = new HashMap<JdbcType, TypeHandler<?>>();
      TYPE_HANDLER_MAP.put(javaType, map);
    }
    // 将 TypeHandler 注册至 TYPE_HANDLER_MAP
    map.put(jdbcType, handler);
  }
  // 向 ALL_TYPE_HANDLERS_MAP 注册 TypeHandler 的类型和 TypeHandler 对象
  ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
}

方法 1~3 最终都会调用方法 4 进行注册，它们做了一些前置的工作，主要是解析方法上的 @MappedTypes 和 @MappedJdbcTypes 注解，@MappedTypes 表示 TypeHandler 可以用于的 Java 类，@MappedJdbcTypes 表示 TypeHandler 可以处理的 JDBC 数据类型。

// 方法 1，方法包含 typeHandlerClass 参数
public void register(Class<?> typeHandlerClass) {
  boolean mappedTypeFound = false;
  // 解析获取 @MappedTypes 注解
  MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
  if (mappedTypes != null) {
    // 根据 @MappedTypes 上指定的 Java 类型，逐个注册
    for (Class<?> javaTypeClass : mappedTypes.value()) {
      // 经过包含类型转化和实例化 TypeHandler 的 register 方法转发，最终交给方法 3 进行处理
      register(javaTypeClass, typeHandlerClass);
      mappedTypeFound = true;
    }
  }
  if (!mappedTypeFound) {
    // 未指定 @MappedTypes 注解，直接交给方法 2 处理
    register(getInstance(null, typeHandlerClass));
  }
}

// 方法 2 
public <T> void register(TypeHandler<T> typeHandler) {
  boolean mappedTypeFound = false;
  // 检查 @MappedTypes 注解，根据指定的 Java 类型进行注册，逻辑同方法 1
  MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
  if (mappedTypes != null) {
    for (Class<?> handledType : mappedTypes.value()) {
      register(handledType, typeHandler);
      mappedTypeFound = true;
    }
  }
  // 从 3.1.0 开始，可以根据 TypeHandler 的类型自动查找对应 Java 类型，但是需要 TypeHandler 继承 TypeReference
  // 它会自动解析 TypeHandler 上指定的泛型参数，并以该泛型参数作为 Java 类型
  if (!mappedTypeFound && typeHandler instanceof TypeReference) {
    try {
      TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
      // 由重载方法 3 继续处理
      register(typeReference.getRawType(), typeHandler);
      mappedTypeFound = true;
    } catch (Throwable t) {
    }
  }
  if (!mappedTypeFound) {
    register((Class<T>) null, typeHandler);
  }
}

// 方法 3，解析 @MappedJdbcTypes 注解
private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
  // 获取 @MappedJdbcTypes 注解
  MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
  if (mappedJdbcTypes != null) {
    // 根据 @MappedJdbcTypes 注解指定的JDBC 类型进行注册
    for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
      register(javaType, handledJdbcType, typeHandler); // 重载方法 4
    }
    // 该 TypeHandler 能否处理 null 类型
    if (mappedJdbcTypes.includeNullJdbcType()) {
      register(javaType, null, typeHandler); // 重载方法 4
    }
  } else {
    register(javaType, null, typeHandler); // 重载方法 4
  }
}

以上方法最终均调用了方法 4，向 TYPE_HANDLER_MAP 和 ALL_TYPE_HANDLERS_MAP 完成注册，重载方法 5 是唯一一个向 JDBC_TYPE_HANDLER_MAP 注册的方法。

// 方法 5
public void register(JdbcType jdbcType, TypeHandler<?> handler) {
  // 注册 jdbcType 对应的 TypeHandler
  JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
}

除了能够注册单个 TypeHandler 外，TypeHandlerRegistry 还提供了扫描整个 package 下的 TypeHandler 接口实现类，并完成 TypeHandler 的自动注册工作。

// 方法 6，扫描整个 package 下的 TypeHandler 实现类
public void register(String packageName) {
  // 扫描整个 package 下实现 TypeHandler 的类
  ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
  resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
  Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();
  for (Class<?> type : handlerSet) {
    // 过滤掉内部类、接口、抽象类，这些类无法被直接实例化
    if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
      register(type); // 由方法 1 完成注册
    }
  }
}

除了以上 register 方法外，TypeHandlerRegistry 的构造方法完成了基本的类型注册逻辑，由于数据类型过多，仅以 String 类型来说明问题。

public TypeHandlerRegistry() {
  // 省略其他类型的注册逻辑

  // 向 TYPE_HANDLER_MAP 和 ALL_TYPE_HANDLERS_MAP 完成注册，StringTypeHandler 能够正确处理String 的 null 到 JDBC 的 null 的转化
  register(String.class, new StringTypeHandler());
  register(String.class, JdbcType.CHAR, new StringTypeHandler());
  register(String.class, JdbcType.CLOB, new ClobTypeHandler());
  register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
  register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());
  register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
  register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
  register(String.class, JdbcType.NCLOB, new NClobTypeHandler());

  // StringTypeHandler 能够完成 JDBC 的 varchar 到 Java 的 String 之间的相互转化
  register(JdbcType.CHAR, new StringTypeHandler());
  register(JdbcType.VARCHAR, new StringTypeHandler());
  register(JdbcType.CLOB, new ClobTypeHandler());
  register(JdbcType.LONGVARCHAR, new ClobTypeHandler());
  register(JdbcType.NVARCHAR, new NStringTypeHandler());
  register(JdbcType.NCHAR, new NStringTypeHandler());
  register(JdbcType.NCLOB, new NClobTypeHandler());

  register(Character.class, new CharacterTypeHandler());
  register(char.class, new CharacterTypeHandler());
}

查找 TypeHandler 的方法

和注册方法相同，查找 TypeHandler 也存在多个重载的情况，TypeHandlerRegistry.getTypeHandler() 的核心逻辑是从以上四个集合中获取对应的元素。
在这里插入图片描述
getTypeHandler 的系列方法中，最核心的方法是方法 1：getTypeHandler(Type type, JdbcType jdbcType)，其他方法都是经过类型转化最终调用该方法。

// 方法 1
private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
  // 不解析 ParamMap 类型
  if (ParamMap.class.equals(type)) {
    return null;
  }
  // 查找Java 类型对应的 TypeHandler 集合
  Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
  TypeHandler<?> handler = null;
  if (jdbcHandlerMap != null) {
    // 根据当前 jdbcType 类型获取对应的 TypeHandler
    handler = jdbcHandlerMap.get(jdbcType);
    if (handler == null) {
      // 如果未找到，则查找能够处理 null 值的 TypeHandler
      handler = jdbcHandlerMap.get(null);
    }
    if (handler == null) {
      // 如果 jdbcHandlerMap 中只注册了一个 TypeHandler，则使用该 TypeHandler
      handler = pickSoleHandler(jdbcHandlerMap);
    }
  }
  return (TypeHandler<T>) handler;
}

getJdbcHandlerMap 方法会检查 TYPE_HANDLER_MAP 中是否存在对应的 TypeHandler 集合，如果当前类不存在对应的 TypeHandler，则继续向父类中搜索对应的 TypeHandler，如果最终仍未找到，则以 NULL_TYPE_HANDLER_MAP 初始化该 Java 类型对应的 TypeHandler。

private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
  // 查找 Java 类型对应的 TypeHandler 集合
  Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
  if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) { // 检测是否为空集合标志
    return null;
  }
  // 初始化 Java 类型对应的 TypeHandler 集合
  if (jdbcHandlerMap == null && type instanceof Class) {
    Class<?> clazz = (Class<?>) type;
    if (clazz.isEnum()) { // 如果是枚举类型
      // 在枚举类接口上向父类搜索
      jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);
      if (jdbcHandlerMap == null) {
        // 如果没有指定过任何 TypeHandler，则使用默认的 TypeHandler
        register(clazz, getInstance(clazz, defaultEnumTypeHandler));
        return TYPE_HANDLER_MAP.get(clazz);
      }
    } else {
      // 在父类上搜索是否已存在 TypeHandler 集合
      jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
    }
  }
  TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
  return jdbcHandlerMap;
}

// 查找 enum 类型实现接口的情况
private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForEnumInterfaces(Class<?> clazz, Class<?> enumClazz) {
  // 遍历所有实现的接口
  for (Class<?> iface : clazz.getInterfaces()) {
    // 当前接口是否已经有 TypeHandler，如果没有，则递归向父接口查询
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(iface);
    if (jdbcHandlerMap == null) {
      jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);
    }
    if (jdbcHandlerMap != null) {
      // 找到一个父接口上注册过的 TypeHandler
      HashMap<JdbcType, TypeHandler<?>> newMap = new HashMap<JdbcType, TypeHandler<?>>();
      for (Entry<JdbcType, TypeHandler<?>> entry : jdbcHandlerMap.entrySet()) {
        // 尝试使用当前的 enum 作为参数，尝试覆盖接口对应的 TypeHandler
        newMap.put(entry.getKey(), getInstance(enumClazz, entry.getValue().getClass()));
      }
      return newMap;
    }
  }
  return null;
}

// 查找普通类父类的 TypeHandler
private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> clazz) {
  Class<?> superclass =  clazz.getSuperclass();
  if (superclass == null || Object.class.equals(superclass)) {
    return null; // Object 或 null，则查找结束
  }
  Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);
  if (jdbcHandlerMap != null) {
    return jdbcHandlerMap;
  } else {
    // 继续查找父类对应的 TypeHandler
    return getJdbcHandlerMapForSuperclass(superclass);
  }
}

TypeHandlerRegistry.getMappingTypeHandler(Class<? extends TypeHandler<?>> handlerType) 方法可以根据 handlerType 的类型，直接从 ALL_TYPE_HANDLERS_MAP 中获取对应的 TypeHandler。

TypeHandlerRegistry.getTypeHandler(JdbcType jdbcType) 方法可以根据指定的jdbcType 从 JDBC_TYPE_HANDLER_MAP 中获取对应的 TypeHandler。

Mybatis 除了支持默认的 TypeHandler 外，还支持从配置文件中配置 <typeHandlers>节点，自定义添加 TypeHandler 实现类。Mybatis 初识化时，会解析对应的配置节点，并将对应的 TypeHandler 注册至 TypeHandlerRegistry 中。

总结

TypeHandlerRegistry 可以管理所有的 TypeHandler，支持注册和获取对应的 Java 类和 JDBC 类型对应的 TypeHandler。TypeHandlerRegistry 作为 Configuration 的一个字段，在 Mybatis 的执行过程中的任何阶段都可以被方便的获取和使用。另外，TypeHandler 支持扩展，允许自定义 TypeHandler，Mybatis 可以根据泛型参数，自动解析其能够处理的 Java 类。


参考文档：《Mybatis 技术内幕》

本文的基本脉络参考自《Mybatis 技术内幕》，编写文章的原因是希望能够系统地学习 Mybatis 的源码，但是如果仅阅读源码或者仅从官方文档很难去系统地学习，因此希望参考现成的文档，按照文章的脉络逐步学习。

欢迎关注我的公众号：我的搬砖日记，我会定时分享自己的学习历程。
在这里插入图片描述

凉茶方便面
关注
专栏目录
TypeHandlerRegistry 注册handler
javalj的博客
09-17 1611
age org.apache.ibatis.type; import java.io.InputStream; import java.io.Reader; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.lang.reflect.Type; import java.math....
mybatis源码学习------类型处理器模块
我是兴锅的博客
09-29 423
简介 ① MyBatis 为简化配置文件提供了别名机制，该机制是类型转换模块的主要功能之一。 ② 类型转换模块的另一个功能是实现 JDBC 类型与 Java 类型之间的转换，该功能在为 SQL 语句绑定实参以及映射查询结果集时都会涉及： 在为 SQL 语句绑定实参时，会将数据由 Java 类型转换成 JDBC 类型。 而在映射结果集时，会将数据由 JDBC 类型转换成 Java 类型。 类型处理器的作用如下图所示 TypeHandler接口及其实现类 TypeHandler接口中定义了两种类型的方
Mybatis源码（六）— TypeHandlerRegistry
weixin_43936962的博客
05-10 610
type包下类的解析
mybatis底层组件介绍-TypeHandler和TypeHandlerRegistry
lxlneversettle的博客
01-31 1012
TypeHandler 因为jdbc中数据的类型和java的数据类型并不是直接对应的，因此需要在jdbc数据类型和java数据类型之间进行转换，转换主要发生在两个场景： 当给sql语句注入参数时，需要将java数据类型转换成jdbc数据类型 当从数据库中查询出记录后，需要将对应的记录转换成DO时，需要将jdbc数据类型转换成jdbc数据类型 而TypeHandler就是用来进行jdbc数据类型和java数据类型之间的转换的 接口方法 首先看下TypeHandler这个接口都有哪些方法 public in
mybatis-configuration容器(2)--类型处理注册表--TypeHandlerRegistry
weixin_44053668的博客
07-18 484
        这个handler的主要功能就是完成mysql的列值与java字段相互转换的处理器。那么这里就会出现两个种不同的的类型。 mysql的列类型叫做jdbcType(由jdbc提供); java的字段类型叫做javaType(由jdk提供); 首先我们先看一段熟悉的代码 public static void main(String[] args) { Connection conn = DriverMan
Mybatis源码学习(11)-类型处理器之TypeHandlerRegistry、TypeAliasRegistry、Alias、MappedJdbcTypes、MappedTypes
向心行者
09-17 7102
一、概述   Mybatis类型转换模块，除了定义了一些列的类型处理器（类型转换器）外，还提供了一些其他类，比如：类型处理器注册器类、别名注解类等。主要包含了以下类： Alias 注解类 别名注解 JdbcType 枚举类 JdbcType枚举类，对应数据库表中字段的类型 MappedJdbcTypes 注解类 用于指明类型处理器可以处理的JdbcType中的类型集合 MappedTypes 注...
mybatis源码学习------ResultSetHandler之简单映射
我是兴锅的博客
11-10 609
DefaultResultSetHandler的handleRowValues方法中有两个分支，一个用于处理嵌套映射，一个用于处理简单映射，本文讲分析其处理简单映射的分支。 handleRowValues方法的定义如下： public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping p
mybatis-3-mybatis-3.4.5 源码
02-23
通过对MyBatis源码的学习，我们可以了解到MyBatis如何解析配置，如何构建SQL，如何处理参数和结果，以及如何利用缓存提高性能。这对于理解和优化MyBatis的应用，甚至开发自己的持久层框架都有极大的帮助。在阅读源码...
Mybatis源码学习第八课---核心层源码分析--接口层Executor
qq_36697880的博客
03-01 210
Executor 是MyBatis的核心接口之一，其中定义了数据库操作的基本方法。在实际应用中经常设计的SqlSession接口的功能，都是基于Executor接口实现的。 SQL 语句的执行涉及多个组件，包括 MyBatis 的四大核心，它们是:Executor、StatementHandler、ParameterHandler、ResultSetHandler。SQL 的执行过...
Mybatis源码学习第五课---核心层源码分析--配置加载阶段
qq_36697880的博客
12-25 232
一、 mybatis初始化 类似于 Spring、 MyBatis 等灵活性和可扩展性都很高的开源框架都提供了很多配置项，开发人员需要在使用时提供相应的配置信息，实现相应的需求。 MyBatis 中的配置文件主要有两 个，分别是 mybatis-config.xml 配置文件和映射配置文件。 现在主流的配置方式除了使用 XML 配置文件，还会配合注解进行配...
Mybatis深入剖析 - typeHandlerRegistry parameterHandler resultSetHandler
blue2048
01-09 662
Statement在具体orm的过程总，主要靠这三个类进行参数装配，结果装配和相应的类型转换 parameterHandler resultSetHandler typeHandlerRegistry protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object...
mybatis 源码分析六、TypeHandlerRegistry和TypeHandler详解
最新发布
m0_56362438的博客
12-06 349
TypeHandlerRegistry和TypeHandler在mybatis源码type包中，TypeHandler主要的作用是用做JdbcType 和 javaType的类型转换，就是我们常说的数据库类型和java中实体类型的转换。可以看做是正对TypeHandler的缓存，一次性将所有的TypeHandler进行了注册在我们需要使用的时候在重TypeHandlerRegistry注册器中获取。这样我们将我们自定义的TypeHandler注入到了我们的项目中。我们可以看一下执行的结果。
【Mybatis源码分析】类型处理器（TypeHandler）及其注册
qq_63691275的博客
04-15 1354
写类型处理器，可以选择继承BaseTypeHandler类，也可以选择去实现TypeHandler接口。如果不想在配置文件中去配置对应的Java类型的话，那就使用@MappedTypes注解进行配置（当然可以配置多个，因为一个处理器可以对应多个Java数据类型嘛，可以达到一致效果的也可以配置，从而达到复用）。
Mybatis TypeHandler 介绍及使用
Crystalqy的博客
10-19 2965
我们可以直接继承BaseTypeHandler来实现我们自己的类型转换器throw new IllegalArgumentException("输入参数不能为空");@Overridetry {throw new RuntimeException("Json对象转换成String失败", e);@Override@Override@Overridetry {throw new RuntimeException("json转换成Java对象失败", e);
Mybatis的类型转换注册类TypeHandlerRegistry
l688899886的博客
08-07 571
这篇文章主要讲解了类型转换注册类的TypeHandlerRegistry的注册方法和根据Java类型获取对应的TypeHandler实例的功能,注册类是重要的一个类，Mybatis的类型转换都需要在这个类进行注册才能实现类型转换。...
【MyBatis学习笔记】5：认识使用typeHandlers配置类型处理器
LauZyHou的笔记
07-16 1604
简述 注册了的类型处理器会用于处理下面两种情形： 为PreparedStatement设置一个参数，将参数从Java类型转为JDBC类型。 从ResultSet中取出一个值，将结果从JDBC类型转为Java类型。 类型处理器可分为以下两类： MyBatis系统定义的类型处理器 用户自定义的类型处理器 认识系统定义的类型处理器 在org.apache.ibatis.type.Ty...
Mybatis使用TypeHandler实现Java类型与数据库类型的自定义转换
zy的博客
04-11 741
TypeHandler 当 SpringBoot 项目中使用到Mybatis时，通常情况下程序中使用的各种基本数据类型在数据库中都有定义，如 String - VARCHAR; 但当使用一些数据库中没有定义的数据类型时，如 Serializable ，此时 Mybatis 无法在数据库的数据类型和程序中的数据类型之间进行转换，就需要使用到自定义 TypeHandler； 通过实现 BaseTypeHandler<需要转换的Java类型> 来自定义类型的转换 举例将 Java 中的 Seriali
13、类型转换（TypeHandler）介绍
等风的帆
06-26 3549
Mybatis中的TypeHandler是什么无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。Mybatis默认为我们实现了许多TypeHandler, 当我们没有配置指定TypeHandler时，Mybatis会根据参数或者返回结果的不同，默认为我们选择合适的Typ
mybatis精通之路之TypeHandler初探
热门推荐
白哥哥的博客
05-20 1万+
前言：直入正题，在我们利用mybatis作为持久层框架存储数据时，从mybatis接收参数到mysql存储数据，都会用到typeHandler类型处理器。这也就是从JavaType->JdbcType的转化过程。由于mybatis初始时已经内置大部分基础类型转化的TypeHandler，已经足够我们平常的简单应用开发了，所以大多数情况下并不需要我们自己去定义类型转换器。但是，当遇到一些特殊情况时，为
MyBatis-Spring 1.0.0-RC3 全面参考与入门教程
《MyBatis-Spring 1.0.0-RC3参考指南》是一份详细的文档，由MyBatis社区（MyBatis.org）发布，版权属于2010年。该指南旨在帮助用户理解和应用MyBatis 1.0.0-RC3版本与Spring框架的集成，以解决在Spring 3.0中缺乏对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值