目标完成对Spring体系的全面深入深深入 透彻理解 输出培训

第一天 0226

确立了两条主线
1.源码 http://cmsblogs.com/?tag=spring%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90
2.书《Spring实战》《Spring源码》
完成了对spring IoC，AOP，模板消除样板式代码的深入理解
Spring IoC五大体系：1.Resource体系，对资源的抽象和访问策略的定义 2.BeanFactory 体系 3.BeanDefinition 体系 4.BeanDefinitionReader 体系 5.ApplicationContext 体系

第二天 0227

Resource体系 统一资源加载策略
Bean装配的自动装配、Java配置、XML配置

第三天 0228##

Bean的高级装配……
beanDefinition

image.png

第四天 0301##

我知道有个人在看，不知道昨天没有更新有没有不开心
面向切面的spring AspectJ的重要性
Spring解析XMl具体标签的方式

第五天 0304##

bean的加载
"in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."

第六天 0305##

在死磕bean加载过程源码

第七天 0306##

在死磕bean加载过程源码 循环依赖的解决

第八天 0310##

各种原因被打断了几天，今天好好看看
有点难啃 没有啃完 感觉见到曙光了

第九天 0311##

createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) 方法，用于实例化 Bean 对象。它会根据不同情况，选择不同的实例化策略来完成 Bean 的初始化，主要包括：

Supplier 回调：#obtainFromSupplier(final String beanName, final RootBeanDefinition mbd) 方法。
工厂方法初始化：#instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) 方法。
构造函数自动注入初始化：#autowireConstructor(final String beanName, final RootBeanDefinition mbd, Constructor<?>[] chosenCtors, final Object[] explicitArgs) 方法。
默认构造函数注入：#instantiateBean(final String beanName, final RootBeanDefinition mbd) 方法。

远比我想想的复杂难懂的多……不是谁都可以随随便便的做出精品的……认真的研读的时候，你会发现死磕这两个字 真他妈真切

第十天0312##

很高兴 我今天完成了第一个阶段的学习：总结以下问题：
1.单例模式在解决循环依赖的时候为什么要采用三级缓存，第三级缓存采用ObjectFactory的方式是为了解决什么问题？

/** Cache of singleton factories: bean name to ObjectFactory.
     *
     * 存放的是 ObjectFactory，可以理解为创建单例 bean 的 factory，对应关系是 bean name --> ObjectFactory
     *
     */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

final Object bean = instanceWrapper.getWrappedInstance();
// 提前将创建的 bean 实例的工厂 加入到 singletonFactories （三级缓存）中
            // 这里是为了后期避免循环依赖
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

/**
     * Add the given singleton factory for building the specified singleton
     * if necessary.
     * <p>To be called for eager registration of singletons, e.g. to be able to
     * resolve circular references.
     * @param beanName the name of the bean
     * @param singletonFactory the factory for the singleton object
     */
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

/**
     * Obtain a reference for early access to the specified bean,
     * typically for the purpose of resolving a circular reference.
     * @param beanName the name of the bean (for error handling purposes)
     * @param mbd the merged bean definition for the bean
     * @param bean the raw bean instance
     * @return the object to expose as bean reference
     */
    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }
        return exposedObject;
    }

2.第二级缓存返回的是否为BeanWrapper，这个BeanWrapper是什么概念？

    /** Cache of early singleton objects: bean name to bean instance.
     *
     * 存放的是早期的 bean，对应关系也是 bean name --> bean instance。
     * 它与 singletonObjects 区别在于 earlySingletonObjects 中存放的 bean 不一定是完整的，
     * 从上面过程中我们可以了解，bean 在创建过程中就已经加入到 earlySingletonObjects 中了，
     * 所以当在 bean 的创建过程中就可以通过 getBean() 方法获取。
     *
     * 这个 Map 也是解决【循环依赖】的关键所在。
     *
     */
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

一级缓存：

    /** Cache of singleton objects: bean name to bean instance.
     *  存放的是单例 bean 的映射。
     *  对应关系为 bean name --> bean instance
     */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

第一个问题中提到的，程序首先尝试从一级缓存“singletonObjects”中获取实例（这里面获取的实例实际上是已经创建完成的实例），如果获取不到，这尝试冲二级缓存“earlySingletonObjects”中获取（这里存放的是未完成创建的BeanWrapper），如果仍然获取不到，则尝试从三级缓存“singletonFactories”中获取一个ObjectFactory然后调用这个ObjectFactory的getObject方法来创建bean，并放到二级缓存中，并将ObjectFactory从三级缓存中remove掉。

3.怎样深度理解这三个过程a.实例化（createBeanInstance）b.填充属性（popularBean）c.初始化（initializeBean）?
4.getObjectForBeanInstance()的作用
5.aware的使用场景及具体实现
6.post-process的使用场景及具体实现
7.createBeanWrapper的supplier回调实现方式
8.怎样保证了线程安全的单例Bean
在bean创建的时候首先将bean注册到 DefaultSingletonBeanRegistry
/** Names of beans currently excluded from in creation checks. */
private final Set<String> inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
中；
依赖Bean在进行getObjectFromFactoryBean 中的 object = doGetObjectFromFactoryBean(factory, beanName);操作时，使用了FactoryBean的指定方法
我预计在完成framwork前 来详细解答这8个问题

近来的spring研究让我有一点点小兴奋

第11天0313##

今天好累
大体整理一下思路接下来需要完成springFramework的整体深度架构到细节的研究---->然后是web部分springmvc---->然后是springBoot---->然后是springCloud、springDataFlow；计划于4.30前全部完成

12 0314##

LoadTimeWeaverAware：加载Spring Bean时织入第三方模块，如AspectJ
BeanClassLoaderAware：加载Spring Bean的类加载器
BootstrapContextAware：资源适配器BootstrapContext，如JCA,CCI
ResourceLoaderAware：底层访问资源的加载器
BeanFactoryAware：声明BeanFactory
PortletConfigAware：PortletConfig
PortletContextAware：PortletContext
ServletConfigAware：ServletConfig
ServletContextAware：ServletContext
MessageSourceAware：国际化
ApplicationEventPublisherAware：应用事件
NotificationPublisherAware：JMX通知
BeanNameAware：声明Spring Bean的名字

我们始终需要注意的是 BeanFactoryPostProcessor 是与 BeanDefinition 打交道的，如果想要与 Bean 打交道，请使用 BeanPostProcessor 。

12 0315##

Bean 的转换过程

image.png

ApplicationContext 的架构图

image.png
load BeanDefinition 的全流程
image.png

get Bean 的全流程

image.png

接下来我将用两天时间系统梳理一下
下周一3.18 我将召开小组技术讨论会，深入讨论一些深度细节问题

13 0316##

日本旅行刷新认知

14 0326##

回归死磕源码系列

15 0330##

回答8个核心问题

写在最后，完成我的第一个阶段的笔记：
一句话总结spring解决循环依赖的问题：通过spring容器，提前暴露刚完成构造器注入，但是未完成其他步骤（不如setter注入）的bean来完成的，而且只能解决单例bean作用域的bean循环依赖。通过提前暴露一个工程方法从而使其他bean能够引用到该bean。