# 一.测试代码：
```
//①通过反射 实例化对象
ObjectFactory objectFactory = new DefaultObjectFactory();
TUser user = objectFactory.create(TUser.class);
ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
③
ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
//②拿到 MeteObject 对象
MetaObject metaObject = MetaObject.forObject(user, objectFactory, objectWrapperFactory, reflectorFactory);
//通过metaObject 可以拿到Reflector，拿到反射对象的各种信息
//使用Reflector读取类元信息
Reflector findForClass = reflectorFactory.findForClass(TUser.class);
Constructor<?> defaultConstructor = findForClass.getDefaultConstructor();
String[] getablePropertyNames = findForClass.getGetablePropertyNames();
String[] setablePropertyNames = findForClass.getSetablePropertyNames();
System.out.println(defaultConstructor.getName());
System.out.println(Arrays.toString(getablePropertyNames));
System.out.println(Arrays.toString(setablePropertyNames));
//使用metaObject可以获取ObjectWrapper
//ObjectWrapper读取对象信息，并对对象属性进行赋值操作
// TUser userTemp = new TUser();
ObjectWrapper wrapperForUser = metaObject.getObjectWrapper();
wrapperForUser.getGetterNames();
wrapperForUser.getSetterNames();
PropertyTokenizer prop = new PropertyTokenizer("userName");
wrapperForUser.set(prop, " liuyanfei");
System.out.println(metaObject.getOriginalObject());
```# 二.关于①处的源码
ObjectFactory:MyBatis每次创建结果对象的新实例时，它都会使用对象工厂(ObjectFactory)去构建POJO;
ObjectFactory对利用反射创建对象进行了封装，所以在写业务代码的时候可以利用ObjectFactory 的 create 方法快速的创建目标对象。他的实现类是org.apache.ibatis.reflection.factory.DefaultObjectFactory。以下是 DefaultObjectFactory 的部分源码
```
@Override
public <T> T create(Class<T> type) {
return create(type, null, null);
}
@SuppressWarnings("unchecked")
@Override
public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
Class<?> classToCreate = resolveInterface(type);
// we know types are assignable
return (T) instantiateClass(classToCreate, constructorArgTypes, constructorArgs);
}
//调用 create 方法 最终调用的是这个方法
<T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
try {
Constructor<T> constructor;
//实力化一个无参的对象
if (constructorArgTypes == null || constructorArgs == null) {
//调用 目标类默认的构造器
constructor = type.getDeclaredConstructor();
//如果构造器是 private 的，那么就把他变成 public
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
//调用 jdk 的反射方法 返回实例
return constructor.newInstance();
}
constructor = type.getDeclaredConstructor(constructorArgTypes.toArray(new Class[constructorArgTypes.size()]));
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
return constructor.newInstance(constructorArgs.toArray(new Object[constructorArgs.size()]));
} catch (Exception e) {
StringBuilder argTypes = new StringBuilder();
if (constructorArgTypes != null && !constructorArgTypes.isEmpty()) {
for (Class<?> argType : constructorArgTypes) {
argTypes.append(argType.getSimpleName());
argTypes.append(",");
}
argTypes.deleteCharAt(argTypes.length() - 1); // remove trailing ,
}
StringBuilder argValues = new StringBuilder();
if (constructorArgs != null && !constructorArgs.isEmpty()) {
for (Object argValue : constructorArgs) {
argValues.append(String.valueOf(argValue));
argValues.append(",");
}
argValues.deleteCharAt(argValues.length() - 1); // remove trailing ,
}
throw new ReflectionException("Error instantiating " + type + " with invalid types (" + argTypes + ") or values (" + argValues + "). Cause: " + e, e);
}
}
```
# 三.②处的源码。
### 1.MetaObject中的源码
ReflectorFactory：创建Reflector的工厂类，Reflector是mybatis反射模块的基础，每个Reflector对象都对应
一个类。ReflectorFactory在其中缓存了Reflector
ObjectWrapper:对对象的包装，抽象了对象的属性信息，他定义了一系列查询对象属性信息的方法，以及更
新属性的 MetaObject 通过静态方法forObject 实例化 MetaObject
```
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) {
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 {
//构造函数中会判断目标类是属于哪种类型的这里我们只演示简单对象，所以最终会执行到这里 实例化BeanWrapper
//BeanWrapper 是ObjectWrapper的实现类。实例化的时候通过构造器把MetaObject对象和目标对象传进去，接下来看BeanWrapper的实现
this.objectWrapper = new BeanWrapper(this, object);
}
}
public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
if (object == null) {
return SystemMetaObject.NULL_META_OBJECT;
} else {
return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
}
}
```
### 2.BeanWrapper中的源码
BaseWrapper:是实现了ObjectWrapper的一个抽象类BeanWrapper中包含两个属性，一个是目标对象的实例（object），一个是metaClass
```
public class BeanWrapper extends BaseWrapper {
private final Object object;
private final MetaClass metaClass;
public BeanWrapper(MetaObject metaObject, Object object) {
super(metaObject);
this.object = object;
//实例化BeanWrapper，会调用 MetaClass 的静态方法forClass
//注意调用 forClass 会传入两个参数，
//第一个是目标对象的 class，
//第二个是ReflectorFactory,就是在测试代码中③处创建的那个 ReflectorFactory,传递过程请看 MetaObject的①处
this.metaClass = MetaClass.forClass(object.getClass(), metaObject.getReflectorFactory());
}
.....
```### 3.MetaClass 中的源码
MetaClass 中包含两个属性：reflectorFactory、reflector，稳住，已经很接近了
```
public class MetaClass {
private final ReflectorFactory reflectorFactory;
private final Reflector reflector;
//第一个是目标对象的 class，
//第二个是ReflectorFactory,就是在测试代码中③处创建的那个 ReflectorFactory
private MetaClass(Class<?> type, ReflectorFactory reflectorFactory) {
this.reflectorFactory = reflectorFactory;
//通过调用reflectorFactory的findForClass获取到目标类的reflector，基本获取了 reflector 就已经大功告成了，想干啥干啥了，接着再看reflectorFactory如何获取 reflector
this.reflector = reflectorFactory.findForClass(type);
}
public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory) {
return new MetaClass(type, reflectorFactory);
}
.....
```### 4.DefaultReflectorFactory中的源码
ReflectorFactory是一个接口，他的实现类是DefaultReflectorFactory中的源码
可以看到DefaultReflectorFactory 是把reflectorMap放到 ConcurrentMap 中缓存的，通过findForClass，如果ConcurrentMap中有 目标类 --> Relector 这一组，那么就返回ConcurrentMap中对应的 relector ，否则就创建 relector。
```
public class DefaultReflectorFactory implements ReflectorFactory {
private boolean classCacheEnabled = true;
private final ConcurrentMap<Class<?>, Reflector> reflectorMap = new ConcurrentHashMap<Class<?>, Reflector>();
public DefaultReflectorFactory() {
}
@Override
public boolean isClassCacheEnabled() {
return classCacheEnabled;
}
@Override
public void setClassCacheEnabled(boolean classCacheEnabled) {
this.classCacheEnabled = classCacheEnabled;
}
@Override
public Reflector findForClass(Class<?> type) {
if (classCacheEnabled) {
// synchronized (type) removed see issue #461
Reflector cached = reflectorMap.get(type);
if (cached == null) {
cached = new Reflector(type);
reflectorMap.put(type, cached);
}
return cached;
//上面这一堆 在 mybatis 其他版本的源码中这样写，和上面是一个效果
//return reflectorMap.computeIfAbsent(type, Reflector::new);
} else {
return new Reflector(type);
}
}
}
```关于 Reflector 的解读可以查看 这篇博客：https://blog.csdn.net/weixin_37139197/article/details/85119383
