MetaObject源码解析

MetaObject是个反射工具类它支持以“点.”的方式向下递归反射创建对象，属性赋值以及通过key名获取集合对象。

测试

public void shouldGetAndSetNestedField() {
    // 创建一个普通bean
    RichType rich = new RichType();
    // 将bean包装成MetaObject对象
    MetaObject meta = SystemMetaObject.forObject(rich);
    // 以map的方式
    meta.setValue("richType.richMap[key]", "foo");
    // 以属性的方式
    meta.setValue("richType.richField", "foo");
    // 不用.的方式，只能支持到二级属性
    meta.setValue("richProperty", "foo");
    System.out.println(meta.getValue("richType.richMap[key]"));
    System.out.println(meta.getValue("richType.richField"));
    System.out.println(meta.getValue("richProperty"));
  }
// bean的结构
public class RichType {
 
  private String richField;
 
  private String richProperty;
 
  private Map richMap = new HashMap();
}

 

forObject，简单来说就是包装一个对象赋予一些能力

private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory) {
    this.originalObject = object;// 源对象
    this.objectFactory = objectFactory;// 对象工厂
    this.objectWrapperFactory = objectWrapperFactory;// 对象包装器工厂
    // 对象包装器
    if (object instanceof ObjectWrapper) {
        //如果对象本身已经是ObjectWrapper型，则直接赋给objectWrapper
      this.objectWrapper = (ObjectWrapper) object;
    } else if (objectWrapperFactory.hasWrapperFor(object)) {
        //如果有包装器,调用ObjectWrapperFactory.getWrapperFor
      this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
    } else if (object instanceof Map) {
        //如果是Map型，返回MapWrapper
      this.objectWrapper = new MapWrapper(this, (Map) object);
    } else if (object instanceof Collection) {
        //如果是Collection型，返回CollectionWrapper
      this.objectWrapper = new CollectionWrapper(this, (Collection) object);
    } else {
        //除此以外，返回BeanWrapper
      this.objectWrapper = new BeanWrapper(this, object);
    }
  }

分词器源码，主要是将我们的传入的值进行分割

public class PropertyTokenizer implements Iterable<PropertyTokenizer>, Iterator<PropertyTokenizer> {
  // 例子：richType.richMap[key]
  // 当前字段名
  private String name; //richType
  private String indexedName; //richType
  // 下标，如果有值说明子属性有集合类型的
  private String index; //0
  // .后面的字段
  private String children; //richMap
 
  public PropertyTokenizer(String fullname) {
    //找.
    int delim = fullname.indexOf('.');
    if (delim > -1) {
      name = fullname.substring(0, delim);
      children = fullname.substring(delim + 1);
    } else {
    // 找不到.的话，取全部部分
      name = fullname;
      children = null;
    }
    indexedName = name;
    // 把中括号里的数字给解析出来
    delim = name.indexOf('[');
    if (delim > -1) {
      index = name.substring(delim + 1, name.length() - 1);
      name = name.substring(0, delim);
    }
  }

 setValue，递归调用，思路是先创建上层对象再创建下层属性（对象），知道最上层的对象才能知道它拥有什么属性

public void setValue(String name, Object value) {
    // 分词器进行分词，如richType.richMap[key]，返回richType,子属性为richMap[key]
    PropertyTokenizer prop = new PropertyTokenizer(name);
    // 是否有子属性
    if (prop.hasNext()) {
       // 内部就是递归调用，并将调用获取的值进行包装成MetaObject对象
      // 此时传入的richType后面没有.就是直接创建这个对象了。
      MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
      if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
        if (value == null && prop.getChildren() != null) {
          // don't instantiate child path if value is null
          //如果上层就是null了，还得看有没有儿子，没有那就结束
          return;
        } else {
            //否则还得new一个，委派给ObjectWrapper.instantiatePropertyValue创建新实例
          metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
        }
      }
      //递归调用setValue,给子属性赋值
      metaValue.setValue(prop.getChildren()/*子属性名称*/, value);
    } else {
      //到了最后一层了，所以委派给ObjectWrapper.set，调用setter方法
      objectWrapper.set(prop, value);
    }
  }

metaObjectForProperty 没什么好说的，就是将当前对象包装成MetaObject，如果返回null说明是类不是属性就会进入上面的第5行代码里面的逻辑

public MetaObject metaObjectForProperty(String name) {
    //实际是递归调用
  Object value = getValue(name);
  return MetaObject.forObject(value, objectFactory, objectWrapperFactory);
}

getValue套路跟setValue一样的，获取prop.name字段的对象

public Object getValue(String name) {
  PropertyTokenizer prop = new PropertyTokenizer(name);
  if (prop.hasNext()) {
    MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
    if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
        //如果上层就是null了，那就结束，返回null
      return null;
    } else {
        //否则继续看下一层，递归调用getValue
     return metaValue.getValue(prop.getChildren());
    }
  } else {
    return objectWrapper.get(prop);
  }
}

objectWrapper.get(prop, value)（objectWrapper.set(prop, value)）; 两个作用，解析集合并赋值返回，反射调用对象的getter方法

@Override
public Object get(PropertyTokenizer prop) {
    //如果有index(有中括号),说明是集合，那就要解析集合
  if (prop.getIndex() != null) {
    // 内部还是递归调用getValue，主要是通过反射获取并创建集合属性对象，到最终都会走向getBeanProperty方法
    Object collection = resolveCollection(prop, object);
    // 给集合赋值并获取
    return getCollectionValue(prop, collection);
  } else {
      //否则，getBeanProperty，底层通过反射调用getter方法
    return getBeanProperty(prop, object);
  }
}
// 如上
public void set(PropertyTokenizer prop, Object value) {
    if (prop.getIndex() != null) {
      Object collection = resolveCollection(prop, object);
      setCollectionValue(prop, collection, value);
    } else {
      setBeanProperty(prop, object, value);
    }
  }

 集合赋值方法

protected void setCollectionValue(PropertyTokenizer prop, Object collection, Object value) {
  if (collection instanceof Map) {
    ((Map) collection).put(prop.getIndex(), value);
  } else {
    int i = Integer.parseInt(prop.getIndex());
    if (collection instanceof List) {
      ((List) collection).set(i, value);
    } else if (collection instanceof Object[]) {
      ((Object[]) collection)[i] = value;
    } else if (collection instanceof char[]) {
      ((char[]) collection)[i] = (Character) value;
    } else if (collection instanceof boolean[]) {
      ((boolean[]) collection)[i] = (Boolean) value;
    } else if (collection instanceof byte[]) {
      ((byte[]) collection)[i] = (Byte) value;
    } else if (collection instanceof double[]) {
      ((double[]) collection)[i] = (Double) value;
    } else if (collection instanceof float[]) {
      ((float[]) collection)[i] = (Float) value;
    } else if (collection instanceof int[]) {
      ((int[]) collection)[i] = (Integer) value;
    } else if (collection instanceof long[]) {
      ((long[]) collection)[i] = (Long) value;
    } else if (collection instanceof short[]) {
      ((short[]) collection)[i] = (Short) value;
    } else {
      throw new ReflectionException("The '" + prop.getName() + "' property of " + collection + " is not a List or Array.");
    }
  }
}

整体流程图

总结：通过分词区分当前属性和子属性，通过反射先创建当前属性，后创建子属性，反复循环操作。