Mybatis 源码学习(7)-反射工具（ObjectWrapper & MetaObject）

历史文章：

Mybatis 源码学习(6)-反射工具（MetaClass）

MetaClass 可以通过反射来解析类级别类型信息，而 ObjectWrapper 是对对象的包装，可以通过字符串操作和查询对象的属性。ObjectWrapper 类继承关系如下，它提供了 BaseWrapper、BeanWrapper、MapWrapper 和 CollectionWrapper。BaseWrapper 提供集合类型解析的抽象方法，BeanWrapper 提供普通 Bean 的 get、set 方法，MapWrapper 提供 Map 类型的 put 和 get 方法，CollectionWrapper 提供集合的 add 和 addAll 方法。

ObjectWrapper

ObjectWrapper 的接口定义如下：

public interface ObjectWrapper {
  // 获取指定的属性
  // 如果封装的是普通的 Bean  对象，则调用对应的 get 方法
  // 如果封装的是集合对象，则返回对应下标的 value
  // 如果封装的是 Map 对象，则返回 key 对应的 value
  Object get(PropertyTokenizer prop);

  // 设置指定的属性值
  // 如果封装的是普通的 Bean  对象，则调用对应的 set 方法
  // 如果封装的是集合对象，则设置对应下标的 value
  // 如果封装的是 Map 对象，则设置 key 对应的 value
  void set(PropertyTokenizer prop, Object value);

  // 查找属性表达式指定的属性
  // useCamelCaseMapping 表示是否忽略表达式中的下划线
  String findProperty(String name, boolean useCamelCaseMapping);

  // 获取可读属性的名称集合
  String[] getGetterNames();

  // 获取可写属性的名称集合
  String[] getSetterNames();

  // 解析属性表达式指定的属性对应的 set 方法的参数类型
  Class<?> getSetterType(String name);
  // 解析属性表达式指定的属性对应的 get 方法的返回值
  Class<?> getGetterType(String name);

  // 判断属性表达式指定属性是否有 set/get 方法 
  boolean hasSetter(String name);
  boolean hasGetter(String name);

  // 为属性表达式指定的属性创建相应的 MetaObject 对象
  MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory);
  
  // 判断封装对象是否是集合
  boolean isCollection();
  
  // 向集合中添加元素，调用 Collection.add 方法
  void add(Object element);
  // 向集合中添加一批元素，调用 Collection.addAll 方法
  <E> void addAll(List<E> element);
}

ObjectWrapperFactory 负责创建 ObjectWrapper，系统默认提供了 DefaultObjectWrapperFactory，但是该默认工厂类不提供任何实现，仅抛出异常。在实际使用时，可以通过配置 mybatis-config.xml 在配置中设置自定义的 ObjectWrapperFactory。

BaseWrapper

BaseWrapper 是 ObjectWrapper 的子类（抽象类），它封装了 MetaObject，并且提供三个集合类型的操作方法供子类使用：resolveCollection、getCollectionValue、setCollectionValue。

Mybatis 源码学习(7)-反射工具（ObjectWrapper & MetaObject）

BaseWrapper.resolveCollection 方法会调用 MetaObject.getValue 解析属性表达式对应的属性（不过它一般被用来解析集合类型的属性，它能兼容普通 Bean）。

BaseWrapper.getCollectionValue 和 BaseWrapper.setCollectionValue 方法类似，它们能够解析 Map、List、数组，这三种集合类型的对象，并能够根据下标操作对应的集合中的元素。

protected Object getCollectionValue(PropertyTokenizer prop, Object collection) {
  if (collection instanceof Map) { // 集合是 Map 类型，index 是 key
    return ((Map) collection).get(prop.getIndex());
  } else {
    int i = Integer.parseInt(prop.getIndex()); // 其他集合类型，index 是数值下标
    if (collection instanceof List) { // 确认集合的类型
      return ((List) collection).get(i); // 按照下标获取对应下标元素的值
    } else if (collection instanceof Object[]) {
      return ((Object[]) collection)[i];
    } else if (collection instanceof char[]) {
      return ((char[]) collection)[i];
    } else if (collection instanceof boolean[]) {
      return ((boolean[]) collection)[i];
    } else if (collection instanceof byte[]) {
      return ((byte[]) collection)[i];
    } else if (collection instanceof double[]) {
      return ((double[]) collection)[i];
    } else if (collection instanceof float[]) {
      return ((float[]) collection)[i];
    } else if (collection instanceof int[]) {
      return ((int[]) collection)[i];
    } else if (collection instanceof long[]) {
      return ((long[]) collection)[i];
    } else if (collection instanceof short[]) {
      return ((short[]) collection)[i];
    } else {
      throw new ReflectionException(“…”);
    }
  }
}

BeanWrapper

BeanWrapper 继承了 BaseWrapper，它封装了实际的 JavaBean 对象、该对象的 MetaClass、该对象的 MetaObject。除了类级别上的 findProperty、getGetterNames、getSetterNames、getSetterType、getGetterType、hasSetter、hasGetter方法外，BeanWrapper 还包含三个对象级别的操作方法：get、set、instantiatePropertyValue。

BeanWrapper.get、BeanWrapper.set 方法可以用来根据属性表达式获取和设置相应的属性值。

// 获取属性表达式对应的值
public Object get(PropertyTokenizer prop) {
  // 如果存在下标信息，则表示该表达式是集合类型
  if (prop.getIndex() != null) {
    // 通过 MetaObject.getValue 方法获取 object 对象中的指定集合属性；
    // 实际上 MetaObject.getValue 又重新调用了该方法，
    // 由于重新调用时不存在下标，则会直接调用 getBeanProperty 去解析属性
    Object collection = resolveCollection(prop, object);
    // 按照下标获取元素
    return getCollectionValue(prop, collection);
  } else {
    // 不存在索引，直接获取 Bean 属性
    // 直接调用属性的 Invoker.invoke，即可能存在 get 方法或者 Field 本身
    return getBeanProperty(prop, object);
  }
}

private Object getBeanProperty(PropertyTokenizer prop, Object object) {
  try {
    // 根据属性名称，查找 Reflector.getMethods 集合中相应的 GetFieldinvoker 或 Methodinvoker
    Invoker method = metaClass.getGetInvoker(prop.getName());
    try {
      // 通过反射获取属性值
      return method.invoke(object, NO_ARGUMENTS);
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  } catch (RuntimeException e) {
    throw e;
  } catch (Throwable t) {
    throw new ReflectionException(“…”);
  }
}

BeanWrapper.instantiatePropertyValue 可以创建属性表达式指定的属性实例（只能是该对象直接引用的属性），同时创建该实例对应的 MetaObject。

public MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory) {
  MetaObject metaValue;
  Class<?> type = getSetterType(prop.getName());  // 获取 getter 的返回值类型，即属性的类型
  try {
    Object newObject = objectFactory.create(type); // 构造一个属性的实例
    // 创建该实例的 MetaObject 以便后续通过 MetaObject 操作对象
    metaValue = MetaObject.forObject(newObject, metaObject.getObjectFactory(), metaObject.getObjectWrapperFactory(), metaObject.getReflectorFactory());
    // 将属性实例设置至对象中
    set(prop, newObject);
  } catch (Exception e) {
    throw new ReflectionException(“…”);
  }
  return metaValue;
}

MapWrapper

MapWrapper 是对 Map<String, Object> 的封装，它提供的 get、set 方法都是针对 key 做操作的。

CollectionWrapper

CollectionWrapper 是对 Collection 的封装，它不提供 get、set 方法，但是提供针对集合的 add 和 addAll 方法用于添加元素。

MetaObject

MetaObject 是对 ObjectWrapper 的封装，它提供实际对象的 getValue/setValue 方法，它的内部实现均依赖 ObjectWrapper。MetaObject 包含以下字段：

private final Object originalObject; // 原始 JavaBean 对象
private final ObjectWrapper objectWrapper; // 原始 JavaBean 对象对应的 ObjectWrapper
private final ObjectFactory objectFactory; // 负责实例化 originalObject 的 工厂对象
private final ObjectWrapperFactory objectWrapperFactory; // 负责创建ObjectWrapper的工厂对象
private final ReflectorFactory reflectorFactory; // 用于创建并缓存 Reflector 对象的工厂对象

MetaObject 的初始化需要传入原始对象、对象工厂 ObjectFactory 等，并在构造器内完成 ObjectWrapper 的初始化。

// private 修饰，避免外部创建对象
private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
  // 初始化参数
  this.originalObject = object;
  this.objectFactory = objectFactory;
  this.objectWrapperFactory = objectWrapperFactory;
  this.reflectorFactory = reflectorFactory;

  if (object instanceof ObjectWrapper) { // 如果原始对象已经是 ObjectWrapper 对象，则直接使用
    this.objectWrapper = (ObjectWrapper) object;
  } else if (objectWrapperFactory.hasWrapperFor(object)) {
    // 若 ObjectWrapperFactory 能够为该原始对象创建对应的 ObjectWrapper 对象，则优先使用 ObjectWrapperFactory
    // 默认的 DefaultObjectWrapperFactory.hasWrapperFor 返回值是 false 因此不能被使用
    this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
  } else if (object instanceof Map) {
    // 处理 Map 类型
    this.objectWrapper = new MapWrapper(this, (Map) object);
  } else if (object instanceof Collection) {
    // 处理 Collection 类型
    this.objectWrapper = new CollectionWrapper(this, (Collection) object);
  } else {
    // 如果是普通 JavaBean，则创建 BeanWrapper
    this.objectWrapper = new BeanWrapper(this, object);
  }
}

// 静态工厂方法
public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
  if (object == null) {
    // 若 object 为 null ，则返回 SystemMetaObject .NULL_META_OBJECT 作为 null 对象
    return SystemMetaObject.NULL_META_OBJECT;
  } else {
    return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
  }
}

MetaObject 和 ObjectWrapper 中关于类级别的方法，例如 hasGetter、hasSetter、findProperty 等方法，都是直接调用 MetaClass 的对应方法实现的。而 MetaObject 关于对象的方法，例如 getValue、setValue 都是调用 ObjectWrapper 的方法实现的。

public Object getValue(String name) {
  // 解析属性表达式
  PropertyTokenizer prop = new PropertyTokenizer(name);
  if (prop.hasNext()) { // 处理子表达式
    // 根据解析后的表达式创建 MetaObject
    MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
    if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
      return null;
    } else {
      return metaValue.getValue(prop.getChildren()); // 递归处理子表达式
    }
  } else {
    return objectWrapper.get(prop); // 通过 ObjectWrapper 获取指定的属性（递归出口）
  }
}

public MetaObject metaObjectForProperty(String name) {
  Object value = getValue(name); // 获取指定的属性
  // 创建属性对应的 MetaObject
  return MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);
}

如果存在以下类结构：

public class A {
    List<B> lists;
}

public class B {
    private String name;
}

以

metaObject.getValue("lists[0].name”)

为例，其中 metaObject 是对象 A 的一个实例对应的 MetaObject 对象：

调用 metaObject.getValue 将属性占位符解析为 name = lists，indexName= lists[0]，children = name ；
调用 metaObjectForProperty 处理表达式 lists[0] ，通过间接调用 metaObject.getValue -> objectWrapper.get，会实际调用 BeanWrapper.get 方法，解析集合类型对象，之后触发 resolveCollection 和 getCollectionValue 解析集合中的元素；
得到对象 B 后，继续解析表达式 name，即调用表示 B 对象的 metaValue.getValue(“name”) 的属性值。

MetaObject.setValue 的逻辑和 MetaObject.getValue 的逻辑一致，但是如果需要设置的值不为空，会通过 BeanWrapper.instantiatePropertyValue 创建路径上的空对象（但是如果使用下标指定集合对象，则无法创建对应下标指向的对象）。BeanWrapper.instantiatePropertyValue 内部使用 DefaultObjectFactory.create 方法通过反射创建对象：

public MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory) {
  MetaObject metaValue;
  // 获取属性 getter 方法的返回值类型
  Class<?> type = getSetterType(prop.getName());
  try {
     // 通过反射创建属性对象
    Object newObject = objectFactory.create(type);
    // 创建对象对应的 MetaObject
    metaValue = MetaObject.forObject(newObject, metaObject.getObjectFactory(), metaObject.getObjectWrapperFactory(), metaObject.getReflectorFactory());
    // 将创建后的对象设置到对应的属性或集合中
    set(prop, newObject);
  } catch (Exception e) {
    throw new ReflectionException(“…”);
  }
  return metaValue;
}

总结

ObjectWrapper 和 MetaObject 都是对对象的封装，ObjectWrapper 是一系列类，它提供对 JavaBean、Map、Collection 实例的操作封装，能够很方便的操作这些类型的属性、元素。MetaObject 是对 ObjectWrapper 的封装，它可以实现对任意类型的对象，通过属性表达式直接操作，而无需明确实例化对象。

参考文档：《Mybatis 技术内幕》

本文的基本脉络参考自《Mybatis 技术内幕》，编写文章的原因是希望能够系统地学习 Mybatis 的源码，但是如果仅阅读源码或者仅从官方文档很难去系统地学习，因此希望参考现成的文档，按照文章的脉络逐步学习。

欢迎关注我的公众号：我的搬砖日记，我会定时分享自己的学习历程。

Mybatis 源码学习(7)-反射工具（ObjectWrapper & MetaObject）

Mybatis 源码学习(7)-反射工具（ObjectWrapper & MetaObject）

ObjectWrapper

BaseWrapper

BeanWrapper

MapWrapper

CollectionWrapper

MetaObject

总结

继续阅读

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

用mybatis的generator插件在项目中自动生成dao及entity

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

从mybatis到mybatis plus(mp)

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

Mybatis 源码学习(7)-反射工具（ObjectWrapper &amp; MetaObject）

ObjectWrapper

BaseWrapper

BeanWrapper

MapWrapper

CollectionWrapper

MetaObject

总结

继续阅读

Mybatis 源码学习(7)-反射工具（ObjectWrapper & MetaObject）