spring源码解析-循环依赖

讲解内容：

• spring的循环依赖---属性注入--自动注入
• spring bean的生命周期
• spring bean实例化的过程
• spring循环依赖

讲解模式

• 打断点，一步一步走过spring bean循环依赖解决过程。由于spring 创建bean过程繁杂，重要的代码会讲解，不重要的忽略。自动注入也是个重点，后面文章会再次讲解到。
• 本笔记是个人学习子路老师的课程所做的，有兴趣的可以去看看他的课，讲的更好

带着问题学习

问题1：spring当中的循环依赖如何解决的
问题2：spring当中怎么支持循环依赖的
回答：
spring中的AbstractAutowireBeanFactory类里面有个变量allowCircularRefrence=true这是设置是否支持循环依赖的参数，在么个bean创建的过程中，都会进行判断。可以通过启动类中的

public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
        AbstractAutowireCapableBeanFactory acb = ac.getDefaultListableBeanFactory();
        acb.setAllowCircularReferences(false);
        ac.register(Test.class);
        ac.refresh();
        ac.getBean(IndexService.class).getService();
    }

或者修改源码，在AnnotationConfigApplicationContext类中直接

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
        this();
        setAllowCircularReference(false);
        register(annotatedClasses);
        refresh();
    }

问题3：如何证明spring默认支持循环依赖（源码细节）
问题4：对spring源码有什么了解吗？（可以回答一个IOC或者AOP即可）
问题5：对spring源码深入研究，可以进行二次扩展吗？（直接继承BeanFactoryPostProcess类）

public class ZbBeanFactoryPostProcess implements BeanFactoryPostProcessor {
    //这里的factory中调用的所有对象都是二级缓存中的，在加载到三级缓存中之前会调用用户自己写的扩展类。
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
//      GenericBeanDefinition是BeanDefinition的子类，子类具有更多的实现，rootBeanDefinition也是BeanDefinition的子类
        GenericBeanDefinition  userService = (GenericBeanDefinition)configurableListableBeanFactory.getBeanDefinition("userService");
        userService.setScope("");
        userService.setBeanClassName("XXX");
    }
}

问题6：如何关闭单例循环依赖
启动类中AnnotationConfigApplicationContext.java的构造方法中添加setAllowCircularReference（false即可）

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    this();
    setAllowCircularReference(false);
    register(annotatedClasses);
    refresh();
}

问题7：@Autowired和@Source有什么不一样
回答：在bea初始化的时候bean注入各种属性的时候，处理他们的后置处理器不一样
问题：如何解决循环依赖>>>依赖注入功能>>>初始化完成依赖注入>{
1、初始化bean ------ b
}

问题：循环依赖的过程
回答：
getBean() ------index object --------注入UserService-----getBean(UserService) ---从容器中拿（三级缓存）-----拿不到----判断是否需要第三个缓存中拿------开始new Userservice-----object UserService --------注入index----从容器中拿getBean(Index)-----index不等于nulll,注入半成品index---创建userservice .

问题：spring bean声明周期如何完成依赖注入的呢？

问题：spring bean的产生过程，bean是如何产生的

现有class--beanDefinition(类)------object（bean）

spring懒加载，在类上面直接使用注解@Lazy(true)，表明这个类在初始化的时候不加载，到用到的时候才会去加载

注意：
bean----------spring bean
java对象-----对象

spring bean创建过程简单概述

先过过眼，具体内容后面详细讲解，这里有个大概印象
getBean() ------index object --------注入UserService-----getBean(UserService) ---从容器中拿（三级缓存）-----拿不到----判断是否需要第三个缓存中拿------开始new Userservice-----object UserService --------注入index----从容器中拿getBean(Index)-----index不等于nulll,注入半成品index---创建userservice .

文字描述

• 实例化一个ApplicationContext的对象；
• 调用bean工厂后置处理器完成扫描；
• 循环解析扫描出来的类信息；
• 实例化一个BeanDefinition对象来存储解析出来的信息；
• 把实例化好的beanDefinition对象put到beanDefinitionMap当中缓存起来，以便后面实例化bean；
• 再次调用bean工厂后置处理器；
• 当然spring还会干很多事情，比如国际化，比如注册BeanPostProcessor等等，如果我们只关心如何实例化一个bean的话那么这一步就是spring调用finishBeanFactoryInitialization方法来实例化单例的bean，实例化之前spring要做验证，需要遍历所有扫描出来的类，依次判断这个bean是否Lazy，是否prototype，是否abstract等等；
• 如果验证完成spring在实例化一个bean之前需要推断构造方法，因为spring实例化对象是通过构造方法反射，故而需要知道用哪个构造方法；
• 推断完构造方法之后spring调用构造方法反射实例化一个对象；注意我这里说的是对象、对象、对象；这个时候对象已经实例化出来了，但是并不是一个完整的bean，最简单的体现是这个时候实例化出来的对象属性是没有注入，所以不是一个完整的bean；
• spring处理合并后的beanDefinition(合并？是spring当中非常重要的一块内容，后面的文章我会分析)；
• 判断是否支持循环依赖，如果支持则提前把一个工厂存入singletonFactories——map；
• 判断是否需要完成属性注入
• 如果需要完成属性注入，则开始注入属性
• 判断bean的类型回调Aware接口
• 调用生命周期回调方法
• 如果需要代理则完成代理
• put到单例池——bean完成——存在spring容器当中

对象的创建过程

1、scan扫描类
2、parse解析，利用for循环对所有遍历的类进行解析,设置类的名称，父类，单例还是原型等等。

for (){
    GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
    genericBeanDefinition.setBeanClassName("XXX");
    genericBeanDefinition.setBeanClass("XXXX.class");
    genericBeanDefinition.setScope("prototytype"
    .......
    //放入到一级缓存中
    map.put("XXXX");
    list.add(xxxx)
}

3、调用扩展，
遍历map validate校验类中是否符合各种规则
然后符合就直接new了。

开启spring循环依赖讲解

循环依赖样例

UserService.java

package test.service;/**
 * Created by zhanbei on 2020/12/6.
 */
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserService {
    @Autowired
    private IndexService indexService;

    public UserService(){
        System.out.println("UserService start");
    }

}

IndexService.java

package test.service;/**
 * Created by zhanbei on 2020/12/6.
 */

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class IndexService {

    @Autowired
    private UserService userService;

    public IndexService(){
        System.out.println("IndexServicde started");
    }
    public String getService(){
        return "IndexService";
    }
}

bean的实例化生命周期

1、启动类中调用的AnnotationConfigApplicationContext类

@Lazy(true)
public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Test.class);
        ac.getBean(IndexService.class).getService();
    }
}

在这里可以做很多事情，可以关闭循环依赖等等，只要在ac.refresh()方法执行之前，可以修改很多spring内部的东西。如下

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
        AbstractAutowireCapableBeanFactory acb = ac.getDefaultListableBeanFactory();
        //可以在这里关闭循环依赖
        acb.setAllowCircularReferences(false);
        ac.register(Test.class);
        ac.refresh();
        ac.getBean(IndexService.class).getService();
    }

2、AnnotationConfigApplicationContext类中主要代码，主要构件bean生命周期的是refresh()方法

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    this();
        //也可以在这关闭循环依赖，这里是我个人手动修改的spring源码
    setAllowCircularReference(false);
    register(annotatedClasses);
    refresh();
}

3、refresh方法里才是整个bean生命周期开始的地方，准确的开始地方，后面会讲解（refresh在spring-context-5.1.13.RELEASE.jar.org.springframework.context.support.AbstractApplicationContext.class中）

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();
        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);
        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);
            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);
            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);
            // Initialize message source for this context.
            initMessageSource();
            // Initialize event multicaster for this context.
            initApplicationEventMulticaster();
            // Initialize other special beans in specific context subclasses.
            onRefresh();
            // Check for listener beans and register them.
            registerListeners();
            // Instantiate all remaining (non-lazy-init) singletons.
            //调用finishBeanFactoryInitialization方法实例化所有扫描出来的类
            //spring在AbstractApplicationContext#finishBeanFactoryInitialization方法中完成了bean的实例化。这点需要记住
            finishBeanFactoryInitialization(beanFactory);
            // Last step: publish corresponding event.
            finishRefresh();
        }
        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();
            // Reset 'active' flag.
            cancelRefresh(ex);
            // Propagate exception to caller.
            throw ex;
        }
        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

3.1、finishBeanFactoryInitialization方法中调用preInstantiateSingletons初始化扫描出来的类。

**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
*/
rotected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }
    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }
    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }
    // Stop using the temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(null);
    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration();
    // Instantiate all remaining (non-lazy-init) singletons.
    beanFactory.preInstantiateSingletons(); 
}

3.2、preInstantiateSingletons方法会经过一系列的判断之后，调用getBean方法区实例化扫描出来的类
preInstantiateSingletons位于（spring-beans-5.1.13.RELEASE.jar.org.springframework.beans.factory.support.DefaultListableBeanFactory.class）

@Override
public void preInstantiateSingletons() throws BeansException {
    if (logger.isDebugEnabled()) {
        logger.debug("Pre-instantiating singletons in " + this);
    }
    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    List beanNames = new ArrayList<>(this.beanDefinitionNames);
    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean factory = (FactoryBean) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                        ((SmartFactoryBean) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }
    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction