Une introduction approfondie à la série Mybatis (5) ---Introduction et configuration de TypeHandler (code source mybatis)

L'article précédent "Introduction approfondie à la série Mybatis (4) --- Configuration détaillée des alias typeAliases (code source mybatis)" a introduit l'utilisation des alias dans mybatis et son code source. Cet article vous présentera TypeHandler et analysera brièvement son code source.

Qu'est-ce que TypeHandler dans Mybatis ?

　Que MyBatis définisse un paramètre dans une instruction préparée (PreparedStatement) ou récupère une valeur de l'ensemble de résultats, un processeur de type sera utilisé pour convertir la valeur obtenue en Java de manière appropriée. Mybatis implémente de nombreux TypeHandlers pour nous par défaut Lorsque nous ne configurons pas un TypeHandler spécifié, Mybatis sélectionnera le TypeHandler approprié pour nous par défaut en fonction des paramètres ou renverra les résultats.

Alors, quels TypeHandlers Mybatis a-t-il implémentés pour nous ? Comment pouvons-nous personnaliser un TypeHandler ? Ceux-ci seront ensuite présentés dans le code source de mybatis ?

Avant de regarder le code source, voyons comment le configurer comme avant, non ?

Configuration de TypeHandler :

<configuration>
    <typeHandlers>
      <!-- 
          当配置package的时候，mybatis会去配置的package扫描TypeHandler
          <package name="com.dy.demo"/>       -->
      
      <!-- handler属性直接配置我们要指定的TypeHandler -->
      <typeHandler handler=""/>
      
      <!-- javaType 配置java类型，例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->
      <typeHandler javaType="" handler=""/>
      
      <!-- jdbcType 配置数据库基本数据类型，例如varchar, 如果配上jdbcType, 那么指定的typeHandler就只作用于指定的类型  -->
      <typeHandler jdbcType="" handler=""/>
      
      <!-- 也可两者都配置 -->
      <typeHandler javaType="" jdbcType="" handler=""/>
      
  </typeHandlers>
  
  ......  
</configuration>

Ce qui précède présente brièvement TypeHandler. Jetons maintenant un coup d'œil au code source de TypeHandler dans mybatis.

=================================== = =====================Je suis la ligne de démarcation du code source====================== === ====================================

Anciennes règles, commencez par analyse de XML En parlant de :

/**
 * 解析typeHandlers节点 */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);
          }
        }
      }
    }
}

Ensuite, jetons un coup d'œil à la classe d'enregistrement de gestion de TypeHandler :

TypeHandlerRegistry :

/**
 * typeHandler注册管理类 */public final class TypeHandlerRegistry {  
 //源码一上来，二话不说，几个大大的HashMap就出现，这不又跟上次讲的typeAliases的注册类似么  
 //基本数据类型与其包装类
  private static final Map<Class<?>, Class<?>> reversePrimitiveMap = new HashMap<Class<?>, Class<?>>() {    private static final long serialVersionUID = 1L;
    {
      put(Byte.class, byte.class);
      put(Short.class, short.class);
      put(Integer.class, int.class);
      put(Long.class, long.class);
      put(Float.class, float.class);
      put(Double.class, double.class);
      put(Boolean.class, boolean.class);
      put(Character.class, char.class);
    }
  };  //这几个MAP不用说就知道存的是什么东西吧，命名的好处
  private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<JdbcType, TypeHandler<?>>(JdbcType.class);  private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>();  private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);  private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<Class<?>, TypeHandler<?>>();  //就像上篇文章讲的typeAliases一样，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(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(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());    // 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);
  }  private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
    TypeHandler<?> handler = null;    if (jdbcHandlerMap != null) {
      handler = jdbcHandlerMap.get(jdbcType);      if (handler == null) {
        handler = jdbcHandlerMap.get(null);
      }
    }    if (handler == null && type != null && type instanceof Class && Enum.class.isAssignableFrom((Class<?>) type)) {
      handler = new EnumTypeHandler((Class<?>) type);
    }
    @SuppressWarnings("unchecked")    // type drives generics here
    TypeHandler<T> returned = (TypeHandler<T>) handler;    return returned;
  }  public TypeHandler<Object> getUnknownTypeHandler() {    return UNKNOWN_TYPE_HANDLER;
  }  public void register(JdbcType jdbcType, TypeHandler<?> handler) {
    JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
  }  //
  // REGISTER INSTANCE  
  //
  /**
   * 只配置了typeHandler, 没有配置jdbcType 或者javaType   
   */
  @SuppressWarnings("unchecked")  public <T> void register(TypeHandler<T> typeHandler) {    
  boolean mappedTypeFound = false;    
  //在自定义typeHandler的时候，可以加上注解MappedTypes 去指定关联的javaType    
  //因此，此处需要扫描MappedTypes注解
    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);
    }
  }  /**
   * 配置了typeHandlerhe和javaType   */
  public <T> void register(Class<T> javaType, TypeHandler<? extends T> typeHandler) {
    register((Type) javaType, typeHandler);
  }  private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {    
  //扫描注解MappedJdbcTypes
    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);
  }  /**
   * typeHandlerhe、javaType、jdbcType都配置了   */
  public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) {
    register((Type) type, jdbcType, handler);
  }  /**
   * 注册typeHandler的核心方法
   * 就是向Map新增数据而已   */
  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);      
      if (reversePrimitiveMap.containsKey(javaType)) {
        register(reversePrimitiveMap.get(javaType), 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(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);
    }
  } 
  /**
   * 根据指定的pacakge去扫描自定义的typeHander，然后注册   */
  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);
      }
    }
  }  
  // get information
  
  /**
   * 通过configuration对象可以获取已注册的所有typeHandler   */
  public Collection<TypeHandler<?>> getTypeHandlers() {    
  return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
  }
  
}

Comme vous pouvez le voir dans le code source, mybatis a implémenté de nombreux TypeHandlers pour nous si vous ouvrez un TypeHandler et regardez son code source. , vous pouvez voir qu'il hérite d'une abstraction. Classe : BaseTypeHandler, pouvons-nous également implémenter un TypeHandler personnalisé en héritant de BaseTypeHandler ? La réponse est oui, alors montrons maintenant le TypeHandler personnalisé pour tout le monde :

=============================================== === ===Ligne de séparation TypeHandler personnalisée========================================= ==== ==================

ExampleTypeHandler :

@MappedJdbcTypes(JdbcType.VARCHAR)  
//此处如果不用注解指定jdbcType, 那么，就可以在配置文件中通过"jdbcType"属性指定， 同理， javaType 也可通过 @MappedTypes指定public class ExampleTypeHandler extends BaseTypeHandler<String> {

  @Override  public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
    ps.setString(i, parameter);
  }

  @Override  public String getNullableResult(ResultSet rs, String columnName) throws SQLException {    return rs.getString(columnName);
  }

  @Override  public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {    return rs.getString(columnIndex);
  }

  @Override  public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {    return cs.getString(columnIndex);
  }
}

Ensuite, il est temps de nous configurer le TypeHandler personnalisé :

<configuration>
  <typeHandlers>
      <!-- 由于自定义的TypeHandler在定义时已经通过注解指定了jdbcType, 所以此处不用再配置jdbcType -->
      <typeHandler handler="ExampleTypeHandler"/>
  </typeHandlers>
  
  ......  
</configuration>

En d'autres termes, lorsque nous personnalisons le TypeHandler, peut être TypeHandler spécifie jdbcType via @MappedJdbcTypes et spécifie javaType via @MappedTypes S'il n'est pas spécifié à l'aide d'annotations, nous devons le configurer dans le fichier de configuration.

D'accord, cet article se termine ici.

Ce qui précède est une introduction approfondie à la série Mybatis (5) --- Introduction et configuration de TypeHandler (code source mybatis Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www. php.cn) !