13、类型转换（TypeHandler）介绍

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

Mybatis中的TypeHandler是什么

无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。Mybatis默认为我们实现了许多TypeHandler, 当我们没有配置指定TypeHandler时，Mybatis会根据参数或者返回结果的不同，默认为我们选择合适的TypeHandler处理。

如果你使用JSR-310(Date和Time API)，你可以使用mybatis-typehandlers-jsr310

配置TypeHandler

 <typeHandlers>
   <!--当配置package的时候，mybatis会去配置的package扫描TypeHandler，此种方法不能喝下面的3种共存-->
        <!--<package name="com.lf.typehandle"></package>-->
        <!-- handler属性直接配置我们要指定的TypeHandler -->
        <typeHandler handler=""/>

        <!-- javaType 配置java类型，例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->
        <typeHandler javaType="" handler=""/>

        <!-- jdbcType 配置数据库基本数据类型，例如varchar, 如果配上jdbcType, 那么指定的typeHandler就只作用于指定的类型  -->
        <typeHandler jdbcType="" handler=""/>

        <!-- 也可两者都配置 -->
        <typeHandler javaType="" jdbcType="" handler=""/>
 </typeHandlers>

mybatis实现的类型转换

类型处理器Java 类型JDBC 类型
BooleanTypeHandlerjava.lang.Boolean, boolean数据库兼容的 BOOLEAN
ByteTypeHandlerjava.lang.Byte, byte数据库兼容的 NUMERIC 或 BYTE
ShortTypeHandlerjava.lang.Short, short数据库兼容的 NUMERIC 或 SHORT INTEGER
IntegerTypeHandler java.lang.Integer, int数据库兼容的 NUMERIC 或 INTEGER
LongTypeHandlerjava.lang.Long, long数据库兼容的 NUMERIC 或 LONG INTEGER
FloatTypeHandlerjava.lang.Float, float数据库兼容的 NUMERIC 或 FLOAT
DoubleTypeHandlerjava.lang.Double, double数据库兼容的 NUMERIC 或 DOUBLE
BigDecimalTypeHandlerjava.math.BigDecimal数据库兼容的 NUMERIC 或 DECIMAL
StringTypeHandlerjava.lang.StringCHAR, VARCHAR
ClobReaderTypeHandlerjava.io.Reader-
ClobTypeHandlerjava.lang.StringCLOB, LONGVARCHAR
NStringTypeHandlerjava.lang.StringNVARCHAR, NCHAR
NClobTypeHandlerjava.lang.StringNCLOB
BlobInputStreamTypeHandlerjava.io.InputStream-
ByteArrayTypeHandlerbyte[]数据库兼容的字节流类型
BlobTypeHandlerbyte[] BLOB,LONGVARBINARY
DateTypeHandlerjava.util.DateTIMESTAMP
DateOnlyTypeHandlerjava.util.DateDATE
TimeOnlyTypeHandlerjava.util.DateTIME
SqlTimestampTypeHandlerjava.sql.TimestampTIMESTAMP
SqlDateTypeHandlerjava.sql.DateDATE
SqlTimeTypeHandlerjava.sql.TimeTIME
ObjectTypeHandlerAny OTHER或未指定类型
EnumTypeHandlerEnumeration TypeVARCHAR-任何兼容的字符串类型，存储枚举的名称（而不是索引）
EnumOrdinalTypeHandlerEnumeration Type任何兼容的 NUMERIC 或 DOUBLE 类型，存储枚举的索引（而不是名称）。

xml配置源码

private void typeHandlerElement(XNode parent) throws Exception {
       if (parent != null) {
             for (XNode child : parent.getChildren()) {
               //子节点为package时，获取其name属性的值，然后自动扫描package下的自定义typeHandler
               if ("package".equals(child.getName())) {
                 String typeHandlerPackage = child.getStringAttribute("name");
                 typeHandlerRegistry.register(typeHandlerPackage);
               } else {
                 //子节点为typeHandler时， 可以指定javaType属性， 也可以指定jdbcType, 也可两者都指定
                 //javaType 是指定java类型
                 //jdbcType 是指定jdbc类型（数据库类型： 如varchar）
                 String javaTypeName = child.getStringAttribute("javaType");
                 String jdbcTypeName = child.getStringAttribute("jdbcType");
                 //handler就是我们配置的typeHandler
                 String handlerTypeName = child.getStringAttribute("handler");
                 //resolveClass方法就是我们上篇文章所讲的TypeAliasRegistry里面处理别名的方法
                 Class<?> javaTypeClass = resolveClass(javaTypeName);
                 //JdbcType是一个枚举类型，resolveJdbcType方法是在获取枚举类型的值
                 JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
                 Class<?> typeHandlerClass = resolveClass(handlerTypeName);
                 //注册typeHandler, typeHandler通过TypeHandlerRegistry这个类管理
                 if (javaTypeClass != null) {
                   if (jdbcType == null) {
                     typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
                   } else {
                     typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
                   }
                 } else {
                   typeHandlerRegistry.register(typeHandlerClass);
                 }
               }
             }
           }
    }

TypeHandler的管理注册类


package org.apache.ibatis.type;

import org.apache.ibatis.io.ResolverUtil;
import org.apache.ibatis.io.Resources;

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.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Clinton Begin
 * @author Kazuki Shimizu
 */
public final class TypeHandlerRegistry {
    private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = new HashMap<JdbcType, TypeHandler<?>>();

    //保存Mybatis内部提供的枚举JdbcType类型和对应的TypeHandler
    private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<JdbcType, TypeHandler<?>>(JdbcType.class);

    //javaType的Class类型(Type是Class的接口)，value是一个Map集合（比如String，可能对应数据库的clob、char、varchar等，所以是一对多关系）
    private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<Type, Map<JdbcType, TypeHandler<?>>>();

    //处理Object类型（运行时，会尝试进行向下类型转换找到合适的TypeHandler，如果依然失败，最后选择ObjectTypeHandler）
    private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);

    //所有的TypeHandler. Key：TypeHandler的Class类型，value：TypeHandler实例（都是singleton）
    private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<Class<?>, TypeHandler<?>>();


    // mybatis也默认给我们注册了不少的typeHandler
    public TypeHandlerRegistry() {
        register(Boolean.class, new BooleanTypeHandler());
        register(boolean.class, new BooleanTypeHandler());
        register(JdbcType.BOOLEAN, new BooleanTypeHandler());
        register(JdbcType.BIT, new BooleanTypeHandler());

        register(Byte.class, new ByteTypeHandler());
        register(byte.class, new ByteTypeHandler());
        register(JdbcType.TINYINT, new ByteTypeHandler());

        register(Short.class, new ShortTypeHandler());
        register(short.class, new ShortTypeHandler());
        register(JdbcType.SMALLINT, new ShortTypeHandler());

        register(Integer.class, new IntegerTypeHandler());
        register(int.class, new IntegerTypeHandler());
        register(JdbcType.INTEGER, new IntegerTypeHandler());

        register(Long.class, new LongTypeHandler());
        register(long.class, new LongTypeHandler());

        register(Float.class, new FloatTypeHandler());
        register(float.class, new FloatTypeHandler());
        register(JdbcType.FLOAT, new FloatTypeHandler());

        register(Double.class, new DoubleTypeHandler());
        register(double.class, new DoubleTypeHandler());
        register(JdbcType.DOUBLE, new DoubleTypeHandler());

        register(Reader.class, new ClobReaderTypeHandler());
        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());
        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(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
        register(JdbcType.ARRAY, new ArrayTypeHandler());

        register(BigInteger.class, new BigIntegerTypeHandler());
        register(JdbcType.BIGINT, new LongTypeHandler());

        register(BigDecimal.class, new BigDecimalTypeHandler());
        register(JdbcType.REAL, new BigDecimalTypeHandler());
        register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
        register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

        register(InputStream.class, new BlobInputStreamTypeHandler());
        register(Byte[].class, new ByteObjectArrayTypeHandler());
        register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
        register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
        register(byte[].class, new ByteArrayTypeHandler());
        register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
        register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
        register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
        register(JdbcType.BLOB, new BlobTypeHandler());

        register(Object.class, UNKNOWN_TYPE_HANDLER);
        register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
        register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

        register(Date.class, new DateTypeHandler());
        register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
        register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
        register(JdbcType.TIMESTAMP, new DateTypeHandler());
        register(JdbcType.DATE, new DateOnlyTypeHandler());
        register(JdbcType.TIME, new TimeOnlyTypeHandler());

        register(java.sql.Date.class, new SqlDateTypeHandler());
        register(java.sql.Time.class, new SqlTimeTypeHandler());
        register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

        // mybatis-typehandlers-jsr310
        try {
            // since 1.0.0
            register("java.time.Instant", "org.apache.ibatis.type.InstantTypeHandler");
            register("java.time.LocalDateTime", "org.apache.ibatis.type.LocalDateTimeTypeHandler");
            register("java.time.LocalDate", "org.apache.ibatis.type.LocalDateTypeHandler");
            register("java.time.LocalTime", "org.apache.ibatis.type.LocalTimeTypeHandler");
            register("java.time.OffsetDateTime", "org.apache.ibatis.type.OffsetDateTimeTypeHandler");
            register("java.time.OffsetTime", "org.apache.ibatis.type.OffsetTimeTypeHandler");
            register("java.time.ZonedDateTime", "org.apache.ibatis.type.ZonedDateTimeTypeHandler");
            // since 1.0.1
            register("java.time.Month", "org.apache.ibatis.type.MonthTypeHandler");
            register("java.time.Year", "org.apache.ibatis.type.YearTypeHandler");
            // since 1.0.2
            register("java.time.YearMonth", "org.apache.ibatis.type.YearMonthTypeHandler");
            register("java.time.chrono.JapaneseDate", "org.apache.ibatis.type.JapaneseDateTypeHandler");

        } catch (ClassNotFoundException e) {
            // no JSR-310 handlers
        }

        // issue #273
        register(Character.class, new CharacterTypeHandler());
        register(char.class, new CharacterTypeHandler());
    }

    public boolean hasTypeHandler(Class<?> javaType) {
        return hasTypeHandler(javaType, null);
    }

    public boolean hasTypeHandler(TypeReference<?> javaTypeReference) {
        return hasTypeHandler(javaTypeReference, null);
    }

    public boolean hasTypeHandler(Class<?> javaType, JdbcType jdbcType) {
        return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null;
    }

    public boolean hasTypeHandler(TypeReference<?> javaTypeReference, JdbcType jdbcType) {
        return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null;
    }

    public TypeHandler<?> getMappingTypeHandler(Class<? extends TypeHandler<?>> handlerType) {
        return ALL_TYPE_HANDLERS_MAP.get(handlerType);
    }

    public <T> TypeHandler<T> getTypeHandler(Class<T> type) {
        return getTypeHandler((Type) type, null);
    }

    public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference) {
        return getTypeHandler(javaTypeReference, null);
    }

    public TypeHandler<?> getTypeHandler(JdbcType jdbcType) {
        return JDBC_TYPE_HANDLER_MAP.get(jdbcType);
    }

    public <T> TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType) {
        return getTypeHandler((Type) type, jdbcType);
    }

    public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference, JdbcType jdbcType) {
        return getTypeHandler(javaTypeReference.getRawType(), jdbcType);
    }
    /**
     * 配置了typeHandlerhe和javaType
     */
    @SuppressWarnings("unchecked")
    private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
        Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
        TypeHandler<?> handler = null;
        if (jdbcHandlerMap != null) {
            handler = jdbcHandlerMap.get(jdbcType);
            if (handler == null) {
                handler = jdbcHandlerMap.get(null);
            }
            if (handler == null) {
                // #591
                handler = pickSoleHandler(jdbcHandlerMap);
            }
        }
        // type drives generics here
        return (TypeHandler<T>) handler;
    }


    @SuppressWarnings({"rawtypes", "unchecked"})
    private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
        Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
        if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {
            return null;
        }
        if (jdbcHandlerMap == null && type instanceof Class) {
            Class<?> clazz = (Class<?>) type;
            if (clazz.isEnum()) {
                jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz);
                if (jdbcHandlerMap == null) {
                    register(clazz, new EnumTypeHandler(clazz));
                    return TYPE_HANDLER_MAP.get(clazz);
                }
            } else {
                jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
            }
        }
        TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
        return jdbcHandlerMap;
    }

    private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForEnumInterfaces(Class<?> clazz) {
        for (Class<?> iface : clazz.getInterfaces()) {
            Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(iface);
            if (jdbcHandlerMap == null) {
                jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface);
            }
            if (jdbcHandlerMap != null) {
                return jdbcHandlerMap;
            }
        }
        return null;
    }

    private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> clazz) {
        Class<?> superclass = clazz.getSuperclass();
        if (superclass == null || Object.class.equals(superclass)) {
            return null;
        }
        Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);
        if (jdbcHandlerMap != null) {
            return jdbcHandlerMap;
        } else {
            return getJdbcHandlerMapForSuperclass(superclass);
        }
    }

    private TypeHandler<?> pickSoleHandler(Map<JdbcType, TypeHandler<?>> jdbcHandlerMap) {
        TypeHandler<?> soleHandler = null;
        for (TypeHandler<?> handler : jdbcHandlerMap.values()) {
            if (soleHandler == null) {
                soleHandler = handler;
            } else if (!handler.getClass().equals(soleHandler.getClass())) {
                // More than one type handlers registered.
                return null;
            }
        }
        return soleHandler;
    }

    public TypeHandler<Object> getUnknownTypeHandler() {
        return UNKNOWN_TYPE_HANDLER;
    }

    public void register(JdbcType jdbcType, TypeHandler<?> handler) {
        JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
    }

    //
    // REGISTER INSTANCE
    //

    // Only handler

    /**
     * 只配置了typeHandler
     */
    @SuppressWarnings("unchecked")
    public <T> void register(TypeHandler<T> typeHandler) {
        //在自定义typeHandler的时候，可以加上注解MappedTypes 去指定关联的javaType
        //因此，此处需要扫描MappedTypes注解
        boolean mappedTypeFound = false;
        MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
        if (mappedTypes != null) {
            for (Class<?> handledType : mappedTypes.value()) {
                register(handledType, typeHandler);
                mappedTypeFound = true;
            }
        }
        // @since 3.1.0 - try to auto-discover the mapped type
        if (!mappedTypeFound && typeHandler instanceof TypeReference) {
            try {
                TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
                register(typeReference.getRawType(), typeHandler);
                mappedTypeFound = true;
            } catch (Throwable t) {
                // maybe users define the TypeReference with a different type and are not assignable, so just ignore it
            }
        }
        if (!mappedTypeFound) {
            register((Class<T>) null, typeHandler);
        }
    }

    // java type + handler

    public <T> void register(Class<T> javaType, TypeHandler<? extends T> typeHandler) {
        register((Type) javaType, typeHandler);
    }

    /**
     * 只配置了typeHandle和JavaType
     * @param javaType
     * @param typeHandler
     * @param <T>
     */
    private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
        MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
        if (mappedJdbcTypes != null) {
            for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
                register(javaType, handledJdbcType, typeHandler);
            }
            if (mappedJdbcTypes.includeNullJdbcType()) {
                register(javaType, null, typeHandler);
            }
        } else {
            register(javaType, null, typeHandler);
        }
    }

    public <T> void register(TypeReference<T> javaTypeReference, TypeHandler<? extends T> handler) {
        register(javaTypeReference.getRawType(), handler);
    }

    // java type + jdbc type + handler

    public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) {
        register((Type) type, jdbcType, handler);
    }

    /**
     * 都配置了
     * @param javaType
     * @param jdbcType
     * @param handler
     */
    private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
        if (javaType != null) {
            Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
            if (map == null) {
                map = new HashMap<JdbcType, TypeHandler<?>>();
                TYPE_HANDLER_MAP.put(javaType, map);
            }
            map.put(jdbcType, handler);
        }
        ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
    }

    //
    // REGISTER CLASS
    //

    // Only handler type

    public void register(Class<?> typeHandlerClass) {
        boolean mappedTypeFound = false;
        MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
        if (mappedTypes != null) {
            for (Class<?> javaTypeClass : mappedTypes.value()) {
                register(javaTypeClass, typeHandlerClass);
                mappedTypeFound = true;
            }
        }
        if (!mappedTypeFound) {
            register(getInstance(null, typeHandlerClass));
        }
    }

    // java type + handler type

    public void register(String javaTypeClassName, String typeHandlerClassName) throws ClassNotFoundException {
        register(Resources.classForName(javaTypeClassName), Resources.classForName(typeHandlerClassName));
    }

    public void register(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
        register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
    }

    // java type + jdbc type + handler type

    public void register(Class<?> javaTypeClass, JdbcType jdbcType, Class<?> typeHandlerClass) {
        register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));
    }

    // Construct a handler (used also from Builders)

    @SuppressWarnings("unchecked")
    public <T> TypeHandler<T> getInstance(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
        if (javaTypeClass != null) {
            try {
                Constructor<?> c = typeHandlerClass.getConstructor(Class.class);
                return (TypeHandler<T>) c.newInstance(javaTypeClass);
            } catch (NoSuchMethodException ignored) {
                // ignored
            } catch (Exception e) {
                throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);
            }
        }
        try {
            Constructor<?> c = typeHandlerClass.getConstructor();
            return (TypeHandler<T>) c.newInstance();
        } catch (Exception e) {
            throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);
        }
    }


    /**
     * 根据包扫描
     * @param packageName
     */
    public void register(String packageName) {
        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) {
            //Ignore inner classes and interfaces (including package-info.java) and abstract classes
            if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
                register(type);
            }
        }
    }


    public Collection<TypeHandler<?>> getTypeHandlers() {
        return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
    }

}

管理器中，真正实现功能的方法有3个
根据包扫描的

  private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
        if (javaType != null) {
            Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
            if (map == null) {
                map = new HashMap<JdbcType, TypeHandler<?>>();
                TYPE_HANDLER_MAP.put(javaType, map);
            }
            map.put(jdbcType, handler);
        }
        ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
    }
    public void register(Class<?> typeHandlerClass) {
        boolean mappedTypeFound = false;
        MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
        if (mappedTypes != null) {
            for (Class<?> javaTypeClass : mappedTypes.value()) {
                register(javaTypeClass, typeHandlerClass);
                mappedTypeFound = true;
            }
        }
        if (!mappedTypeFound) {
            register(getInstance(null, typeHandlerClass));
        }
    }
  /**
     * 都配置了
     * @param javaType
     * @param jdbcType
     * @param handler
     */
    private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
        if (javaType != null) {
            Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
            if (map == null) {
                map = new HashMap<JdbcType, TypeHandler<?>>();
                TYPE_HANDLER_MAP.put(javaType, map);
            }
            map.put(jdbcType, handler);
        }
        ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
    }
等风de帆
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TypeHandler类型转换
weixin_43665676的博客
12-28 444
这是一个学习使用TypeHandler的demo git下载链接： https://gitee.com/ding-ding-car-of-makabaka/mybatis-typehandler.git 下面对项目文件目录下的一些文件的说明： 以下文件都是idea新建项目生成的文件，部分文件我并没有上传git仓库，可能大家下载的时候并没有 .gitignore 用git做版本控制时 用这个文件控制那些文件或文件夹 不被提交（不用git的话可删除 没影响） HELP.md md是一种文档格式 这个就是你项目
Mybatis类型转换介绍 TypeHandler
08-10
在实际项目中，我们可能会遇到需要处理复杂类型转换的情况，比如枚举类型、自定义集合类型等。这时，自定义TypeHandler可以有效地解决这些问题，提高代码的可读性和可维护性。 总结来说，Mybatis的TypeHandler是...
Mybatis源码（六）— TypeHandlerRegistry
weixin_43936962的博客
05-10 542
type包下类的解析
Mybatis 源码学习(9)-类型转换（TypeHandlerRegistry）
teaandnoodle的专栏
11-24 577
历史文章： Mybatis 源码学习(8)-类型转换（TypeHandler） 定义 TypeHandler 后，Mybatis 还需要对这些 TypeHandler 进行管理，Mybatis 是通过 TypeHandlerRegistry 来实现 TypeHandler 的管理的。TypeHandlerRegistry 的初始化是在 Configuration 中，Configuration ...
mybatis 源码分析六、TypeHandlerRegistry和TypeHandler详解
最新发布
m0_56362438的博客
12-06 288
TypeHandlerRegistry和TypeHandler在mybatis源码type包中，TypeHandler主要的作用是用做JdbcType 和 javaType的类型转换，就是我们常说的数据库类型和java中实体类型的转换。可以看做是正对TypeHandler的缓存，一次性将所有的TypeHandler进行了注册在我们需要使用的时候在重TypeHandlerRegistry注册器中获取。这样我们将我们自定义的TypeHandler注入到了我们的项目中。我们可以看一下执行的结果。
Mybatis对于类转换器TypeHandler的简单使用
java_tzx的博客
08-28 4792
目录 TypeHandler概念 MyBatis 内置的 TypeHandler 如何自定义typehandler  自定义demo(亲测有效)  TypeHandler概念 MyBatis 中的 TypeHandler 类型处理器用于 JavaType 与 JdbcType 之间的转换，用于 PreparedStatement 设置参数值和从 ResultSet...
Mybatis中的typeHandlers（类型处理器）
喵丶布
07-28 1302
mybatis中通过typeHandlers完成jdbc类型和java类型的转换。 通常情况下，mybatis提供的类型处理器满足日常需要，不需要自定义. mybatis支持类型处理器： 类型处理器 Java类型 JDBC类型 BooleanTypeHandler Boolean，boolean 任何兼容的布尔值 ByteTypeHandler Byte，byte 任何兼容的数字或字节类型...
Mybatis实现自定义类型转换器TypeHandler的方法
09-01
在MyBatis框架中，类型转换器TypeHandler扮演着至关重要的角色，它负责在Java对象与数据库之间的数据转换。在某些场景下，MyBatis内置的类型转换器可能无法满足我们的需求，这时就需要我们自定义TypeHandler。下面将...
MyBatis使用自定义TypeHandler转换类型的实现方法
08-26
本文介绍了如何使用MyBatis的自定义TypeHandler转换类型，解决了日期类型转换的问题。使用自定义TypeHandler可以提高开发效率和代码的可读性，满足不同的业务需求。在实际开发中，开发者可以根据项目的需求创建...
Mybatis自定义TypeHandler解决特殊类型转换问题详解
08-25
Mybatis自定义TypeHandler解决特殊类型转换问题详解 Mybatis是一个流行的持久层框架，它提供了许多强大的功能来帮助开发者快速构建数据库应用程序。然而，在使用Mybatis时，我们可能会遇到一些特殊类型转换问题，...
Mybatis实战之TypeHandler高级进阶
08-31
在Mybatis中，TypeHandler是一个至关重要的组件，它负责Java类型和JDBC类型之间的转换。在实际开发中，特别是处理枚举类型时，自定义TypeHandler能提供更灵活的映射规则。本文将深入探讨如何实现自定义枚举Type...
MyBatis自定义typeHandler的完整实例
08-26
MyBatis是一个基于Java的持久层框架，提供了强大的数据持久化功能，而TypeHandler是MyBatis中一个非常重要的组件，负责将Java类型转换为数据库类型，反之亦然。在实际开发中，我们常常需要根据业务需求自定义Type...
Mybatis中自定义TypeHandler处理枚举详解
08-31
在Mybatis中，枚举类型的数据处理是通过TypeHandler实现的。默认情况下，Mybatis提供了两种内置的枚举TypeHandler： 1. `EnumTypeHandler`: 这个TypeHandler将枚举对象转换为它们的字符串表示，即枚举的名称。在...
Mybatis实现自定义的typehandler三步曲
09-01
在Mybatis中，TypeHandler是一个关键组件，它负责Java类型与JDBC类型的转换。当数据库字段需要与Java对象中的特定类型进行映射时，Mybatis会使用预定义或自定义的TypeHandler。以下是对"Mybatis实现自定义的type...
Typehandler mybatis
05-14
MyBatis 是一款著名的 Java 持久层...正确理解和使用 TypeHandler 不仅能提高代码的可读性和维护性，还能有效避免因类型转换错误导致的运行时异常。在实际开发中，我们应该根据具体需求灵活运用和扩展 TypeHandler。
mybatis中接收array，如何配置handler
搬砖农民工的博客
09-08 1967
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-configuration容器(2)--类型处理注册表--TypeHandlerRegistry
weixin_44053668的博客
07-18 459
        这个handler的主要功能就是完成mysql的列值与java字段相互转换的处理器。那么这里就会出现两个种不同的的类型。 mysql的列类型叫做jdbcType(由jdbc提供); java的字段类型叫做javaType(由jdk提供); 首先我们先看一段熟悉的代码 public static void main(String[] args) { Connection conn = DriverMan
Mybatis的类型转换注册类TypeHandlerRegistry
l688899886的博客
08-07 553
这篇文章主要讲解了类型转换注册类的TypeHandlerRegistry的注册方法和根据Java类型获取对应的TypeHandler实例的功能,注册类是重要的一个类，Mybatis的类型转换都需要在这个类进行注册才能实现类型转换。...
Mybatis TypeHandler 介绍及使用
Crystalqy的博客
10-19 2457
我们可以直接继承BaseTypeHandler来实现我们自己的类型转换器throw new IllegalArgumentException("输入参数不能为空");@Overridetry {throw new RuntimeException("Json对象转换成String失败", e);@Override@Override@Overridetry {throw new RuntimeException("json转换成Java对象失败", e);
mybatis 字典转换 typehandler 查字典
09-03
MyBatis 字典转换 TypeHandler 是一种用于处理数据库中字段和 Java 实体属性之间的转换的机制。它允许开发人员在数据库中存储枚举值或其他常量，并在 MyBatis 查询时将其转换为相应的 Java 对象。 通常，在数据库设计中，我们会将某些字段的取值限制为预定义的有限选项，通常以整数或字符串形式存储在数据库中。然而，在 Java 代码中，我们更倾向于使用枚举类型或其他自定义对象来表示这些选项。 为了解决数据库字段和 Java 对象之间的转换问题，MyBatis 提供了 TypeHandler 接口。该接口定义了将字段值转换为 Java 对象和将 Java 对象转换为字段值的方法。开发人员可以根据自己的需求实现该接口并注册自己的 TypeHandler。 当 MyBatis 执行查询时，如果遇到了定义了 TypeHandler 的字段，它将使用相应的 TypeHandler 对象来处理字段的转换。类型转换可以是双向的，也就是说可以将 Java 对象转换为数据库字段，以及将数据库字段转换为 Java 对象。 字典转换的一个典型应用场景是将数据库中的整数值转换为对应的枚举类型。通过实现自定义的 TypeHandler，开发人员可以将数据库表中的整数字段映射为相应的枚举对象，从而在程序中更方便地使用枚举值。这种转换可以在查询结果映射时自动进行，也可以在参数设置时手动进行。 总之，MyBatis 字典转换 TypeHandler 是一项非常实用的功能，它允许我们在数据库和 Java 对象之间进行灵活的转换，使程序开发更加方便和高效。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值