MyBatis源码解析 - 反射模块

MyBatis源码解析 - 反射模块

1. 前言

​ 该模块位于org.apache.ibatis.reflection包中，MyBatis在进行参数处理、结果映射等操作时，会涉及大量的反射操作。Java 中的反射虽然功能强大，但是代码编写起来比较复杂且容易出错，为了简化反射操作的相关代码，MyBatis提供了专门的反射模块，它对常见的反射操作做了进一步封装，提供了更加简洁方便的反射API。本节就来为读者介绍该模块中核心代码的实现。

2. Reflector

Reflector 是MyBaits中反射模块的基础，Reflector中缓存了很多反射操作需要使用的元数据。各个字段如下：

private final Class type;  //对应的class类型
private final String[] readablePropertyNames; //可读属性的名称集合，可读属性就是存在相应getter方法的属性
private final String[] writablePropertyNames; //可写属性的名称集合，可写属性就是存在相应setter方法的属性
//记录了属性相应的setter方法，key是属性名称，value 是Invoker对象，它是对setter方法对应
// Method 对象的封装
private final Map setMethods = new HashMap<>();
//属性相应的getter方法集合，key 是属性名称，value 也是Invoker对象
private final Map getMethods = new HashMap<>();
//记录了属性相应的setter方法的参数值类型，key是属性名称，value是setter方法的参数类型
private final Map> setTypes = new HashMap<>();
//记录了属性相应的getter方法的参数值类型，key是属性名称，value是getter方法的参数类型
private final Map> getTypes = new HashMap<>();
//记录了默认的构造函数
private Constructor defaultConstructor;
//记录了所有属性名称的集合
private Map caseInsensitivePropertyMap = new HashMap<>();

在Reflector的构造函数中，会解析指定的Class对象，并填充上述集合，代码如下：

public Reflector(Class clazz) {
    type = clazz; //初始化type字段
    //查找默认构造函数（无参构造函数）具体实现是以反射遍历所有构造方法
    addDefaultConstructor(clazz);
    //处理class中的getter方法
    addGetMethods(clazz);
    //处理class中的setter方法
    addSetMethods(clazz);
    //处理没有getter或setter方法的字段
    addFields(clazz);
    // 初始化为空数组
    readablePropertyNames = getMethods.keySet().toArray(new String[0]);
    // 初始化为空数组
    writablePropertyNames = setMethods.keySet().toArray(new String[0]);
    //初始化caseInsensitivePropertyMap集合 其中记录了所有大写格式的属性名称
    for (String propName : readablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
    for (String propName : writablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
  }

Reflector.addGetMethods()方法主要解析类中定义的getter方法，Reflector.addSetMethods()方法主要解析类中定义的setter方法，两个类似，下面我们就以Reflector.addGetMethods()方法为例进行介绍，Reflector.addGetMethods()解析有下面三个步骤：

1. 首先调用Reflector.getClassMethods()方法获取当前类以及父类中定义的所有方法的唯一签名以及相应的Method对象。

   private Method[] getClassMethods(Class clazz) {
     //用于记录指定类中定义的全部方法的唯一签名对应的Method对象
     Map uniqueMethods = new HashMap<>();
     Class currentClass = clazz;
     while (currentClass != null && currentClass != Object.class) {
       //记录currentClass类中定义的全部方法
       addUniqueMethods(uniqueMethods, currentClass.getDeclaredMethods());
   
       // we also need to look for interface methods -
       // because the class may be abstract
       //记录接口中定义一的方法
       Class[] interfaces = currentClass.getInterfaces();
       for (Class anInterface : interfaces) {
         addUniqueMethods(uniqueMethods, anInterface.getMethods());
       }
       //获取父类继续while循环
       currentClass = currentClass.getSuperclass();
     }
   
     Collection methods = uniqueMethods.values();
     //转换成methods数组返回
     return methods.toArray(new Method[0]);
   }
   

   ---

   在Reflector.getClassMethods()方法中会为每个方法生成唯一签名，并记录到conflictingSetters集合中，实现如下：

   ---

private void addUniqueMethods(Map uniqueMethods, Method[] methods) {
  for (Method currentMethod : methods) {
    if (!currentMethod.isBridge()) {
      //通过getSignature()方法得到的方法签名 规则：返回值类型#方法名称：参数类型列表。
      //通过getSignature()方法得到的发放签名是全局唯一的，可以作为该方法的唯一标识
      String signature = getSignature(currentMethod);
      // check to see if the method is already known
      // if it is known, then an extended class must have
      // overridden a method
      //检测是否在子类中已经添加过该方法【如果添加过就忽略】
      if (!uniqueMethods.containsKey(signature)) {
        //记录该签名和方法的对应关系
        uniqueMethods.put(signature, currentMethod);
      }
    }
  }
}

---

2. 然后按照Java规范，从Reflector.getClassMethods()方法返回的Method数组中查找该类的getter方法，记录到conflictingSetters集合中。【该集合为HashMap>>,key为属性名称，value是该属性对应的setter集合。】

3. 当子类覆盖父类的getter方法且返回值发生变化时，在步骤【1】中就会产生两个签名不同的方法，在Reflector.addUniqueMethods()方法中会被当做两个不同的方法添加到conflictingSetters集合中，这显然不是我们要的结果，所以第三步我们会调用Reflector.resolveSetterConflicts()方法对这个覆写的方法进行处理，同时会将得到的getter方法记录到getMethods集合，并将其返回值类型填充到getTypes集合。Reflector.resolveSetterConflicts()方法具体实现如下：

   ---

private void resolveGetterConflicts(Map> conflictingGetters) {
  // 遍历 conflictingGetters 集合
  for (Entry> entry : conflictingGetters.entrySet()) {
    Method winner = null;
    //获取属性名
    String propName = entry.getKey();
    //是否是不明确的
    boolean isAmbiguous = false;
    //
    for (Method candidate : entry.getValue()) {
      if (winner == null) {
        winner = candidate;
        continue;
      }
      //获取最终选择的方法方法返回值
      Class winnerType = winner.getReturnType();
      //获取候选方法候选类型
      Class candidateType = candidate.getReturnType();
      //返回值相同
      if (candidateType.equals(winnerType)) {
        //对于不是布尔类型的
        if (!boolean.class.equals(candidateType)) {
          //不明确的类型 【不明确 抛异常】
          isAmbiguous = true;
          break;
        } else if (candidate.getName().startsWith("is")) {
          //对于boolean类型
          //当前方法返回值是当前最合适的方法的返回值的子类
          winner = candidate;
        }
      } else if (candidateType.isAssignableFrom(winnerType)) {
        //当前最适合的方法的返回值是当前方法返回值的子类，什么都不做 当前最适合的方法 依然不变
        // OK getter type is descendant
      } else if (winnerType.isAssignableFrom(candidateType)) {  //当前返回值是当前最适合的方法的返回值的
        winner = candidate;
      } else {
        //不明确的类型 要抛异常
        isAmbiguous = true;
        break;
      }
    }
    addGetMethod(propName, winner, isAmbiguous);
  }
}

---

Reflector.addGetMethod()方法对getMethods集合和getTypes集合进行填充，具体实现代码如下：

---

private void addGetMethod(String name, Method method, boolean isAmbiguous) {
  //对于不明确的方法 抛异常处理
  MethodInvoker invoker = isAmbiguous
      ? new AmbiguousMethodInvoker(method, MessageFormat.format(
          "Illegal overloaded getter method with ambiguous type for property ''{0}'' in class ''{1}''. This breaks the JavaBeans specification and can cause unpredictable results.",
          name, method.getDeclaringClass().getName()))
      : new MethodInvoker(method);
  //将属性名以及对应的MethodInvoker对象添加到getMethods集合中，Invoker的内容后面解析
  getMethods.put(name, invoker);
  //获取返回值的Type,TypeParameterResolver会在后面分析
  Type returnType = TypeParameterResolver.resolveReturnType(method, type);
  //将属性名及其getter方法的返回值加到getTypes集合中保存，typeToClass()方法后面分析
  getTypes.put(name, typeToClass(returnType));
}

---

分析完Reflector.addGetMethods()的三个核心步骤后，我们看下具体实现代码，如下：

---

private void addGetMethods(Class clazz) {
  //conflictingGetters集合 key为属性名称，value为相应的getter方法集合，因为子类可能覆盖父类的getter方法，
  //所以同一属性的名称可能存在多个getter方法
  Map> conflictingGetters = new HashMap<>();
  //步骤一：获取指定类以及父类和接口中定义的方法
  Method[] methods = getClassMethods(clazz);
  //步骤二：按照javabean规范查找getter方法 添加到conflictingGetters中
  Arrays.stream(methods).filter(m -> m.getParameterTypes().length == 0 && PropertyNamer.isGetter(m.getName()))
    .forEach(m -> addMethodConflict(conflictingGetters, PropertyNamer.methodToProperty(m.getName()), m));
  //对于getter方法进行处理
  resolveGetterConflicts(conflictingGetters);

Reflector.addFields()方法会处理类中定义的所有字段，并且将处理的字段信息添加到setMethods集合、setTypes集合、getMethods集合、getTypes集合中，Reflector.addFileds()方法的实现代码如下：

//处理类中定义的所有字段
private void addFields(Class clazz) {
  //提取clazz中定义的所有字段
  Field[] fields = clazz.getDeclaredFields();
  for (Field field : fields) {
    if (!setMethods.containsKey(field.getName())) {
      // issue #379 - removed the check for final because JDK 1.5 allows
      // modification of final fields through reflection (JSR-133). (JGB)
      // pr #16 - final static can only be set by the classloader
      int modifiers = field.getModifiers();
      //过滤调static和final修饰的方法
      if (!(Modifier.isFinal(modifiers) && Modifier.isStatic(modifiers))) {
        //填充setMethods集合和setTypes集合
        addSetField(field);
      }
    }
    //getMethods集合中不包同名属性时，将其记录到getMethods集合和getTypes集合中
    if (!getMethods.containsKey(field.getName())) {
      //填充getMethods集合和getTypes集合
      addGetField(field);
    }
  }
  if (clazz.getSuperclass() != null) {
    //处理父类中定义的字段
    addFields(clazz.getSuperclass());
  }
}

Reflector中提供多个get *()方法用于读取上述集合中的元数据信息。

3. Invoker & GetFieldInvoker & SetFieldInvoker & AmbiguousMethodInvoker & MethodInvoker

add *Methods()方法和add *Field()方法在上述集合中添加元素的时候，会将getter/setter方法对应的Method对象以及字段对应的Field对象统一封装成Invoker对象。Invoker接口的定义如下：

---

public interface Invoker {
  //调用指定字段的值或者指定的方法
  Object invoke(Object target, Object[] args) throws IllegalAccessException, InvocationTargetException;

  //返回属性相应的类型
  Class getType();
}

---

invoker接口的实现如下图：

​ GetFieldInvoker/SetFieldInvoker通过field字段封装了FIeld对象，两者的invoke()方法是通过调用Field.get()/set()方法实现的。MethodInvoker通过method字段封装了对应的Method对象，其invoke()方法是通过调用Method.invoke()方法实现的。

4. ReflectorFactory

ReflectorFactory接口主要实现了对Reflector对象的创建和缓存，接口定义如下：

---

public interface ReflectorFactory {

  //检查该ReflectorFactory对象是否会缓存Reflector对象
  boolean isClassCacheEnabled();

  //设置是否缓存Reflector对象
  void setClassCacheEnabled(boolean classCacheEnabled);

  //创建指定对象的Reflector对象
  Reflector findForClass(Class type);
}

MyBatis对ReflectorFactory接口只提供了DefaultReflectorFactory这一个实现类，他与Reflector关系如图：

DefaultReflectorFactory的字段含义如下：

//该字段决定是否对Reflector对象的缓存
private boolean classCacheEnabled = true;
//使用ConcurrentHashMap集合实现对Reflector对象的缓存
private final ConcurrentMap, Reflector> reflectorMap = new ConcurrentHashMap<>();

DefaultReflectorFactory提供findForClass()方法实现为指定Class创建Reflector对象，并将Reflector对象缓存到reflectorMap集合中，具体代码如下：

public Reflector findForClass(Class type) {
  if (classCacheEnabled) { //检测是否开启缓存
   //cas放入缓存
   return reflectorMap.computeIfAbsent(type, Reflector::new);
  } else {
   //未开启缓存则直接创建
   return new Reflector(type);
  }
}

此外除了使用MyBatis提供的DefaultReflectorFactory实现，们还可以在mybatis-config.xml中配置自定义的ReflectorFactory实现类，从而实现上面功能的拓展。（后面会在介绍MyBatis初始化流程时，会提到拓展点。）

5. TypeParameterResolver

1. Type知识准备

在分析TypeParameterResolver之前我们先来看下Type接口，Type是所有类型的父接口，他有四个接口和一个实现类，类图如图所示：

Class

Class：表示原始类型类型，Class对象表示JVM中一个类或者接口，每个Java类在JVM都表现为一个Class对象。在程序中可以通过 ”xxx.class“,”对象.getClass()"或者是Class.forName("类名")来获取Class对象。数组也被映射为Class对象，所有元素类型相同切维数相同的数组都共享一个Class对象。

ParameterizedType

ParameterizedType:表示参数化类型，例如List< String >,Map,Service< User >这种带有泛型的类型。

GenericArrayType

GenericArrayType：表示的是数组类型且组成元素是ParameterizedType或者TypeVariable。例如List< String >[]或者T[]

TypeVariable

TypeVariable：表示的是类型变量，它用来反映在JVM编译该泛型前的信息。例如在LIst中的T就是类型变量，它在编译的时候需要被转化成一个具体的类型才能正常使用。

WildcardType

WildcardType：表示通配符类型，例如：? extends Number和? extends Integer。

2. 方法解析

上面介绍了Type接口的基础知识，我们回来继续分析TypeParameterResolver。在对Reflector的分析中我们看到了TypeParameterResolver的身影，他是一个工具类提供一些列静态方法来解析指定类中的字段、方法返回值或者方法参数的类型。TypeParameterResolver中各个方法之间的调用大致如下：【其中有一些递归调用没有体现出来，在后面的分析中会进行强调。】

TypeParameterResolver中通过resolveFieldTypes()方法、resolveReturnTypes()方法、resolveParamTypes()方法分别解析字段类型、方法返回值类型和方法参数列表中各个参数的类型。这三个方法类似。我们就以resolveFieldTypes()来分析。TypeParameterResolve.resolveFieldTypes()方法实现代码如下：

public static Type resolveFieldType(Field field, Type srcType) {
  //获取字段的声明类型
  Type fieldType = field.getGenericType();
  //获取字段定义所在类的Class对象
  Class declaringClass = field.getDeclaringClass();
  //调用resolveType()方法做后续处理
  return resolveType(fieldType, srcType, declaringClass);
}

上述三个解析方法都会调用resolveType()会根据第一个参数Type，即方法、返回值或者方法返回参数的类型，选择合适的方法解析。resolveType()的第二个参数表示查找该字段、返回值或者方法参数的起始位置。第三个参数则表示该字段、方法所在的类。

TypeParameterResolve.resolveType()方法代码如下：

private static Type resolveType(Type type, Type srcType, Class declaringClass) {
  if (type instanceof TypeVariable) {
    //解析 TypeVariable 类型
    return resolveTypeVar((TypeVariable) type, srcType, declaringClass);
  } else if (type instanceof ParameterizedType) {
    //解析  ParameterizedType 类型
    return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);
  } else if (type instanceof GenericArrayType) {
    //解析  GenericArrayType 类型
    return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);
  } else {
    return type;
  }
}

TypeParameterResolve.resolveParameterizedType()方法代码如下：

private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class declaringClass) {
  // 得到参数化类型中的原始类型对应的Class对象
  Class rawType = (Class) parameterizedType.getRawType();
  //返回参数化类型的类型变量
  Type[] typeArgs = parameterizedType.getActualTypeArguments();
  //用于保存解析后的结果
  Type[] args = new Type[typeArgs.length];
  for (int i = 0; i < typeArgs.length; i++) {
    if (typeArgs[i] instanceof TypeVariable) {
      //解析类型变量
      args[i] = resolveTypeVar((TypeVariable) typeArgs[i], srcType, declaringClass);
    } else if (typeArgs[i] instanceof ParameterizedType) {
      //如果嵌套了ParameterizedType则调用resolveParameterizedType()方法进行处理
      args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);
    } else if (typeArgs[i] instanceof WildcardType) {
      //如果嵌套了WildcardType则调用resolveWildcardType()方法进行处理
      args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);
    } else {
      args[i] = typeArgs[i];
    }
  }
  //将解析结果封装成TypeParameterResolver中定义的ParameterizedType实现并返回
  return new ParameterizedTypeImpl(rawType, null, args);
}

---

TypeParameterResolve.resolveTypeVar()方法负责解析TypeVariable。具体实现如下：

---

private static Type resolveTypeVar(TypeVariable typeVar, Type srcType, Class declaringClass) {
  Type result;
  Class clazz;
  if (srcType instanceof Class) {
    clazz = (Class) srcType;
  } else if (srcType instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) srcType;
    clazz = (Class) parameterizedType.getRawType();
  } else {
    throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass());
  }

  if (clazz == declaringClass) {
    //获取上界
    Type[] bounds = typeVar.getBounds();
    if (bounds.length > 0) {
      return bounds[0];
    }
    return Object.class;
  }
  //获取声明的父类类型
  Type superclass = clazz.getGenericSuperclass();
  //通过扫描父类进行后续解析 这个是递归的入口
  result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass);
  if (result != null) {
    return result;
  }
  // 获取接口
  Type[] superInterfaces = clazz.getGenericInterfaces();
  for (Type superInterface : superInterfaces) {
    //通过扫描接口进行后续解析 逻辑同扫描父类
    result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface);
    if (result != null) {
      return result;
    }
  }
  //若在某个集成结构中解析成功则返回Object.class
  return Object.class;
}

scanSuperTypes()方法具体实现如下：

private static Type scanSuperTypes(TypeVariable typeVar, Type srcType, Class declaringClass, Class clazz, Type superclass) {
  if (superclass instanceof ParameterizedType) {
    ParameterizedType parentAsType = (ParameterizedType) superclass;
    //获取父类的原始类型
    Class parentAsClass = (Class) parentAsType.getRawType();
    TypeVariable[] parentTypeVars = parentAsClass.getTypeParameters();
    if (srcType instanceof ParameterizedType) {
      //转化父类参数化类型
      parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType);
    }
    if (declaringClass == parentAsClass) {
      for (int i = 0; i < parentTypeVars.length; i++) {
        if (typeVar.equals(parentTypeVars[i])) {
          return parentAsType.getActualTypeArguments()[i];
        }
      }
    }
    if (declaringClass.isAssignableFrom(parentAsClass)) {
      //继续解析父类，知道解析到定义该字段的类
      return resolveTypeVar(typeVar, parentAsType, declaringClass);
    }
  } else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class) superclass)) {
    //声明的父类不再含有类型变量且不是定义该字段的类则继续解析
    return resolveTypeVar(typeVar, superclass, declaringClass);
  }
  return null;
}

分析完TypeParameterResolver.resolveTypeVar()和resolveParameterizedType()两个方法后，再来看resolveGenericArrayType()方法，该方法负责解析GenericArrayType类型的变量，它会根据数组元素的类型选择合适的resolve *()方法进行解析，具体实现如下：

private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType, Class declaringClass) {
  //获取数组元素的类型
  Type componentType = genericArrayType.getGenericComponentType();
  Type resolvedComponentType = null;
  //根据数组元素类型选择合适的方法进行解析
  if (componentType instanceof TypeVariable) {
    resolvedComponentType = resolveTypeVar((TypeVariable) componentType, srcType, declaringClass);
  } else if (componentType instanceof GenericArrayType) {
    //递归调用resolveGenericArrayType()方法
    resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass);
  } else if (componentType instanceof ParameterizedType) {
    resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType, declaringClass);
  }
  //根绝解析后的数组项类型构造返回类型
  if (resolvedComponentType instanceof Class) {
    return Array.newInstance((Class) resolvedComponentType, 0).getClass();
  } else {
    return new GenericArrayTypeImpl(resolvedComponentType);
  }
}

最后我们来分析一下TypeParameterResolver.resolveWildcardType()方法。该方法负责解析WildcardType类型的变量。首先解析WildcardType类型的上下界，然后通过解析后的结果构造WildcardTypeImpl对象返回。具体解析过程与上述resolve *()类似。

通过上面的方法分析我们知道，当存在复杂的继承关系以及泛型类型时，TypeParameterResolver可以帮助我们解析字段、方法和方法返回值的类型。这个是Reflector类的基础。

MyBatis源码中也提供了TypeParameterResolver相关的TypeParameterResolverTest这个测试类，可以从多方面测试TypeParameterResolver的功能。我们可以参考一下更好的了解TypeParameterResolver的功能。

6. ObjectFactory

MyBatis中有很多模块会使用到ObjectFactory这个接口，该接口提供了多个crate()方法的重载，通过这些方法可以创建指定类型的对象。ObjectFactory接口定义如下：

public interface ObjectFactory {
  //设置配置信息
  default void setProperties(Properties properties) {
    // NOP
  }
  //通过无参构造器创建指定类的对象
   T create(Class type);
  //根据参数列表，从指定类型中选择合适的构造器创建对象
   T create(Class type, List> constructorArgTypes, List