Mybatis源码学习(11)-类型处理器之TypeHandlerRegistry、TypeAliasRegistry、Alias、MappedJdbcTypes、MappedTypes

一、概述

  Mybatis类型转换模块，除了定义了一些列的类型处理器（类型转换器）外，还提供了一些其他类，比如：类型处理器注册器类、别名注解类等。主要包含了以下类：

1. Alias 注解类
   别名注解
2. JdbcType 枚举类
   JdbcType枚举类，对应数据库表中字段的类型
3. MappedJdbcTypes 注解类
   用于指明类型处理器可以处理的JdbcType中的类型集合
4. MappedTypes 注解类
   用于指明该TypeHandler实现类能够处理的Java 类型的集合
5. SimpleTypeRegistry 简单类型注册器
   用于判断哪些类是简单类型，和JAVA的基本数据类型不完全一样
6. TypeAliasRegistry 类别名注册器
   用于取代复杂的类型全限定名，mybatis中用于映射器配置文件中进行参数类型与返回结果类型的设置。默认完成了大量基础类型别名的注册。
7. TypeException 异常类
8. TypeHandlerRegistry 类型处理器注册器
   主要完成类型处理器的注册功能，同时也能对类型处理器进行统筹管理，其内部定义了集合来进行类型处理器的存取，同时定义了存取方法。默认完成了大量常见类型处理器的注册。

二、类详解

1、类型别名

• 用法
  类型别名是为Java类型设置一个简单的名字。它只和 XML配置有关，存在的意义仅在于用来减少类完全限定名的冗余。例如:

  当这样配置时，Blog可以用在任何使用domain.blog.Blog的地方。

  也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如:

  每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。看下面的例子：

 @Alias("author")
 public class Author {
       ...
 }

注：上面类型别名的用法实例，来源Mybatis官方文档。

• 别名注解 Alias

根据上面实例可以知道，注解@Alias主要用来表示该类对应的简写名称，需要配合Mybatis的配置文件来使用。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Alias {
  String value();
}

TypeAliasRegistry.registerAlias()方法用来处理别名注解，主要是解析注解，并把简写名和对应的java类型注册到类型别名注册器中。

public void registerAlias(Class type) {
    String alias = type.getSimpleName();
    //判断需要注册别名的类上，是否有Alias注解，如果有就使用注解中的值，否则就用类的简名
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    } 
    //调用通用的别名注册方法实现类别名的注册
    registerAlias(alias, type);
  }

2、JdbcType 枚举类

  JdbcType这个枚举类型表示了在JDBC中的数据类型，该枚举类中定义了TYPE_CODE宇段，表示JDBC类型在java.sql.Types中相应的常量编码，并通过一个静态集合codeLookup (Map类型〉记录了常量编码与JdbcType 之间的对应关系。

  这个枚举类的代码结构主要包括了

1. 枚举值的定义，枚举值定义的时候，把对应的java.sql.Types常量编码，存储到了对应的TYPE_CODE字段中；
2. 字段TYPE_CODE和codeLookup。其中，TYPE_CODE表示当前枚举值对应的在java.sql.Types中相应的常量编码；codeLookup记录了常量编码与JdbcType 之间的对应关系。
3. 静态代码块 主要是把所有枚举值和java.sql.Types中相应的常量编码建立一一对应的关系，并存储到codeLookup对象中。
4. 构造函数，提供定义枚举值的时候，可以和java.sql.Types中相应的常量编码建立对应关系。
5. forCode()方法，提供根据java.sql.Types中相应的常量编码查询JdbcType的方法，供其他地方引用。

public enum JdbcType {

  ARRAY(Types.ARRAY),
  BIT(Types.BIT),
  TINYINT(Types.TINYINT),
  SMALLINT(Types.SMALLINT),
  INTEGER(Types.INTEGER),
  BIGINT(Types.BIGINT),
  FLOAT(Types.FLOAT),
  REAL(Types.REAL),
  DOUBLE(Types.DOUBLE),
  NUMERIC(Types.NUMERIC),
  DECIMAL(Types.DECIMAL),
  CHAR(Types.CHAR),
  VARCHAR(Types.VARCHAR),
  LONGVARCHAR(Types.LONGVARCHAR),
  DATE(Types.DATE),
  TIME(Types.TIME),
  TIMESTAMP(Types.TIMESTAMP),
  BINARY(Types.BINARY),
  VARBINARY(Types.VARBINARY),
  LONGVARBINARY(Types.LONGVARBINARY),
  NULL(Types.NULL),
  OTHER(Types.OTHER),
  BLOB(Types.BLOB),
  CLOB(Types.CLOB),
  BOOLEAN(Types.BOOLEAN),
  CURSOR(-10), // Oracle
  UNDEFINED(Integer.MIN_VALUE + 1000),
  NVARCHAR(Types.NVARCHAR), // JDK6
  NCHAR(Types.NCHAR), // JDK6
  NCLOB(Types.NCLOB), // JDK6
  STRUCT(Types.STRUCT),
  JAVA_OBJECT(Types.JAVA_OBJECT),
  DISTINCT(Types.DISTINCT),
  REF(Types.REF),
  DATALINK(Types.DATALINK),
  ROWID(Types.ROWID), // JDK6
  LONGNVARCHAR(Types.LONGNVARCHAR), // JDK6
  SQLXML(Types.SQLXML), // JDK6
  DATETIMEOFFSET(-155); // SQL Server 2008

  public final int TYPE_CODE;
  private static Map codeLookup = new HashMap();

  static {
    for (JdbcType type : JdbcType.values()) {
      codeLookup.put(type.TYPE_CODE, type);
    }
  }

  JdbcType(int code) {
    this.TYPE_CODE = code;
  }

  public static JdbcType forCode(int code)  {
    return codeLookup.get(code);
  }

}

3、@MappedTypes、@MappedJdbcTypes

  ＠MappedTypes注解用于指明该TypeHandler实现类能够处理的Java 类型的集合，＠MappedJdbcTypes 注解用于指明该TypeHandler 实现类能够处理的JDBC类型集合。

• ＠MappedTypes注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MappedTypes {
  Class[] value();
}

• ＠MappedTypes注解解析器，用于注册相关类型处理器。代码如下：

 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));
    }
  }

Mybatis中不止这一处解析该注解，仅用作分析说明

• ＠MappedJdbcTypes

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MappedJdbcTypes {
  JdbcType[] value();
  boolean includeNullJdbcType() default false;
}

• ＠MappedJdbcTypes注解解析器，用于注册相关类型处理器。代码如下：

/**
   * 将类型处理器注册到对应的Java类型
   * 解析类型处理器是否包含MappedJdbcTypes注解，如果有，把注解对应的所有jdbcType注册到对应的Map中，
   * 否则，默认jdbcType=null，然后注册到对应的Map中。
   * @param javaType
   * @param typeHandler
   */
  private  void register(Type javaType, TypeHandler typeHandler) {
	//获取类型处理器上的注解MappedJdbcTypes的值
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {//注解不为空，说明类型处理器上有该注解
      //MappedJdbcTypes注解的value是数组，循环把该注解中包含的jdbcType值注册到对应的Map对象中
      for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
        register(javaType, handledJdbcType, typeHandler);
      }
      if (mappedJdbcTypes.includeNullJdbcType()) {//如果有注解，且注解包含jdbcType=null的情况,将该类型注册到对应的Map对象中
        register(javaType, null, typeHandler);
      }
    } else {//如果注解为空，说明没有注解，即默认jdbcType=null,并注册到对应的Map对象中
      register(javaType, null, typeHandler);
    }
  }

4、注册器 SimpleTypeRegistry

  简单类型注册器，主要用于判断哪些类是简单类型，和JAVA的基本数据类型不完全一样。这里简单类型主要包括了String、Byte、Short、Character、Integer、Long、Float、Double、Boolean、Date、Class、BigInteger、BigDecimal。提供了一个isSimpleType()方法，用来判断类是否属于简单类型。

public class SimpleTypeRegistry {

  private static final Set> SIMPLE_TYPE_SET = new HashSet>();

  static {
    SIMPLE_TYPE_SET.add(String.class);
    SIMPLE_TYPE_SET.add(Byte.class);
    SIMPLE_TYPE_SET.add(Short.class);
    SIMPLE_TYPE_SET.add(Character.class);
    SIMPLE_TYPE_SET.add(Integer.class);
    SIMPLE_TYPE_SET.add(Long.class);
    SIMPLE_TYPE_SET.add(Float.class);
    SIMPLE_TYPE_SET.add(Double.class);
    SIMPLE_TYPE_SET.add(Boolean.class);
    SIMPLE_TYPE_SET.add(Date.class);
    SIMPLE_TYPE_SET.add(Class.class);
    SIMPLE_TYPE_SET.add(BigInteger.class);
    SIMPLE_TYPE_SET.add(BigDecimal.class);
  }

  private SimpleTypeRegistry() {
    // Prevent Instantiation
  }

  public static boolean isSimpleType(Class clazz) {
    return SIMPLE_TYPE_SET.contains(clazz);
  }

}

5、注册器 TypeAliasRegistry

  类别名注册器。用于取代复杂的类型全限定名，mybatis中用于映射器配置文件中进行参数类型与返回结果类型的设置。默认完成了大量基础类型别名的注册。

• 字段
    类别名注册器TypeAliasRegistry中，只有一个字段TYPE_ALIASES，该字段用来存储的别名和实际类型映射关系的地方，通过HashMap键值对实现。

private final Map> TYPE_ALIASES = new HashMap>();

• 构造函数
    构造函数完成了大量基础类型别名的注册。需要注意的是，除了这里进行了别名的注册，在创建Configuration实例的时候在其无参构造器中也注册了一些类别名。

public TypeAliasRegistry() {
	//字符串类型
    registerAlias("string", String.class);
    //基本包装类型
    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    
   	//略
  }

Configuration无参构造函数

public Configuration() {
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
    
	//略
  }

• registerAlias(String alias, Class value)方法
    该方法，主要实现建立别名与对应类型的一一对应关系，本质上就是一个Map对象赋值的操作。其中，添加了别名为null、或者重复添加的判断逻辑。

 public void registerAlias(String alias, Class value) {
    if (alias == null) {//别名不允许为空，否则抛出异常
      throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748
    String key = alias.toLowerCase(Locale.ENGLISH);
    //如果已经存在key了，且value和之前不一致，报错
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    //把该别名和类型注册到HashMap对象中
    TYPE_ALIASES.put(key, value);
  }

• registerAliases(String packageName)、registerAliases(String packageName, Class superType)类
    该方法主要实现根据包名进行解析别名的方式。其中registerAliases(String packageName)是一个重载简化参数的方法，实际上是由registerAliases(String packageName, Class superType)方法实现功能。其中通过ResolverUtil工具类，获取指定包下符合条件的所有类，然后循环处理进行注册，其中用到了registerAlias(Class type)方法。

/**
   * 包统一注册方式,对应的是如下的设置方式
   * 
   *  	
   * 
   * @param packageName
   */
  public void registerAliases(String packageName){
    registerAliases(packageName, Object.class);
  }

/**
   * 包统一注册方式,实现检索需要注册别名的类，并调用registerAlias(Class type)实现注册
   * 表示注册指定包名下的所有类，它调用了第二个方法，其第二个参数目的是限定要注册的类的来源，只有继承自给定类型的类才能被注册，
   * 这里赋值为Object.class表示其下的所有类均在别名注册的考虑范围。
   * @param packageName
   * @param superType
   */
  public void registerAliases(String packageName, Class superType){
    ResolverUtil> resolverUtil = new ResolverUtil>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set>> typeSet = resolverUtil.getClasses();
    for(Class type : typeSet){
      // Ignore inner classes and interfaces (including package-info.java)
      // Skip also inner classes. See issue #6
      //排除匿名类、接口、内部类等
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
    	  //注册别名
    	  registerAlias(type);
      }
    }
  }

• registerAlias(Class type)方法
    根据对应的类，进行类别名的注册。其中，用到了@Alias注解。当该类上有注解时，就用注解中的值，没有的话，就用类的简写名称。

public void registerAlias(Class type) {
    String alias = type.getSimpleName();
    //判断需要注册别名的类上，是否有Alias注解，如果有就使用注解中的值，否则就用类的简名
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    } 
    //调用通用的别名注册方法实现类别名的注册
    registerAlias(alias, type);
  }

• registerAlias(String alias, String value)方法
    主要实现逐个注册，因为在配置中已经将目标与所要设置的别名名称都指定好了，因此只需要直接执行核心注册方法即可完成注册工作，这种方式适合少量的类型注册情况，但是一旦需要注册的类型较多，工作就会显得很是复杂繁琐。为了简化工作我们可以采用之前第一种方式，要采用这种方式就要在架构编码时有意的将需要进行类型别名注册的类放置到统一的包下。

/**
   * 逐个注册方式,对应的是如下的设置方式
   * 	
   *  		
   *	
   *因为在配置中已经将目标与所要设置的别名名称都指定好了，因此只需要直接执行核心注册方法即可完成注册工作，
   *这种方式适合少量的类型注册情况，但是一旦需要注册的类型较多，工作就会显得很是复杂繁琐，
   *为了简化工作我们可以采用之前第一种方式，要采用这种方式就要在架构编码时有意的将需要进行类型别名注册的类放置到统一的包下。
   * @param alias
   * @param value
   */
  public void registerAlias(String alias, String value) {
    try {
      registerAlias(alias, Resources.classForName(value));
    } catch (ClassNotFoundException e) {
      throw new TypeException("Error registering type alias "+alias+" for "+value+". Cause: " + e, e);
    }
  }

-resolveAlias(String string)方法
  前面分析的都是registerAlias()方法及其重载方法，主要实现别名的注册。该方法主要用来解析别名。通过别名获取集合中保存的别名对应的值，即类的类型。

@SuppressWarnings("unchecked")
  // throws class cast exception as well if types cannot be assigned
  public  Class resolveAlias(String string) {
    try {
      if (string == null) {//别名如果为空，就直接返回null
        return null;
      }
      // issue #748
      String key = string.toLowerCase(Locale.ENGLISH);
      Class value;
      if (TYPE_ALIASES.containsKey(key)) {//如果在别名中注册了，就直接获取别名对应的类类型
        value = (Class) TYPE_ALIASES.get(key);
      } else {
    	////找不到，再试着将String直接转成Class(这样怪不得我们也可以直接用java.lang.Integer的方式定义，也可以就int这么定义)
        value = (Class) Resources.classForName(string);
      }
      return value;
    } catch (ClassNotFoundException e) {
      throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
  }

6、注册器 TypeHandlerRegistry

  类型处理器注册器。主要完成类型处理器的注册功能，同时也能对类型处理器进行统筹管理，其内部定义了集合来进行类型处理器的存取，同时定义了存取方法。默认完成了大量常见类型处理器的注册。

• 字段

类型处理器TypeHandlerRegistry 中，主要包括了一下字段：

1. JDBC_TYPE_HANDLER_MAP
   这是一个枚举Map集合，其内部是以JdbcType枚举类中枚举值为键创建的一种集合,即它是以数据库类型为键来保存类型处理器，将类型处理器注册到对应的数据库类型上。
2. TYPE_HANDLER_MAP、
   这是一个嵌套Map集合，内层集合是以数据库类型为键保存处理器，外层集合为以Java类型来保存对应的数据库类型及其处理器，这个集合将三者联系起来，是真正进行三者对应关系匹配的集合。
3. UNKNOWN_TYPE_HANDLER
   这个是上一篇中分析到的类型处理器，在在实际使用的过程中，根据JavaType和JdbcType来确定的处理器类型。
4. ALL_TYPE_HANDLERS_MAP
   这个集合中保存着所有的类型处理器，是以类型处理器的类类型为键值保存的，它可以统筹所有的类型处理器（带有统计的效果）
5. NULL_TYPE_HANDLER_MAP
   空的 以JdbcType枚举类中枚举值为键创建的一种集合.用于判断一个Map>实例是否为空。
6. defaultEnumTypeHandler
   默认的枚举类型处理器

  private final Map> JDBC_TYPE_HANDLER_MAP = new EnumMap>(JdbcType.class);

  private final Map>> TYPE_HANDLER_MAP = new ConcurrentHashMap>>();

  private final TypeHandler