mybatis源码解读(九)：reflection 包下 MetaObject、Reflector、MetaClass详解

我不是女神ヾ 2023-02-25 10:25 12阅读 0赞

## 功能 ##

reflection 包下的类主要负责的功能是 mybatis 反射实例化对象以及赋值，mybatis之所以可以将返回结果封装成pojo实体类，都是通过reflection包下的相关类通过反射去完成这个操作的。reflection 包下有几个核心的类，MetaObject、Reflector、MetaClass、以及ObjectWrapper。  
它的这个设计思路是，首先将一个class的所有的字段、方法、构造等信息全部都存在 reflector 中，然后再通过 metaObject 的静态方法构造一个元数据对象，通过 ObjectWrapper 去调用 reflaector 中的getSet方法去赋值以及构造方法初始化对象。

## UML ##

MetaClass、MetaObject 相当于是一个封装类，内部封装了 reflector 等元数据信息  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTgy_size_16_color_FFFFFF_t_70]  
Reflector 中有一些关于一个class的详细描述，有type(Class对象)、getMethdos、setMethods、defaultConstructor、readablePropertyNames(get方法的字段名字)、writablePropertyNames(set方法的字段名字)、setTypes(set方法的入参)、caseInsensitivePropertyMap(getset方法的名字大写)等属性。  
DefaultReflectorFactory 是一个构造工厂，顾名思义，是用来构造 Reflector 的，MetaClass 要想获得这个对象，是通过一个静态方法 forClass 来拿的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTgy_size_16_color_FFFFFF_t_70 1]  
MetaObject 内部的一些属性：  
originalObject：实际对象  
ObjectWrapper：封装了调用set方法往对象设值的封装类  
ObjectFactory：反射实例化对象的工厂方法  
objectWrapperFactory：生成 ObjectWrapper 的工厂  
ReflectorFactory： 获取反射元数据信息的工厂  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTgy_size_16_color_FFFFFF_t_70 2]  
ObjectWrapper 是具体往对象中设置的封装类，他有三个主要实现类，通过名字也可以看出来各自的作用：  
BeanWrapper：实例单一对象的处理类  
MapWrapper： 针对Map类型的处理类  
CollectionWrapper：针对集合的处理类

## 代码详解 ##

MetaClass 的获取是通过 forClass 来获取的，在 .XMLMapperBuilder的validateCollection方法中就有一个使用示例，一般用 MetaClass 都是来验证这个类中的某个字段是否存在，比如 validateCollection 验证这个类是否有set方法。

protected void validateCollection(XNode context, Class<?> enclosingType) { 
        if ("collection".equals(context.getName()) && context.getStringAttribute("resultMap") == null
            && context.getStringAttribute("javaType") == null) { 
          // 获取 metaClass
          MetaClass metaResultType = MetaClass.forClass(enclosingType, configuration.getReflectorFactory());
          String property = context.getStringAttribute("property");
          // 判断是否有setter方法
          if (!metaResultType.hasSetter(property)) { 
            throw new BuilderException(
              "Ambiguous collection type for property '" + property + "'. You must specify 'javaType' or 'resultMap'.");
          }
        }
      }

MetaClass.forClass() 方法中，会去调用构造方法，在构造方法中，会通过ReflectorFactory 的findForClass() 方法去构建一个 reflector 出来，这里如果你没有配置的话默认是 DefaultReflectorFactory类

public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory) { 
        return new MetaClass(type, reflectorFactory);
      }
      
      private MetaClass(Class<?> type, ReflectorFactory reflectorFactory) { 
        this.reflectorFactory = reflectorFactory;
        this.reflector = reflectorFactory.findForClass(type);
      }

在 DefaultReflectorFactory 类的 findForClass()方法中，会去判断是否需要缓存，如果有缓存的话会将这个reflector 缓存下来，这样下次调用的时候就可以直接获取不需要再次解析class提升效率，缓存的概念在mybatis中使用的是很多的。

@Override
      public Reflector findForClass(Class<?> type) { 
        if (classCacheEnabled) { 
          // synchronized (type) removed see issue #461
          return reflectorMap.computeIfAbsent(type, Reflector::new);
        } else { 
          return new Reflector(type);
        }
      }

Reflector() 构造方法内部逻辑也很简单，就是分别调用Class对象的默认方法去获取这个class的一些信息，然后会将getset方法名字分别都塞到readablePropertyNames 与 writablePropertyNames 方法中。

public Reflector(Class<?> clazz) { 
        type = clazz;
        // 调用 class 对象的 getDeclaredConstructors() 方法去获取默认构造方法
        addDefaultConstructor(clazz);
        // 获取get methods
        addGetMethods(clazz);
        // 获取set methods
        addSetMethods(clazz);
        // 会有一个补偿，如果这个方法没有 get方法，则会默认生成一个 invoke，并且在getTypes 塞入参标识
        addFields(clazz);
        readablePropertyNames = getMethods.keySet().toArray(new String[0]);
        writablePropertyNames = setMethods.keySet().toArray(new String[0]);
        for (String propName : readablePropertyNames) { 
          caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
        for (String propName : writablePropertyNames) { 
          caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
      }

至于 hasSetter() 其实很简单，就是判断一下 getMethod 方法中是否包含这个属性，不过这里有小细节，就是这里支持表达式形势的检查的，通过 PropertyTokenizer 来完成和这个表达式的解释，比如 user.age 最终会去 解析 user 这个对象下的 age 这个属性是否有setter方法。

public boolean hasSetter(String name) { 
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if (prop.hasNext()) { 
          if (reflector.hasSetter(prop.getName())) { 
            MetaClass metaProp = metaClassForProperty(prop.getName());
            return metaProp.hasSetter(prop.getChildren());
          } else { 
            return false;
          }
        } else { 
          return reflector.hasSetter(prop.getName());
        }
      }

MetaObject 对象的使用，有个示例就是 ResultSetHandler 中的 getRowValue() 方法，这里的 configuration.newMetaObject() 方法其实就是调用默认forObject()方法去实例化 MetaObject

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException { 
    	  // 初始化MetaObject 
          final MetaObject metaObject = configuration.newMetaObject(rowValue);
          boolean foundValues = this.useConstructorMappings;
          if (shouldApplyAutomaticMappings(resultMap, false)) { 
            foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
          }
          // MetaObject去设置
          foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
      
        return rowValue;
      }

forObject() 方法会去调用构造方法，在构造方法内部，只有生成objectWrapper 时稍微有些逻辑处理，他会根据你传入进来的实际对象去决定你到底要生成哪一种wrapper，默认的对象是BeanWrapper

private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { 
        // 目标对象
        this.originalObject = object;
        // 实例化对象工厂
        this.objectFactory = objectFactory;
        // objectWrapper 工厂
        this.objectWrapperFactory = objectWrapperFactory;
        // 反射工厂
        this.reflectorFactory = reflectorFactory;
    	
    	// 根据 目标对象去决定是哪一种wrapper
        if (object instanceof ObjectWrapper) { 
          this.objectWrapper = (ObjectWrapper) object;
        } else if (objectWrapperFactory.hasWrapperFor(object)) { 
          this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
        } else if (object instanceof Map) { 
          this.objectWrapper = new MapWrapper(this, (Map) object);
        } else if (object instanceof Collection) { 
          this.objectWrapper = new CollectionWrapper(this, (Collection) object);
        } else { 
          this.objectWrapper = new BeanWrapper(this, object);
        }
      }

拿到以后我们看一下使用，metaObject.setValue(property, value) 方法，可以看到这里也有  
PropertyTokenizer，所以这里也是支持表达式解析的，默认的话其实是会去调用objectWrapper.set()方法。

public void setValue(String name, Object value) { 
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if (prop.hasNext()) { 
          MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
          if (metaValue == SystemMetaObject.NULL_META_OBJECT) { 
            if (value == null) { 
              // don't instantiate child path if value is null
              return;
            } else { 
              metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
            }
          }
          metaValue.setValue(prop.getChildren(), value);
        } else { 
          objectWrapper.set(prop, value);
        }
      }

set() 方法内部，具体的逻辑处理是在setBeanProperty()方法中，这里会通过metaClass直接去拿到set方法，然后invoke一下，就可以将值塞到对象内部了。

private void setBeanProperty(PropertyTokenizer prop, Object object, Object value) { 
        try { 
        // 通过metaClass去获取set方法
          Invoker method = metaClass.getSetInvoker(prop.getName());
          Object[] params = { value};
          try { 
          // method直接invoke
            method.invoke(object, params);
          } catch (Throwable t) { 
            throw ExceptionUtil.unwrapThrowable(t);
          }
        } catch (Throwable t) { 
          throw new ReflectionException("Could not set property '" + prop.getName() + "' of '" + object.getClass() + "' with value '" + value + "' Cause: " + t.toString(), t);
        }
      }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTgy_size_16_color_FFFFFF_t_70]: /images/20230209/fb0dbab1e0b043d2b5b36708ad16f575.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTgy_size_16_color_FFFFFF_t_70 1]: /images/20230209/d66945fc5908426298f59da00596afef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTgy_size_16_color_FFFFFF_t_70 2]: /images/20230209/99d2af7b52d6408f989d1f7d85a7a16a.png