這篇博客是對(duì)MyBatis解析配置文件的第三部分，不出意外應(yīng)該是最后一篇，今天我們來(lái)分析類(lèi)型處理器和Mapper映射

在看類(lèi)型處理器之前，我們需要了解一個(gè)小知識(shí)，那就是JdbcType，JdbcType是MyBatis里面的一個(gè)枚舉類(lèi)型，看源代碼其實(shí)就是將java.sql.Types封裝了一遍，那這個(gè)類(lèi)是用來(lái)干嘛的呢？

MyBatis底層是通過(guò)JDBC來(lái)實(shí)現(xiàn)的，當(dāng)通過(guò)JDBC插入一段數(shù)據(jù)的時(shí)候，如果這個(gè)數(shù)據(jù)為null，那么有兩種寫(xiě)法：

//第一種方法
PreparedStatement##setString(index,null);
//第二種方法
PreparedStatement##setNull(index, Types.VARCHAR);

按道理來(lái)說(shuō)，第一種方法其實(shí)比較方便，第二種方法需要指定Types，MyBatis需要指定JdbcType的緣由就來(lái)源于此，那為什么不用第一種方法呢？

查看PreparedStatement的方法，當(dāng)涉及到基本數(shù)據(jù)類(lèi)型的時(shí)候，它的申明如下

void setLong(int parameterIndex, long x)

此時(shí)如果你傳入一個(gè)Null，那么Long會(huì)自動(dòng)拆箱，然后拋出NullPointerException，則便是問(wèn)題所在。

因此MyBatis說(shuō)明，當(dāng)在增加，插入，更新數(shù)據(jù)的時(shí)候，如果這個(gè)數(shù)據(jù)可能為Null，那么應(yīng)該指定JdbcType

繼續(xù)看源碼

XMLConfiguration###parseConfiguration()

//調(diào)用各個(gè)方法進(jìn)行解析成Configuration對(duì)象 
private void parseConfiguration(XNode root) {
    try {
      //讀取用戶(hù)自定義屬性
      propertiesElement(root.evalNode("properties"));
      //讀取用戶(hù)的設(shè)置
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      //加載用戶(hù)自定義的VFS實(shí)現(xiàn)  
      loadCustomVfs(settings);
      //加載日志設(shè)置
      loadCustomLogImpl(settings);
      //加載用戶(hù)定義的別名  
      typeAliasesElement(root.evalNode("typeAliases"));
      //加載用戶(hù)定義的插件
      pluginElement(root.evalNode("plugins"));
      //加載用戶(hù)定義的對(duì)象工廠
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      //加載用戶(hù)定義的反射對(duì)象工廠
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      //加載用戶(hù)定義的其他設(shè)置
      settingsElement(settings);
      //加載用戶(hù)定義的環(huán)境變量
      environmentsElement(root.evalNode("environments"));
      //讀取databaseIdProvider
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      //處理類(lèi)型處理器  
      typeHandlerElement(root.evalNode("typeHandlers"));、
      //處理mapper
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

XMLConfigBuilder###typeHandlerElement()

//<typeHandlers>
//    <typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler" javaType="com.dengchengchao.demo.type.Enabled"/>
//    <typeHandler handler="com.dengchengchao.demo.Handler"/>
//</typeHandlers>  
private void typeHandlerElement(XNode parent) {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {

         //首先，處理需要自動(dòng)查找的類(lèi)型處理器
         //這類(lèi)處理器的其他信息需要通過(guò)注解申明
        if ("package".equals(child.getName())) {
          String typeHandlerPackage = child.getStringAttribute("name");
          typeHandlerRegistry.register(typeHandlerPackage);
        } else {
          //獲取配置的其他信息  
          String javaTypeName = child.getStringAttribute("javaType");
          String jdbcTypeName = child.getStringAttribute("jdbcType");
          String handlerTypeName = child.getStringAttribute("handler");
          //調(diào)用resolveClass加載Class
          Class<?> javaTypeClass = resolveClass(javaTypeName);
          //調(diào)用resolveJdbcType加載JdbcType  
          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
          //加載類(lèi)型處理  
          Class<?> typeHandlerClass = resolveClass(handlerTypeName);

          if (javaTypeClass != null) {  
            if (jdbcType == null) {  
              //如果只指定了javaType 
              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
            } else {
              // 當(dāng)XML中指定了javaTypeClass,并且指定了jdbcType的時(shí)候，直接使用這兩個(gè)值注冊(cè)
              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
            }
          } else {
            //如果只指定了typeHandler  
            typeHandlerRegistry.register(typeHandlerClass);
          }
        }
      }
    }
  }

首先，源代碼中有兩點(diǎn)疑問(wèn)：

第一：我們可以發(fā)現(xiàn)typeHandler是可以通過(guò)注解配置其他信息，并且通過(guò)指定package讓MyBatis自動(dòng)掃描，那么MyBatis是如果獲取到類(lèi)上的注解信息的

第二：我們從后面的各種if-else中發(fā)現(xiàn)，MyBatis對(duì)TypeHandler的處理是非常寬松的，哪怕僅僅指定一個(gè)typeHandlerClass也行，那MyBatis是如何處理其他的默認(rèn)值的呢？

帶著這兩個(gè)疑問(wèn)，我們來(lái)看后面的代碼：

TypeHandlerRegister###register(packageName)

  public void register(String packageName) {
    //和前面解析別名一樣，通過(guò)`VFS`讀取包中所有的類(lèi)
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    //使用IsA進(jìn)行過(guò)濾，只需要實(shí)現(xiàn)了`TypeHandler`接口的類(lèi)
    resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
    Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();
    //遍歷，然后注冊(cè)。同理，和解析別名一樣，不需要匿名類(lèi)，接口，以及抽象類(lèi)  
    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);
      }
    }
  }

可以看到，這里獲取到類(lèi)型之后，直接調(diào)用了register(type)，這里調(diào)用的方法估計(jì)和上面只指定typeHandler調(diào)用的方法一樣，下面詳細(xì)看看：

TypeHandlerRegister###register(typeHandlerClass)

public void register(Class<?> typeHandlerClass) {
    boolean mappedTypeFound = false;
    //獲取MappedType注解
    MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    //如果找到了，則獲取它所指定的`javaTypeClass`，然后進(jìn)行注冊(cè)
    if (mappedTypes != null) {
      for (Class<?> javaTypeClass : mappedTypes.value()) {
        register(javaTypeClass, typeHandlerClass);
        mappedTypeFound = true;
      }
    }
    //如果沒(méi)有找到注解
    if (!mappedTypeFound) {
      //直接加載`typeHandlerClass`
      register(getInstance(null, typeHandlerClass));
    }
  }

TypeHandlerRegister###getInstance()

public <T> TypeHandler<T> getInstance(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
    //如果javaType不是null
    if (javaTypeClass != null) {
        try {
            //將javaType作為構(gòu)造參數(shù)初始化`typeHandler`
            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);
        }
    }
    //如果javaType是null，那么直接調(diào)用空構(gòu)造方法
    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);
    }
}

這里簡(jiǎn)單看下，就是通過(guò)反射創(chuàng)建一個(gè)新的對(duì)象而已

更加疑惑了，新建對(duì)象干什么？？？

接著往下看

TypeHandlerRegister###register(TypeHandler<t style="box-sizing: border-box;">)</t>

  @SuppressWarnings("unchecked")
  public <T> void register(TypeHandler<T> typeHandler) {
    boolean mappedTypeFound = false;
    //繼續(xù)通過(guò)注解查找  
    MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class<?> handledType : mappedTypes.value()) {
        register(handledType, typeHandler);
        mappedTypeFound = true;
      }
    }
    //如果沒(méi)有找到，則判斷其能否強(qiáng)制轉(zhuǎn)換為`TypeReference`
    // @since 3.1.0 - try to auto-discover the mapped type
    if (!mappedTypeFound && typeHandler instanceof TypeReference) {
      try {
        TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
        //如果能，則轉(zhuǎn)換為T(mén)ypeReference并調(diào)用getRawType獲取其javaType  
        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
      }
    }
    //如果沒(méi)有找到，則JavaType為null  
    if (!mappedTypeFound) {
      register((Class<T>) null, typeHandler);
    }
  }

不指定JavaClassType的TypeHandler的源碼到這里就結(jié)束了，說(shuō)到底還是通過(guò)各種方法查找JavaType，然后調(diào)用register注冊(cè)，那這個(gè)“各種方法”究竟是什么方法？

• 第一個(gè)，通過(guò)MappedType注解獲取，這個(gè)我們?cè)创a中已經(jīng)閱讀到
• 第二個(gè)，通過(guò)反射獲取泛型類(lèi)型獲取。

第二種方式就比較新奇了，泛型不是通過(guò)擦除實(shí)現(xiàn)的么？怎么能和反射聯(lián)系起來(lái)呢？

首先我們看看如何自己實(shí)現(xiàn)TypeHandler

一般來(lái)說(shuō)，需要實(shí)現(xiàn)自定義的TypeHandler，只需要直接繼承BaseTypeHandler<T>

public class Handler extends BaseTypeHandler<String> {

    @Override
    public void setParameter(PreparedStatement preparedStatement, int i, String integer, JdbcType jdbcType) throws SQLException {
        System.out.println("**********set**********");
        log.info("***********************************");
        preparedStatement.setString(i, integer);
    }

    //.....其他方法
}

我們也可以直接實(shí)現(xiàn)TypeHandler<T>接口：

public interface TypeHandler<T> {
    void setParameter(PreparedStatement var1, int var2, T var3, JdbcType var4) throws SQLException;

    T getResult(ResultSet var1, String var2) throws SQLException;

    T getResult(ResultSet var1, int var2) throws SQLException;

    T getResult(CallableStatement var1, int var2) throws SQLException;
}

可以看到，TypeHandler<T>是一個(gè)泛型方法，而這個(gè)T即使真正的對(duì)應(yīng)的JavaType，我們都知道Java的泛型是通過(guò)擦除實(shí)現(xiàn)的，也就是運(yùn)行過(guò)程中是找不到泛型的方法的，但是如果有什么方法能夠知道這個(gè)T具體的類(lèi)型，那么我們就能夠知道JavaType了。

那這BaseTypeHandler<T>相比TypeHandler有什么默認(rèn)的方法呢？

找到BaseTypeHandler<T>的定義，我們可以發(fā)現(xiàn)BaseTypeHandler<T>繼承自TypeReference,而且里面實(shí)現(xiàn)了一些通用的方法，繼續(xù)看TypeReference的定義，里面僅僅有一個(gè)方法：

Type getSuperclassTypeParameter(Class<?> clazz) {
    Type genericSuperclass = clazz.getGenericSuperclass();
    if (genericSuperclass instanceof Class) {
        if (TypeReference.class != genericSuperclass) {
            return this.getSuperclassTypeParameter(clazz.getSuperclass());
        } else {
            throw new TypeException("'" + this.getClass() + "' extends TypeReference but misses the type parameter. " + "Remove the extension or add a type parameter to it.");
        }
    } else {
        Type rawType = ((ParameterizedType)genericSuperclass).getActualTypeArguments()[0];
        if (rawType instanceof ParameterizedType) {
            rawType = ((ParameterizedType)rawType).getRawType();
        }

        return rawType;
    }
}

從TypeHandlerRegister的register方法中我們可以發(fā)現(xiàn)，register過(guò)程中一直在努力找到TypeHandler的JavaType，最后有一步便是判斷TypeHander實(shí)例能否強(qiáng)制轉(zhuǎn)換為TypeReference,如果能轉(zhuǎn)換，則直接轉(zhuǎn)換為TypeReference,然后調(diào)用getRawType()方法即可。

也就是說(shuō)這個(gè)類(lèi)可以獲取其泛型的具體類(lèi)型，這便是如果繼承這個(gè)類(lèi)，那么就可以不指定JavaType了的奧秘。

簡(jiǎn)單解釋下就是如果一個(gè)類(lèi)繼承一個(gè)泛型類(lèi)，并且這個(gè)類(lèi)不是泛型，那么Java在編譯過(guò)程中是會(huì)保留這個(gè)類(lèi)的具體類(lèi)型的，并且可以通過(guò)反射獲取到具體的泛型類(lèi)型。

而繼承BaseTypeHandler<T>實(shí)現(xiàn)TypeHandler是需要指定具體的類(lèi)型的，因此可以通過(guò)此方法獲取到具體泛型的類(lèi)型。

那么，如果你不是繼承TypeReference，而是直接實(shí)現(xiàn)的TypeHandler接口，那么MyBatis是無(wú)法自動(dòng)獲取JavaType的，此時(shí)如果不指定JavaType，那么MyBatis便會(huì)注冊(cè)一個(gè)null到注冊(cè)器中

總結(jié)一下register()流程：

首先，獲取XML的配置信息，拿到TypeHandler和JavaType和JDBCType

如果，JavaType和JDBCType為空，則先想辦法獲取到JavaType

獲取JavaType的方式首先檢查注解，如果注解沒(méi)有，則如果TypeHandler是通過(guò)繼承TypeReference實(shí)現(xiàn)，那么可以通過(guò)反射自動(dòng)獲取JavaType，如果不是繼承TypeReference,則注冊(cè)javaType為null

接下來(lái)如果JDBCType也沒(méi)有指定，那么會(huì)先查看是否有MappedJdbcTypes注解，如果沒(méi)有注解，則將JDBCType注冊(cè)為null

TypeHandlerRegistry###register()

  private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
    //獲取注解
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
     //不為空的話就去注冊(cè)
    if (mappedJdbcTypes != null) {
      for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
        register(javaType, handledJdbcType, typeHandler);
      }
      if (mappedJdbcTypes.includeNullJdbcType()) {
        register(javaType, null, typeHandler);
      }
    } else {
      register(javaType, null, typeHandler);
    }
  }

TypeHandlerRegistry###register()

  private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
    if (javaType != null) {
      Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);
      if (map == null || map == NULL_TYPE_HANDLER_MAP) {
        map = new HashMap<>();
        typeHandlerMap.put(javaType, map);
      }
      map.put(jdbcType, handler);
    }
    allTypeHandlersMap.put(handler.getClass(), handler);
  }

關(guān)于TypeHandler的配置解析就到這里，關(guān)于TypeHandler的具體使用的代碼后續(xù)會(huì)專(zhuān)門(mén)寫(xiě)一篇文章。這里先不贅述。下面簡(jiǎn)單總結(jié)一下：

• 第一，首先MyBatis的優(yōu)先級(jí)依然是XML文件，當(dāng)XML文件中指定了JavaType時(shí)，則會(huì)先忽略掉注解的配置
• 第二，MyBatis可以通過(guò)反射自動(dòng)裝載JavaType，因此如果是繼承自TypeReference，那么可以不指定JavaType
• 第三，當(dāng)注冊(cè)TypeHandler不指定JdbcType的時(shí)候，TypeHandler能夠匹配所有不指定jdbcType的字段，比如{#id,jdbcType=LONGVARCHAR}便無(wú)法匹配。如果注冊(cè)時(shí)候指定了JdbcType，則只能匹配指定了對(duì)應(yīng)的字段
• 第四，不知道為什么,通過(guò)注解配置的時(shí)候，值是一個(gè)數(shù)組，也就是說(shuō)可以同時(shí)配置多個(gè)字，@MappedTypes({ String.class,Long.class,})，但是貌似并沒(méi)有什么用，因?yàn)?code>Type不對(duì)應(yīng)實(shí)際轉(zhuǎn)換的時(shí)候會(huì)報(bào)錯(cuò)。