2.4.2.创建 Reflector 对象的工厂 ReflectoryFactory

用于生成Reflector对象的ReflectorFactory工厂我们在构建XMLConfigBuilder的过程中提到过，他在XMLConfigBuilder中被硬编码为DefaultReflectorFactory。

/**
 * 用于创建{@link org.apache.ibatis.reflection.Reflector}对象的工厂
 */
 private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

ReflectorFactory也是工厂模式的一个实现，顾名思义,它用于获取指定类的Reflector对象，它定义了三个方法:

/**
 * 反射工厂，用于为指定类(读取)创建Reflector对象
 */
public interface ReflectorFactory {

    /**
     * 是否开启了缓存
     */
    boolean isClassCacheEnabled();

    /**
     * 设置是否启用缓存
     */
    void setClassCacheEnabled(boolean classCacheEnabled);

    /**
     * 获取指定类的缓存信息
     */
    Reflector findForClass(Class<?> type);
}

其默认实现是DefaultReflectorFactory:

/**
 * 默认的Reflector创建工厂
 */
public class DefaultReflectorFactory implements ReflectorFactory {
    /**
     * 默认开启了缓存功能
     */
    private boolean classCacheEnabled = true;

    /**
     * 线程安全的缓存实现
     */
    private final ConcurrentMap<Class<?>, Reflector> reflectorMap = new ConcurrentHashMap<>();

    public DefaultReflectorFactory() {
    }

    /**
     * @return 是否启用缓存
     */
    @Override
    public boolean isClassCacheEnabled() {
        return classCacheEnabled;
    }

    /**
     * 更新缓存
     *
     * @param classCacheEnabled 是否启用缓存
     */
    @Override
    public void setClassCacheEnabled(boolean classCacheEnabled) {
        this.classCacheEnabled = classCacheEnabled;
    }

    @Override
    public Reflector findForClass(Class<?> type) {
        if (classCacheEnabled) {
            //从缓存获取指定类的Reflector，如果不存在，则创建并保存。
            // synchronized (type) removed see issue #461
            return reflectorMap.computeIfAbsent(type, Reflector::new);
        } else {
            // 每次都新建Reflector对象
            return new Reflector(type);
        }
    }
}

ReflectorFactory中比较核心的方法是findForClass：

/**
 * 获取指定类的缓存信息
 */
Reflector findForClass(Class<?> type);

该方法可以为指定的类创建一个Reflector对象，DefaultReflectorFactory对该方法的实现比较简单，只是简单的包裹了一层缓存实现，具体的Reflector对象的创建工作其实是由Reflector类的构造方法来完成的。

@Override
public Reflector findForClass(Class<?> type) {
    if (classCacheEnabled) {
        //从缓存获取指定类的Reflector，如果不存在，则创建并保存。
        // synchronized (type) removed see issue #461
        return reflectorMap.computeIfAbsent(type, Reflector::new);
    } else {
        // 每次都新建Reflector对象
        return new Reflector(type);
    }
}