MyBatis源码实现之反射工具箱之Reflector&ReflectorFactory

我不是女神ヾ 2022-02-25 06:39 287阅读 0赞

## 反射工具箱之Reflector&ReflectorFactory ##

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

### 2.2.1 Reflector&ReflectorFactory ###

为了后面描述的方便，也为了避免产生混淆，这里简单回顾一下JavaBean 规范：类中定义  
的成员变量也称为“ 宇段” ，属性则是通过getter/setter 方法得到的，属性只与类中的方法有关，  
与是否存在对应成员变量没有关系。例如，存在getA （）方法和setA(String）方法，无论类中是否  
定义了字段SettingA() ，我们都认为该类中存在属性a。在后面的分析中，属性的getter/setter 方法  
与同名的字段虽然会一起出现，但还是有必要让读者区分这两个概念。

Reflector是MyBatis 中反射模块的基础，每个Reflector 对象都对应一个类，在Reflector 中  
缓存了反射操作需要使用的类的元信息。Reflector中各个字段的含义如下：

// 对应的class类型
      private final Class<?> type;
      
      // 可读属性的集合，所谓的可读属性就是存在get方法的属性。初始化为空
      private final String[] readablePropertyNames;
      
      // 可写属性的集合，所谓的可写属性就是存在set方法的属性。初始化为空
      private final String[] writeablePropertyNames;
      
      // 记录了属性相应的set方法，key是属性名称，value是Invoker对象，它是对set方法对应Method对象的封装，后面会详细介绍
      private final Map<String, Invoker> setMethods = new HashMap<String, Invoker>();
      
      // 记录了属性相应的get方法，key是属性名称，value是Invoker对象，它是对get方法对应Method对象的封装，后面会详细介绍
      private final Map<String, Invoker> getMethods = new HashMap<String, Invoker>();
      
      // 记录了属性相应set方法的参数类型,key是属性名，value是set方法的参数类型
      private final Map<String, Class<?>> setTypes = new HashMap<String, Class<?>>();
      
      // 记录了属性相应get方法的参数类型,key是属性名，value是get方法的参数类型
      private final Map<String, Class<?>> getTypes = new HashMap<String, Class<?>>();
      
      // 记录了默认的构造方法
      private Constructor<?> defaultConstructor;
      
      // 记录了所有属性名称的集合
      private Map<String, String> caseInsensitivePropertyMap = new HashMap<String, String>();

在Reflector的构造方法中会解析指定的Class对象，并填充上述集合，具体实现如下：

public Reflector(Class<?> clazz) {
        // 初始化type类型字段
        type = clazz;
        
        // 查找默认的无参构造参数，思路简单（略）
        addDefaultConstructor(clazz);
        
        // 处理clazz中的get方法，填充getMethods集合和getTypes集合
        addGetMethods(clazz);
        
        // 处理clazz中的set方法，填充setMethods集合和setTypes集合
        addSetMethods(clazz);
        
        // 处理没有get/set方法的字段
        addFields(clazz);
        
        // 根据getMethods和setMethods集合，初始化可读、可写属性的属性名称
        readablePropertyNames = getMethods.keySet().toArray(new String[getMethods.keySet().size()]);
        writeablePropertyNames = setMethods.keySet().toArray(new String[setMethods.keySet().size()]);
        
        // 初始化caseInsensitivePropertyMap集合，其中记录了所有大写的属性名称的集合
        for (String propName : readablePropertyNames) {
          caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
        for (String propName : writeablePropertyNames) {
          caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
      }

Reflector.addGetMethods（）方法主要负责解析类中定义的getter方法， Reflector.addSetterMethods（）方法负责解析类中定义的setter方法，两者的逻辑类似，这里以addGetMethods （）方法为例进行  
介绍，addSetMethods（）方法不再详细介绍，请读者参考源码学习。  
Reflector.addGetMethods（）方法有如下三个核心步骤。

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

private Method[] getClassMethods(Class<?> cls) {
        // 用于记录类中定义的全部方法的唯一签名及对应的Method对象
        Map<String, Method> uniqueMethods = new HashMap<String, Method>();
        Class<?> currentClass = cls;
        while (currentClass != null && currentClass != Object.class) {
          // 记录currentClass这个类中定义的全部方法
          addUniqueMethods(uniqueMethods, currentClass.getDeclaredMethods());
    
          // 记录接口中定义的方法
          Class<?>[] interfaces = currentClass.getInterfaces();
          for (Class<?> anInterface : interfaces) {
            addUniqueMethods(uniqueMethods, anInterface.getMethods());
          }
    
          // 获取父类，继续while循环
          currentClass = currentClass.getSuperclass();
        }
    
        Collection<Method> methods = uniqueMethods.values();
    
        return methods.toArray(new Method[methods.size()]);
      }

在Reflector.addUniqueMethods（）方法中会为每个方法生成唯一签名，井记录到  
uniqueMethods集合中，具体实现如下：

private void addUniqueMethods(Map<String, Method> uniqueMethods, Method[] methods) {
        for (Method currentMethod : methods) {
          if (!currentMethod.isBridge()) {
            // 获取方法签名：返回值类型#方法名：参数类型列表
            String signature = getSignature(currentMethod);
            // 检测是否在子类中已经添加过该方法，如果在子类中已经添加过， 9)1］表示子类覆盖了该方法，元须再向uniqueMethods 集合中添加该方法了
            if (!uniqueMethods.containsKey(signature)) {
              if (canAccessPrivateMethods()) {
                try {
                  currentMethod.setAccessible(true);
                } catch (Exception e) {
                  // Ignored. This is only a final precaution, nothing we can do.
                }
              }
    
              uniqueMethods.put(signature, currentMethod);
            }
          }
        }
      }

（2）然后，按照JavaBean的规范,从Reflector.getClassMethods（）方法返回的Method 数组  
中查找该类中定义的getter方法（具体哪些方法算是getter 方法，后面会详细介绍），将其记录  
到conflictingGetters 集合中。conflictingGetters 集合（ HashMap<String， List＞（）类型）  
的key为属性名称,value是该属性对应的getter方法集合。

（3）当子类覆盖了父类的getter方法且返回值发生变化时，在步骤l中就会产生两个签名  
不同的方法。例如现有类A及其子类SubA, A 类中定义了getNames（）方法，其返回值类型是  
List<String＞，而在其子类SubA 中， 覆写了其getNames（）方法且将返回值修改成ArrayList  
类型，这种覆写在Java 语言中是合法的。最终得到的两个方法签名分别是java.util.List\#getNames  
和java.util.ArrayList\#getNames，在Reflector.addUniqueMethods（）方法中会被认为是两个不同的  
方法并添加到uniqueMethods 集合中，这显然不是我们想要的结果。

所以，步骤3会调用Reflector.resolveGetterConflicts（）方法对这种覆写的情况进行处理，同  
时会将处理得到的getter 方法记录到getMethods 集合，并将其返回值类型填充到getTypes 集合。  
Reflector.resolveGetterConflicts（）方法的具体实现如下：

private void resolveGetterConflicts(Map<String, List<Method>> conflictingGetters) {
        for (Entry<String, List<Method>> entry : conflictingGetters.entrySet()) {
          // 记录最终符合要求的method对象
          Method winner = null;
          // method对应的属性名
          String propName = entry.getKey();
          for (Method candidate : entry.getValue()) {
            // 首次进来循环时，winner和candidate,然后继续下次循环
            if (winner == null) {
              winner = candidate;
              continue;
            }
            Class<?> winnerType = winner.getReturnType();
            Class<?> candidateType = candidate.getReturnType();
            // 类型一致
            if (candidateType.equals(winnerType)) {
              if (!boolean.class.equals(candidateType)) {
                throw new ReflectionException(
                    "Illegal overloaded getter method with ambiguous type for property "
                        + propName + " in class " + winner.getDeclaringClass()
                        + ". This breaks the JavaBeans specification and can cause unpredictable results.");
              } else if (candidate.getName().startsWith("is")) {
                winner = candidate;
              }
            // winterType是candidateType类型的子类或接口的子实现
            } else if (candidateType.isAssignableFrom(winnerType)) {
              // OK getter type is descendant
            // candidateType是winnerType的子类或接口的子实现
            } else if (winnerType.isAssignableFrom(candidateType)) {
              winner = candidate;
            } else {
            // 返回值具有二义性，抛出异常
              throw new ReflectionException(
                  "Illegal overloaded getter method with ambiguous type for property "
                      + propName + " in class " + winner.getDeclaringClass()
                      + ". This breaks the JavaBeans specification and can cause unpredictable results.");
            }
          }
          addGetMethod(propName, winner);
        }
      }

正如上面所描述的那样，在Reflector.addGetMethod（）方法中完成了对getMethods集合和  
getTypes集合的填充，具体实现如下：

private void addGetMethod(String name, Method method) {
        // 对名称的合法性进行检查
        if (isValidPropertyName(name)) {
          // 将属性名及对应的MethodInvoker对象添加到getMethods集合中去，MethodInvoker作用后面介绍
          getMethods.put(name, new MethodInvoker(method));
          // 将属性名及对应的方法的返回值类型放入getTypes集合中
          Type returnType = TypeParameterResolver.resolveReturnType(method, type);
          getTypes.put(name, typeToClass(returnType));
        }
      }

了解了Reflector.addGetMethods（）方法的三个核心步骤之后，下面来看其具体实现：

private void addGetMethods(Class<?> cls) {
        Map<String, List<Method>> conflictingGetters = new HashMap<String, List<Method>>();
        // 步骤1：获取指定类以及其父类和接口中定义的方法
        Method[] methods = getClassMethods(cls);
        
        // 步骤2：按照JavaBean规范查找getter方法，并记录到conflictingGetters集合中
        for (Method method : methods) {
          if (method.getParameterTypes().length > 0) {
            continue;
          }
          String name = method.getName();
          if ((name.startsWith("get") && name.length() > 3)
              || (name.startsWith("is") && name.length() > 2)) {
            name = PropertyNamer.methodToProperty(name);
            addMethodConflict(conflictingGetters, name, method);
          }
        }
        // 步骤3：对conflictingGetters集合进行处理
        resolveGetterConflicts(conflictingGetters);
      }

Reflector.addFields（）方法会处理类中定义的所有字段，并且将处理后的字段信息添加到  
setMethods集合、setTypes 集合、getMethods 集合以及getTypes 集合中，这一点与上述的  
Reflector.addGetMethods（）方法是一致的。Reflector.addFields（）方法的具体实现如下：

private void addFields(Class<?> clazz) {
        // 获取class中的全部字段
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
          if (canAccessPrivateMethods()) {
            try {
              field.setAccessible(true);
            } catch (Exception e) {
              // Ignored. This is only a final precaution, nothing we can do.
            }
          }
          if (field.isAccessible()) {
            // 当setMethods 集合不包含同名属性时，将其记录到setMethods 集合和setTypes 集合
            if (!setMethods.containsKey(field.getName())) {
              int modifiers = field.getModifiers();
              // 过滤掉final和static 修饰的字段
              if (!(Modifier.isFinal(modifiers) && Modifier.isStatic(modifiers))) {
                addSetField(field);
              }
            }
            // 当getMethods 集合中不包含同名属，l生时，将其记录到getMethods 集合和get Type s 集合
            if (!getMethods.containsKey(field.getName())) {
              addGetField(field);
            }
          }
        }
        // 处理父类重定义的字段
        if (clazz.getSuperclass() != null) {
          addFields(clazz.getSuperclass());
        }
      }

Reflector的初始化过程就介绍到这里了。Reflector 中提供了多个get＊（）方法用于读取上述集  
合中记录的元信息，代码比较简单，请读者参考源码。

还有一点需要注意的是， add \* Method （）方法和add \* Field （）方法在向上述集合添加元素时，  
会将getter/setter 方法对应的Method 对象以及字段对应的Field 对象统一封装成Invoker对象。  
Invoker 接口的定义如下所示。

public interface Invoker {
      // 获取指定字段的值或执行指定的方法，下文会继续介绍
      Object invoke(Object target, Object[] args) throws IllegalAccessException, InvocationTargetException;
    
      // 返回属性的相应的类型
      Class<?> getType();
    }

![在这里插入图片描述][20190401100257596.png]

GetFieldInvoker/SetFieldInvoker 通过field字段封装了对应的Field 对象，两者的invoke （）方  
法是通过调用Field.get()/set（）方法实现的。MethodInvoker 通过method 宇段封装了对应方法的  
Method 对象，其invoke（）方法是通过调用Method.invoke（）方法实现的。具体代码比较简单，就  
不再贴出来了。

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

public interface ReflectorFactory {
    
      // 检测该ReflectorFactory是否缓存了Reflector对象
      boolean isClassCacheEnabled();
    
      // 设置是否缓存该Reflector对象
      void setClassCacheEnabled(boolean classCacheEnabled);
    
      // 创建指定class的Reflector对象
      Reflector findForClass(Class<?> type);
    }

MyBatis只为该接口提供了DefaultReflectorFactory 这一个实现类，它与Reflector的关系如  
图2-9 所示。

![在这里插入图片描述][20190401100349688.png]

DefaultReflectorFactory中字段的含义如下：

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

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

@Override
      public Reflector findForClass(Class<?> type) {
        // 判断是否开启缓存
        if (classCacheEnabled) {
          Reflector cached = reflectorMap.get(type);
          if (cached == null) {
            // 创建reflector对象
            cached = new Reflector(type);
            // 放入集合缓存中去
            reflectorMap.put(type, cached);
          }
          return cached;
        } else {
          return new Reflector(type);
        }
      }

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

[20190401100257596.png]: /images/20220225/d45ad3e0397c4683904a1966f9a17f0f.png
[20190401100349688.png]: /images/20220225/5772702c3150456ba0fac13daa94e740.png