纯手写实现Spring源码框架（四）refresh()刷新容器

前言
前面构建了默认工厂，扫描类，并成功扫描到文件注入进工厂当中，后面写refresh()方法中有很多无关核心部分的扩展代码，比如监听器listener，比如后置处理器，扩充工厂等其他功能，我们在这些当中主要看和实现核心代码，实例化实体和单例的实现

---

AbstractAutowireCapableBeanFactory
核心单例注入代码在this.finishBeanFactoryInitialization(beanFactory);方法中，这里面的方法都在beanFactory.preInstantiateSingletons();这里面的核心方法都来自AbstractAutowireCapableBeanFactory因此需要构建自动注入的体系
首先看看默认工厂的体系

我们先按结构新建抽象类AbstractAutowireCapableBeanFactory并让默认核心工厂DefaultListableBeanFactory继承它

public abstract class AbstractAutowireCapableBeanFactory {
}

接下来按源码进行编码
源码中首先创建了一个数组，这个数组是在我们注册bean的时候创建的

  List<String> beanNames = new ArrayList(this.beanDefinitionNames);

我们在DefaultListableBeanFactory注入的时候构建一个

private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
     this.beanDefinitionNames.add(beanName);

定义RootBeanDefinition继承自abstractBeanDefinition，RootBeanDefinition用于需要单列注入的对象转为RootBeanDefinition

//实例化时候统一管理的类
public class RootBeanDefinition extends AbstractBeanDefinition {
    RootBeanDefinition(){

    }
    public RootBeanDefinition(BeanDefinition beanDefinition) {
        super();
        setScope(beanDefinition.getScope());
        setbeanClass(beanDefinition.getbeanClass());
        setbeanClassName(beanDefinition.getbeanClassName());
        setLazyInit(beanDefinition.isLazyInit());
    }
}

按源码构建层次
AbstractBeanFactory构建

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport {
    public Object getBean(String name){
      return   doGetBean(name,null,null,false);
    };
    //doGetBean==>createBean实现
    protected <T> T doGetBean(final String beanName,final Class<T> requiredType,
                              final Object[] args, boolean typeCheckOnly) {
           //1.解析BeanName，循环的解析Bean名称
    }
}

FactoryBeanRegistrySupport 工厂Bean注入实现

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
}

DefaultSingletonBeanRegistry核心注入

public abstract class DefaultSingletonBeanRegistry implements BeanDefinitionRegistry {
}

SingletonBeanRegistry 单列Bean的定义接口

/**
 * 单列Bean的定义接口
 */
public interface SingletonBeanRegistry {
    //注册单例Bean
    void registerSingleton(String beanName, Object singletonObject);
    //获取单例Bean
    Object getSingleton(String beanName);
    //是否包含
    boolean containsSingleton(String beanName);
    //是否获取名称
    String[] getSingletonNames();
    //个数
    int getSingletonCount();
    //获取Singleton锁名
    Object getSingletonMutex();
}

重要是实现getBean方法实现DefaultSingletonBeanRegistry，现在来实现dogetBean方法

将校验和缓存放入核心单列注入类DefaultSingletonBeanRegistry

public  class DefaultSingletonBeanRegistry  implements SingletonBeanRegistry {
    // 定义缓存注册的bean定义及对应beanName容器
    private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(32);
    /** 存储带有实例+原来对象注入的缓存 */
    protected final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /** 存储缓存创建beanName对应实例的工厂对象的缓存 */
    protected final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /** 存储带有实例，但是依赖对象没有注入的缓存*/
    protected final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

    /** Set of registered singletons, containing the bean names in registration order. */
    protected final Set<String> registeredSingletons = new LinkedHashSet<>(256);

    /** 当前正在创建Bean的检查 beforeSingletonCreation方法中使用*/
    protected final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));
    /** 记录排除创建Bean的检查 beforeSingletonCreation方法中使用*/
    private final Set<String> inCreationCheckExclusions =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));
    @Override
    public void registerSingleton(String beanName, Object singletonObject) {

    }

    @Override
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }

    @Override
    public boolean containsSingleton(String beanName) {
        return false;
    }

    @Override
    public String[] getSingletonNames() {
        return new String[0];
    }

    @Override
    public int getSingletonCount() {
        return 0;
    }

    @Override
    public Object getSingletonMutex() {
        return null;
    }

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
    protected BeanDefinition getBeanDefinition(String beanName) {
        return this.beanDefinitionMap.get(beanName);
    }

    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {

    }

    public boolean containsBeanDefinition(String beanName) {
        return false;
    }

    /**
     * 准备操作加入正在创建Bean缓存
     * @param beanName
     * @param singletonFactory
     * @return
     */
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                //添加进singletonsCurrentlyInCreation正在创建Bean队列中
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;

                try {
                    /**
                     * getBean的时候会回调这个匿名方法
                     * () -> {
                     *                         try {
                     *                             //创建Bean
                     *                             return createBean(beanName, mbd, args);
                     *                         } catch (Exception ex) {
                     *                             // Explicitly remove instance from singleton cache: It might have been put there
                     *                             // eagerly by the creation process, to allow for circular reference resolution.
                     *                             // Also remove any beans that received a temporary reference to the bean.
                     *                             //如果出现了异常需要把校验缓存移除掉
                     *                             destroySingleton(beanName);
                     *                             throw ex;
                     *                         }
                     *                     }
                     */
                    singletonObject = singletonFactory.getObject();
                    //设置标识为新对象
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    //如果出现了异常，拿出来设置为空
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw ex;
                    }
                }
                finally {
                    //移除进singletonsCurrentlyInCreation正在创建Bean队列中
                    //表示创建完成
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    /**
                     *      放入缓存
                     *      synchronized (this.singletonObjects) {
                     *             // 完整单例对象存储到一级缓存
                     *             this.singletonObjects.put(beanName, singletonObject);
                     *             // 从三级缓存移除
                     *             this.singletonFactories.remove(beanName);
                     *             // 从二级缓存中移除
                     *             this.earlySingletonObjects.remove(beanName);
                     *             // 存储刚刚创建实例对应beanName
                     *             this.registeredSingletons.add(beanName);
                     *         }
                     */
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

    protected void beforeSingletonCreation(String beanName) {
        //1.检验是否正在的创建Bean。2.检验是否正在创建
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new RuntimeException("创建Bean的时候出现了并非创建Bean");
        }
    }

    protected void afterSingletonCreation(String beanName) {
        //1.是否是需要创建的Beawn，2.检验是否能有移除，不能则说明数据已经结束
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
            throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
        }
    }

    public boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonsCurrentlyInCreation.contains(beanName);
    }

    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            // 完整单例对象存储到一级缓存
            this.singletonObjects.put(beanName, singletonObject);
            // 从三级缓存移除
            this.singletonFactories.remove(beanName);
            // 从二级缓存中移除
            this.earlySingletonObjects.remove(beanName);
            // 存储刚刚创建实例对应beanName
            this.registeredSingletons.add(beanName);
        }
    }

    /**
     * 清空当前beanName在容器所有的缓存
     * @param beanName
     */
    protected void removeSingleton(String beanName) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.remove(beanName);
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.remove(beanName);
        }
    }
}

AbstractBeanFactory 抽象类核心实现GetBean

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport {
    /** Names of beans that have already been created at least once. */
    //准备创建表示缓存
    //Collections提供了一种保证元素唯一性的Map实现，就是用一个Set来表示Map，它持有这个Map的引用，并且保持Map的顺序、并发和性能特征。这就是newSetFromMap方法：
    private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
    public Object getBean(String name){
      return   doGetBean(name,null,null,false);
    };
    protected <T> T doGetBean(final String beanName,final Class<T> requiredType,
                              final Object[] args, boolean typeCheckOnly) {
        Object bean = null;
        /**
         *     获取缓存中存储的与当前beanName对应实例
         *     private Object getObjectForBeanInstance(Object sharedInstance, String beanName, Object o) {
         *         // 扩展基于FactoryBean实例方式
         *         return sharedInstance;
         *     }
         */
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            //源代码这里是工厂实例化校验我们直接返回Bean就行
            bean = getObjectForBeanInstance(sharedInstance, beanName, null);
        }
        else {
            if (!typeCheckOnly) {
                //标记当前BeanName正在被构建
                markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 根据bean定义作用域类型来创建实例
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            //创建Bean
                            return createBean(beanName, mbd, args);
                        } catch (Exception ex) {
                            // Explicitly remove instance from singleton cache: It might have been put there
                            // eagerly by the creation process, to allow for circular reference resolution.
                            // Also remove any beans that received a temporary reference to the bean.
                            //如果出现了异常需要把校验缓存移除掉
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    //源代码这里是工厂实例化校验我们直接返回Bean就行
                    bean = getObjectForBeanInstance(sharedInstance, beanName, mbd);
                } else if (mbd.isPrototype()) {
                          //是否多列，这里我们不写，只写主流单列
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        return (T) bean;
    }

    private void destroySingleton(String beanName) {
        removeSingleton(beanName);
    }
    public RootBeanDefinition getMergedLocalBeanDefinition(String beanName) {
        // 获取beanName对应Bean定义对象
        BeanDefinition beanDefinition = getBeanDefinition(beanName);
        return new RootBeanDefinition(beanDefinition);
    }
    protected abstract BeanDefinition getBeanDefinition(String beanName);

    /**
     * 标记beanName被创建方法
     * @param beanName
     */
    private void markBeanAsCreated(String beanName) {
        // 双端校验锁
        if (!this.alreadyCreated.contains(beanName)) {
            synchronized (this.alreadyCreated) {
                if (!this.alreadyCreated.contains(beanName)) {
                    this.alreadyCreated.add(beanName);
                }
            }
        }
    }

    private Object getObjectForBeanInstance(Object sharedInstance, String beanName, Object o) {
        // 扩展基于FactoryBean实例方式
        return sharedInstance;
    }

    @Override
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }
    //三级缓存
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
}

这里面CreateBean还没实现，这个属性AutowireCapableBeanFactory体系先构建这个体系

就旁支了一个接口继承Bean定义，在抽象类中具体实现docreateBean方法

实现过程中，出现了一个BeanWrapper，包装前和包装后的对象，用于实现代理方法。
这里面越写越复杂，我们直接中docreateBean方法用的2个方法getWrappedInstance和getWrappedClass

BeanWrapper 接口实现

public interface BeanWrapper {
    /**
 * Return the bean instance wrapped by this object.
 */
 Object getWrappedInstance();

    /**
     * Return the type of the wrapped bean instance.
     */
    Class<?> getWrappedClass();
}

BeanWrapperImpl 实现

public class BeanWrapperImpl implements  BeanWrapper{
    private Class<?> wrapperClass;
    private Object wrapperInstance;
    public BeanWrapperImpl(Object wrapperInstance) {
        this.wrapperClass = wrapperInstance.getClass();
        this.wrapperInstance = wrapperInstance;
    }
    @Override
    public Object getWrappedInstance() {
        return this.wrapperInstance;
    }
    @Override
    public Class<?> getWrappedClass() {
        return this.wrapperClass;
    }
}

完成docreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // Instantiate t bean.
        BeanWrapper instanceWrapper = null;
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            //源码中有判断了一次重新设置，我们直接重新设置
            mbd.setbeanClass(beanType);
        }
        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        //是否允许循环依赖
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            //存储Bean工厂
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            // 完成bean的依赖注入
            populateBean(beanName, mbd, instanceWrapper);
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return exposedObject;
    }

实例化成功

总结
现在还差单例的实例化缓存注入和注入容器。里面有些接口自动生成方法的地方我就没有写进去了。三级工厂的代码列在哪里了因为还没有完全实例化，下一篇写吧。
这篇主要是去构建AutowireCapableBeanFactory和核心注入工厂DefaultSingletonBeanRegistry，其中AutowireCapableBeanFactory主要是整个doCreateBean操作，DefaultSingletonBeanRegistry是做准备数据校验。

百度云：https://pan.baidu.com/s/1W80Alkg88XOX4ZxM76u4cQ
密码：ouig