TypeParameterResolver：

TypeParameterResolver的功能是：當存在複雜的繼承關係以及泛型定義時， TypeParameterResolver 可以幫助我們解析欄位、方法引數或方法返回值的型別。TypeParameterResolver 是在Refelctor中的addGetMethod方法中呼叫的，目的是獲取方法的返回值型別。在Refelctor中的addSetMethod方法中呼叫的，目的是獲取方法的引數型別。

private void addGetMethod(String name, Method method) {
  //檢查屬性名是否合法，檢查條件方法名不以$開頭，不等於serialVersionUID  不等於class
 
  if (isValidPropertyName(name)) {
    getMethods.put(name, new MethodInvoker(method));
    Type returnType = TypeParameterResolver.resolveReturnType(method, type);
    getTypes.put(name, typeToClass(returnType));
  }
}

private void addSetMethod(String name, Method method) {
  if (isValidPropertyName(name)) {
    setMethods
 
.put(name, new MethodInvoker(method));
    Type[] paramTypes = TypeParameterResolver.resolveParamTypes(method, type);
    setTypes.put(name, typeToClass(paramTypes[0]));
  }
}

下面來看TypeParameterResolver具體實現：首先看resolveFieldType(),resolveReturnType(),resolveParamTypes()
此文已resolveFieldType為例講解。

resolveFileType 第一步獲取欄位的宣告型別，第二步 獲取欄位定義所在的類的Class物件。第三步resolveType是獲取欄位的型別

public static Type resolveFieldType(Field field, Type srcType) {
  //獲取欄位的宣告型別
  Type fieldType = field.getGenericType();
  //獲取欄位定義所在的類的Class 物件
  Class<?> declaringClass = field.getDeclaringClass();
  return resolveType(fieldType, srcType, declaringClass);
}

public static Type resolveReturnType(Method method, Type srcType) {
  Type returnType = method.getGenericReturnType();
  Class<?> declaringClass = method.getDeclaringClass();
  return resolveType(returnType, srcType, declaringClass);
}

public static Type[] resolveParamTypes(Method method, Type srcType) {
  Type[] paramTypes = method.getGenericParameterTypes();
  Class<?> declaringClass = method.getDeclaringClass();
  Type[] result = new Type[paramTypes.length];
  for (int i = 0; i < paramTypes.length; i++) {
    result[i] = resolveType(paramTypes[i], srcType, declaringClass);
  }
  return result;
}

此處需要先介紹一下Type介面，Type是所有型別的父介面，它有四個子類和一個實現類。

Class 比較常見，它表示的是原始型別。Class 類的物件表示NM 中的一個類或介面，每個Java 類在NM 裡都表現為一個Class 物件。在程式中可以通過“類名.class ”、“物件.getC!ass（）”或是Class 物件，所有元素型別相同且維數相同的陣列都共享同一個Class 物件。
ParameterizedType 表示的是引數化型別，例如List<String＞ 、Map<Integer,String＞、Service<U ser＞這種帶有泛型的型別。
Type Variable 表示的是型別變數，它用來反映在NM 編譯該泛型前的資訊。例如List<T>中的T 就是型別變數，它在編譯時需被轉換為一個具體的型別後才能正常使用。
GenericArrayType 表示的是陣列型別且組成元素是ParameterizedType 或Type Variable .例如List<String＞［］或T ［］ 。該介面只有Type getGenericComponentType （） 一個方法，它返回陣列的組成元素。
WildcardType 表示的是萬用字元泛型，例如？ extends Number 和？ super Integer 。

現在看 resolveType(Type type, Type srcType, Class<?> declaringClass) 原始碼：主要是根據欄位型別來匹配是屬於哪個型別的，然後返回

private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {
  if (type instanceof TypeVariable) {
    return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);
  } else if (type instanceof ParameterizedType) {
    return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);
  } else if (type instanceof GenericArrayType) {
    return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);
  } else {
    return type;
  }
}

ObjectFactory  

   ObjectFactory 主要功能是：根據指定的引數列表查詢建構函式，並例項化物件。

   My Batis 中有很多模組會使用到ObjectFactory 介面，該介面提供了多個create（）方法的過載，通過這些create（）方法可以建立指定型別的物件。

public interface ObjectFactory {

  /**
   * Sets configuration properties. 設定配置資訊
   * @param properties configuration properties
   */
  void setProperties(Properties properties);

  /**
   * Creates a new object with default constructor. 通過無參構造器建立物件
   * @param type Object type
   * @return
   */
  <T> T create(Class<T> type);

  /**
   * Creates a new object with the specified constructor and params.根據引數列表，從指定型別中選擇合適的構造器建立物件
   * @param type Object type
   * @param constructorArgTypes Constructor argument types
   * @param constructorArgs Constructor argument values
   * @return
   */
  <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs);
  
  /**檢測指定型別是否為集合型別，主要處理java.util.Collection及其子類。
   * Returns true if this object can have a set of other objects.
   * It's main purpose is to support non-java.util.Collection objects like Scala collections.
   * 
   * @param type Object type
   * @return whether it is a collection or not
   * @since 3.1.0
   */
  <T> boolean isCollection(Class<T> type);

}

ObjectFactory只有一個預設實現DafaultObjectFactory,主要看instantiateClass()方法，實現的功能就是 根據指定的引數列表查詢建構函式，並例項化物件。

public class DefaultObjectFactory implements ObjectFactory, Serializable {

  private static final long serialVersionUID = -8855120656740914948L;

  @Override
  public <T> T create(Class<T> type) {
    return create(type, null, null);
  }

  @SuppressWarnings("unchecked")
  @Override
  public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    Class<?> classToCreate = resolveInterface(type);
    // we know types are assignable
    return (T) instantiateClass(classToCreate, constructorArgTypes, constructorArgs);
  }

  @Override
  public void setProperties(Properties properties) {
    // no props for default
  }

  private <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    try {
      //宣告構造方法
      Constructor<T> constructor;
      //如果引數列表為null,通過無參建構函式建立物件。
      if (constructorArgTypes == null || constructorArgs == null) {
        constructor = type.getDeclaredConstructor();
        if (!constructor.isAccessible()) {
          constructor.setAccessible(true);
        }
        return constructor.newInstance();
      }
      //根據指定的引數列表查詢建構函式，並例項化物件。
      constructor = type.getDeclaredConstructor(constructorArgTypes.toArray(new Class[constructorArgTypes.size()]));
      if (!constructor.isAccessible()) {
        constructor.setAccessible(true);
      }
      return constructor.newInstance(constructorArgs.toArray(new Object[constructorArgs.size()]));
    } catch (Exception e) {
      StringBuilder argTypes = new StringBuilder();
      if (constructorArgTypes != null && !constructorArgTypes.isEmpty()) {
        for (Class<?> argType : constructorArgTypes) {
          argTypes.append(argType.getSimpleName());
          argTypes.append(",");
        }
        argTypes.deleteCharAt(argTypes.length() - 1); // remove trailing ,
      }
      StringBuilder argValues = new StringBuilder();
      if (constructorArgs != null && !constructorArgs.isEmpty()) {
        for (Object argValue : constructorArgs) {
          argValues.append(String.valueOf(argValue));
          argValues.append(",");
        }
        argValues.deleteCharAt(argValues.length() - 1); // remove trailing ,
      }
      throw new ReflectionException("Error instantiating " + type + " with invalid types (" + argTypes + ") or values (" + argValues + "). Cause: " + e, e);
    }
  }

  protected Class<?> resolveInterface(Class<?> type) {
    Class<?> classToCreate;
    if (type == List.class || type == Collection.class || type == Iterable.class) {
      classToCreate = ArrayList.class;
    } else if (type == Map.class) {
      classToCreate = HashMap.class;
    } else if (type == SortedSet.class) { // issue #510 Collections Support
      classToCreate = TreeSet.class;
    } else if (type == Set.class) {
      classToCreate = HashSet.class;
    } else {
      classToCreate = type;
    }
    return classToCreate;
  }

  @Override
  public <T> boolean isCollection(Class<T> type) {
    return Collection.class.isAssignableFrom(type);
  }

}