Spring Ioc

qingsongxyz

已于 2022-09-09 21:09:44 修改

阅读量344

点赞数

分类专栏： Spring 文章标签： java spring intellij-idea

于 2022-04-09 16:28:21 首次发布

本文链接：https://blog.csdn.net/qingsongxyz/article/details/124063088

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spring IoC

一、Spring Ioc 和 DI

Spring IoC(Inversion of Control)，即控制反转，是一种设计思想，是将对象交给Ioc容器创建，而不需要自己手动创建，降低了程序的耦合度。

DI(Dependency Injection)，即依赖注入，是Ioc的一种实现方式，注入对象所需的对象、资源、数据。

二、DI(依赖注入)的三种方式

1.构造方法注入（Constructor)

对以下对象进行依赖注入:

package com.qingsongxyz.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {

    private String name;

    private String age;

    private String gender;
}

name属性对应构造函数参数名，value为注入的值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="user" class="com.qingsongxyz.pojo.User">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="18"/>
        <constructor-arg name="gender" value="男"/>
    </bean>
</beans>

也可以使用index对应构造函数的参数

<bean id="user" class="com.qingsongxyz.pojo.User">
    <constructor-arg index="0" value="张三"/>
    <constructor-arg index="1" value="18"/>
    <constructor-arg index="2" value="男"/>
</bean>

扩展: c命名空间注入

//需要添加c命名空间xmlns:c="http://www.springframework.org/schema/c"
<bean id="user" class="com.qingsongxyz.pojo.User" c:name="张三" c:age="18" c:gender="男"/>
//使用构造器对应下标
<bean id="user" class="com.qingsongxyz.pojo.User" c:_0="张三" c:_1="18" c:_2="男"/>

2.setter方式注入

使用property进行set注入，该类需要提供相应参数的setXXX()方法

<bean class="com.qingsongxyz.pojo.User">
    <property name="name" value="张三"/>
    <property name="age" value="18"/>
    <property name="gender" value="男"/>
</bean>

特殊类型属性注入:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Various {
    private Person person;
    private int[] number;
    private List<String> school;
    private Map<String, Float> grade;
}

<bean id="person" class="com.qingsongxyz.pojo.Person"></bean>

<bean id="various" class="com.qingsongxyz.pojo.Various">
    <!--引用类型注入-->
    <property name="person" ref="person"/>    
    <!--数组注入-->
    <property name="number">
        <array>
            <value>1</value>
            <value>2</value>
            <value>3</value>
            <value>4</value>
            <value>5</value>
        </array>
    </property>
    
    <!--List注入-->
    <property name="school">
        <list>
            <value>"湖北大学"</value>
            <value>"武汉大学"</value>
        </list>
    </property>
    
    <!--Map注入-->
    <property name="grade">
        <map>
            <entry key="语文" value="90"/>
            <entry key="数学" value="60"/>
            <entry key="英语" value="100"/>
        </map>
    </property>
</bean>

扩展: p命名空间注入

//需要添加p命名空间xmlns:p="http://www.springframework.org/schema/p"
<bean id="user" class="com.qingsongxyz.pojo.User" p:name="张三" p:age="18" p:gender="男"/>

3.注解注入

使用@Autowired、@Resource、@Inject进行注入

注意:官方推荐使用构造器注入方式，能够保证注入的组件不可变，并且确保需要的依赖不为空(避免空指针的情况)!

循环依赖：使用字段注入可能会导致循环依赖，即A里面注入B，B里面又注入A:

public class A {
    @Autowired
    private B b;
}

public class B {
    @Autowired
    private A a;
}

使用构造器注入，在spring项目启动的时候，就会抛出BeanCurrentlyInCreationException异常从而提醒你避免循环依赖，如果是字段注入的话，启动的时候不会报错，在使用那个bean的时候才会报错。

测试:

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = context.getBean("user", User.class);
    System.out.println(user);
    //User(name=张三, age=18, gender=男)
}

三、Bean的范围

在xml中配置Bean的时候声明scope

<!--scope默认为singleton-->
<bean id="user" class="com.qingsongxyz.pojo.User" scope="singleton">

*1.singleton

Spring创建对象默认为单例范围(singleton)，在IoC容器中只创建一个该类的实例

*2.prototype

原型范围，每次需要该对象都创建一个新的对象实例

3.request

HTTP 请求的request范围

4.session

HTTP 请求的session范围

5.application

HTTP 请求的application范围

5.websocket

websocket范围

四、懒加载、初始化方法和销毁方法

<bean id="user" class="com.qingsongxyz.pojo.User" lazy-init="true">

lazy-init默认为false，当设置懒加载时，只有使用该对象时才创建该对象，可以减少内存消耗

public class MyBean {
    
    public void init(){
        System.out.println("MyBean的init()执行...");
    }
    
    public void destroyMethod(){
        System.out.println("MyBean的destroy()执行...");
    }
}

<bean id="bean" class="com.qingsongxyz.pojo.MyBean" init-method="init" destroy-method="destroyMethod"/>

当初始化bean对象时触发init-method方法，销毁对象时触发destroy-method方法

测试:

    @Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    MyBean bean = context.getBean("bean", MyBean.class);
    //关闭上下文,销毁bean
    ((ClassPathXmlApplicationContext)context).close();
    //MyBean的init()执行...
    //MyBean的destroy()执行...
}

五、工厂方法创建Bean的实例

Dog类

package com.qingsongxyz.autowire;

public class Dog {
    private String name;

    public void bark()
    {
        System.out.println("小狗" + name + "汪汪叫~");
    }

    public Dog() {
    }

    public Dog(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

首先创建工厂类

package com.qingsongxyz.factory;

import com.qingsongxyz.autowire.Dog;

public class DogFactory {

    /**
     * 静态工厂方法
     * @return
     */
    public static Dog createDog(){
        return new Dog("大黄");
    }

    /**
     * 实例工厂方法
     * @return
     */
    public Dog createDogInstance(){
        return new Dog("小白");
    }
}

<!--静态工厂方法创建对象实例-->
<bean id="yellowDog" class="com.qingsongxyz.factory.DogFactory" factory-method="createDog"/>

<!--实例工厂方法创建对象实例-->
<bean id="dogFactory" class="com.qingsongxyz.factory.DogFactory"/>
<bean id="whiteDog" factory-bean="dogFactory" factory-method="createDogInstance"/>

测试:

@Test
public void factoryTest(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Dog yellowDog = context.getBean("yellowDog", Dog.class);
    System.out.println(yellowDog.getName()); //大黄
    
    Dog whiteDog = context.getBean("whiteDog", Dog.class);
    System.out.println(whiteDog.getName());  //小白
}

六、基于java配置Spring

package com.qingsongxyz.hello;

@NoArgsConstructor
@AllArgsConstructor
@Data
public class Hello {
    private String str;

    public void show()
    {
        System.out.println("Hello world!");
    }
}

import com.hubu.hello.Hello;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Config {
    @Bean
    public Hello getHello()
    {
        return new Hello("Hello world!!!");
    }
}

测试：

@Test
public void Test()
{
    ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
    Hello getHello = context.getBean("getHello", Hello.class);
    System.out.println(getHello); //Hello world!!!
}

@Configuration用于定义配置类，替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

七、Bean的生命周期

1.spring启动源码分析

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

ClassPathXmlApplicationContext 继承树：

在这里插入图片描述

ClassPathXmlApplicationContext:
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
   this(new String[] {configLocation}, true, null);
}

ClassPathXmlApplicationContext:
//refresh = true parent = null
public ClassPathXmlApplicationContext(
    String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
    throws BeansException {

    super(parent); //调用父类AbstractXmlApplicationContext构造器
    setConfigLocations(configLocations); //保存配置文件名称
    if (refresh) {
        refresh(); //刷新上下文 (核心方法)
    }
}

AbstractRefreshableConfigApplicationContext:
private String[] configLocations; //保存传入参数(配置文件的名称)

public void setConfigLocations(@Nullable String... locations) {
    if (locations != null) {
        Assert.noNullElements(locations, "Config locations must not be null");
        this.configLocations = new String[locations.length]; 
        //循环遍历传入的参数 配置文件 依次保存起来
        for (int i = 0; i < locations.length; i++) {
            this.configLocations[i] = resolvePath(locations[i]).trim();
        }
    }
    else {
        this.configLocations = null;
    }
}

AbstractXmlApplicationContext:
public AbstractXmlApplicationContext(@Nullable ApplicationContext parent) {
    super(parent); //调用父类AbstractRefreshableConfigApplicationContext构造器
}

AbstractRefreshableConfigApplicationContext:
public AbstractRefreshableConfigApplicationContext(@Nullable ApplicationContext parent) {
    super(parent); //调用父类AbstractRefreshableApplicationContext构造器
}

AbstractRefreshableApplicationContext:
public AbstractRefreshableApplicationContext(@Nullable ApplicationContext parent) {
    super(parent); //调用父类AbstractApplicationContext构造器
}

AbstractApplicationContext:
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
    this(); //调用本类的无参构造器 
    setParent(parent); //如果存在父容器 进行相应的配置
}

AbstractApplicationContext:
public AbstractApplicationContext() {
 	//创建资源模式处理器
    this.resourcePatternResolver = getResourcePatternResolver();
}

protected ResourcePatternResolver getResourcePatternResolver() {
    return new PathMatchingResourcePatternResolver(this);
}

AbstractApplicationContext:
//parent = null
public void setParent(@Nullable ApplicationContext parent) {
    this.parent = parent;
    if (parent != null) {
        Environment parentEnvironment = parent.getEnvironment();
        if (parentEnvironment instanceof ConfigurableEnvironment) {
            getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
        }
    }
}

核心方法refresh：

public void refresh() throws BeansException, IllegalStateException {
   //同步代码块 确保同一时间只能有一个线程进行刷新操作
   synchronized (this.startupShutdownMonitor) {
      StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

      //完成刷新容器前的准备工作
      prepareRefresh();

      //获取新的容器,配置属性信息
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      //准备容器
      prepareBeanFactory(beanFactory);

      try {
         //空函数 供子类定义BeanFactoryPostProcessor
         postProcessBeanFactory(beanFactory);

         StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
         
         //执行BeanFactoryPostProcessor
         invokeBeanFactoryPostProcessors(beanFactory);

         //注册BeanPostProcessors
         registerBeanPostProcessors(beanFactory);
         beanPostProcess.end();

         //初始化消息源
         initMessageSource();

         //初始化事件多播器
         initApplicationEventMulticaster();

         //空函数 供子类扩展
         onRefresh();

         //注册监听器
         registerListeners();

         //实例化所有单例bean
         finishBeanFactoryInitialization(beanFactory);

         //完成刷新操作
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         //销毁已经创建的bean
         destroyBeans();

         //设置容器开启位为false
         cancelRefresh(ex);

         //抛出异常
         throw ex;
      }

      finally {
         //清空缓存
         resetCommonCaches();
         //关闭StartupStep
         contextRefresh.end();
      }
   }
}

prepareRefresh() ：

protected void prepareRefresh() {
   //保存启动时间 
   this.startupDate = System.currentTimeMillis();
   //设置容器关闭位为false
   this.closed.set(false);
   //设置容器开启位为true 
   this.active.set(true);

   if (logger.isDebugEnabled()) {
      if (logger.isTraceEnabled()) {
         logger.trace("Refreshing " + this);
      }
      else {
         logger.debug("Refreshing " + getDisplayName());
      }
   }

   //加载属性信息 空函数 留给子类重写用于扩展
   initPropertySources();

   //验证需要的环境属性信息
   getEnvironment().validateRequiredProperties();
    
   -----------------------------------------------------
    //没有则创建环境对象 保存环境信息
   	public ConfigurableEnvironment getEnvironment() {
		if (this.environment == null) {
			this.environment = createEnvironment();
		}
		return this.environment;
	}
   -----------------------------------------------------

   //初始化容器预刷新监听器
   if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
   }
   else {
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
   }

   //初始化事件用于通知监听器
   this.earlyApplicationEvents = new LinkedHashSet<>();
}

在这里插入图片描述

obtainFreshBeanFactory() ：

AbstractApplicationContext:
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory(); //刷新容器
   return getBeanFactory(); //返回容器
}

AbstractRefreshableApplicationContext:
protected final void refreshBeanFactory() throws BeansException {
    //判断当前是否存在容器
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        //创建一个DefaultListableBeanFactory对象
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        //设置序列化id
        beanFactory.setSerializationId(getId());
        //自定义容器
        customizeBeanFactory(beanFactory);
        //加载bean定义信息
        loadBeanDefinitions(beanFactory);
        //设置容器
        this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

AbstractRefreshableApplicationContext:
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    //是否允许修改bean定义信息
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    //是否允许循环依赖
    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
}

AbstractXmlApplicationContext:
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    //创建一个XML bean信息读取器
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    //设置环境信息、资源加载器、资源实体处理器
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
	
    //初始化bean信息读取器
    initBeanDefinitionReader(beanDefinitionReader);
    //加载bean定义信息
    loadBeanDefinitions(beanDefinitionReader);
}

AbstractXmlApplicationContext:
protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
    //设置开启XML自动检查
    reader.setValidating(this.validating);
}

AbstractXmlApplicationContext:
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    
    //配置文件名称集合
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        //使用XML bean信息读取器读取配置文件
        reader.loadBeanDefinitions(configLocations);
    }
}

AbstractBeanDefinitionReader:
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
    Assert.notNull(locations, "Location array must not be null");
    int count = 0;
    //循环遍历 计算配置文件的个数
    for (String location : locations) {
        count += loadBeanDefinitions(location);
    }
    
    //返回配置文件总数
    return count;
}

prepareBeanFactory(beanFactory) ：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   //设置类加载器
   beanFactory.setBeanClassLoader(getClassLoader());
   //是否无论SPEL表达式, shouldIgnoreSpel默认值为false 不忽略
   if (!shouldIgnoreSpel) {
      //设置bean表达式解析器 
      beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   }
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   //配置容器 添加bean后置处理器 在依赖检查和自动装配时忽略容器底层相关接口
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
   -----------------------------------------------------
   	public void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) {
		Assert.notNull(dependencyType, "Dependency type must not be null");
		if (autowiredValue != null) {
			if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {
				throw new IllegalArgumentException("Value [" + autowiredValue +
						"] does not implement specified dependency type [" + dependencyType.getName() + "]");
			}
             //加入自动装配Map中
			this.resolvableDependencies.put(dependencyType, autowiredValue);
		}
	}
   -----------------------------------------------------

   //添加bean后置处理器 监听内部bean
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   // 注册默认环境bean
   /*
    String ENVIRONMENT_BEAN_NAME = "environment";
	String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";
	String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";
	String APPLICATION_STARTUP_BEAN_NAME = "applicationStartup";
   */
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
   if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
      beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
   }
}

registerListeners() ：

protected void registerListeners() {
    //注册容器底层监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    //注册配置文件中定义的监听器
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    //发布消息
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

finishBeanFactoryInitialization():

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   //初始化转换服务
   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));
   }

   //如果容器中没有注册过BeanFactoryPostProcessor,就注册一个默认的PropertySourcesPlaceholderConfigurer,用于解析注解属性值
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   //初始化LoadTimeWeaverAware
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   //关闭类加载器
   beanFactory.setTempClassLoader(null);

   //缓存bean的全限定名信息
   beanFactory.freezeConfiguration();

   //实例化所有非懒加载的单例bean
   beanFactory.preInstantiateSingletons();
}

DefaultListableBeanFactory:
public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

    //保存所有的bean全限定名
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //非抽象 单例 非懒加载的bean被实例化
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //判断该bean是否是FactoryBean类型
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }
}

AbstractBeanFactory:
@Override
public Object getBean(String name) throws BeansException {
    //真正实例化Bean
    return doGetBean(name, null, null, false);
}

finishRefresh():

protected void finishRefresh() {
   //清除容器缓存
   clearResourceCaches();

   //初始化生命周期处理器
   initLifecycleProcessor();
    
   --------------------------------------------------------
   protected void initLifecycleProcessor() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
			this.lifecycleProcessor =
					beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
			}
		}
		else {
             //设置默认生命周期处理器
			DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
			defaultProcessor.setBeanFactory(beanFactory);
			this.lifecycleProcessor = defaultProcessor;
			beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
						"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
			}
		}
	}
   --------------------------------------------------------

   //运行生命周期处理器
   getLifecycleProcessor().onRefresh();

   //发送容器刷新完成事件
   publishEvent(new ContextRefreshedEvent(this));

   //参与注册LiveBeansView MBean
   if (!NativeDetector.inNativeImage()) {
      LiveBeansView.registerApplicationContext(this);
   }
}

在这里插入图片描述

2.生命周期接口方法及其顺序

BeanFactory接口注释中告诉了我们生命周期相关接口方法执行顺序：

在这里插入图片描述

BeanNameAware接口 setBeanName方法
BeanClassLoaderAware接口 setBeanClassLoader方法
BeanFactoryAware接口 setBeanFactory方法
EnvironmentAware接口 setEnvironment方法
EmbeddedValueResolverAware接口 setEmbeddedValueResolver方法
ResourceLoaderAware接口 setResourceLoader方法 (适用于applicationContext)
ApplicationEventPublisherAware接口 setApplicationEventPublisher方法 (适用于applicationContext)
MessageSourceAware接口 setMessageSource方法 (适用于applicationContext)
ApplicationContextAware接口 setApplicationContext方法 (适用于applicationContext)
ServletContextAware接口 setServletContext方法 (适用于applicationContext)
所有BeanPostProcessor接口 postProcessBeforeInitialization方法
InitializingBean接口 afterPropertiesSet方法
自定义的init-method方法
所有BeanPostProcessor接口 postProcessAfterInitialization方法
所有DestructionAwareBeanPostProcessor接口 postProcessBeforeDestruction方法
DisposableBean接口 destroy方法
自定义的destroy-method方法

顺序图：

在这里插入图片描述

测试：

MyBeanFactoryPostProcessor：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("0.MyBeanFactoryPostProcessor postProcessBeanFactory()被执行...beanFactory" + beanFactory);
    }
}

MyBeanNameAware：

public class MyBeanNameAware implements BeanNameAware {

    @Override
    public void setBeanName(String name) {
        System.out.println("\n1.MyBeanNameAware setBeanName()被执行...name = " + name);
    }
}

MyBeanClassLoaderAware：

public class MyBeanClassLoaderAware implements BeanClassLoaderAware {

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("\n2.MyBeanClassLoaderAware setBeanClassLoader()被执行...classLoader = " + classLoader);
    }
}

MyBeanFactoryAware：

public class MyBeanFactoryAware implements BeanFactoryAware {

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("\n3.MyBeanFactoryAware setBeanFactory()被执行...beanFactory = " + beanFactory);
    }
}

MyEnvironmentAware：

public class MyEnvironmentAware implements EnvironmentAware {

    @Override
    public void setEnvironment(Environment environment) {
        System.out.println("\n4.MyEnvironmentAware setEnvironment()被执行...environment = " + environment);
    }
}

MyEmbeddedValueResolverAware：

public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        System.out.println("\n5.MyEmbeddedValueResolverAware setEmbeddedValueResolver()被执行...resolver = " + resolver);
    }
}

MyResourceLoaderAware：

public class MyResourceLoaderAware implements ResourceLoaderAware {

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        System.out.println("\n6.MyResourceLoaderAware setResourceLoader()被执行...resourceLoader = " + resourceLoader);
    }
}

MyApplicationEventPublisherAware：

public class MyApplicationEventPublisherAware implements ApplicationEventPublisherAware {

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        System.out.println("\n7.MyApplicationEventPublisherAware setApplicationEventPublisher()被执行...applicationEventPublisher = " + applicationEventPublisher);
    }
}

MyMessageSourceAware：

public class MyMessageSourceAware implements MessageSourceAware {

    @Override
    public void setMessageSource(MessageSource messageSource) {
        System.out.println("\n8.MyMessageSourceAware setMessageSource()被执行...messageSource = " + messageSource);
    }
}

MyApplicationContextAware：

public class MyApplicationContextAware implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("\n9.MyApplicationContextAware setApplicationContext()被执行...applicationContext = " + applicationContext);
    }
}

MyInitializingBean：

public class MyInitializingBean implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("\n10.MyInitializingBean afterPropertiesSet()被执行...");
    }
}

User类：

public class User {

    private String name;

    private String age;

    private String gender;

    public void initMethod(){
        System.out.println("\n12.init user...");
    }

    public void destroyMethod(){
        System.out.println("\n13.destroy user...");
    }

    public User() {
        System.out.println("\n11.执行User的无参构造函数...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("执行User的setName()...");
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        System.out.println("执行User的setAge()...");
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        System.out.println("执行User的setGender()...");
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

MyDisposableBean：

public class MyDisposableBean implements DisposableBean {

    @Override
    public void destroy() throws Exception {
        System.out.println("\n14.MyDisposableBean destroy()被执行...");
    }
}

MyDestructionAwareBeanPostProcessor：

public class MyDestructionAwareBeanPostProcessor implements DestructionAwareBeanPostProcessor {

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        System.out.println("MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = " + bean + " beanName" + beanName);
    }
}

自定义BeanPostProcessor:

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean初始化之前执行前置处理器...bean--->" + bean + " beanName = " + beanName);
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean初始化之后执行后置处理器...bean--->" + bean + " beanName = " + beanName);
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

配置文件：

<bean class="com.qingsongxyz.lifecycle.MyBeanNameAware"/>

<bean class="com.qingsongxyz.lifecycle.MyBeanClassLoaderAware"/>

<bean class="com.qingsongxyz.lifecycle.MyBeanFactoryAware"/>

<bean class="com.qingsongxyz.lifecycle.MyEnvironmentAware"/>

<bean class="com.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware"/>

<bean class="com.qingsongxyz.lifecycle.MyResourceLoaderAware"/>

<bean class="com.qingsongxyz.lifecycle.MyApplicationEventPublisherAware"/>

<bean class="com.qingsongxyz.lifecycle.MyMessageSourceAware"/>

<bean class="com.qingsongxyz.lifecycle.MyApplicationContextAware"/>

<bean class="com.qingsongxyz.lifecycle.MyServletContextAware"/>

<!--Bean后置处理器-->
<bean class="com.qingsongxyz.lifecycle.MyBeanPostProcessor"/>

<bean class="com.qingsongxyz.lifecycle.MyInitializingBean"/>

<bean class="com.qingsongxyz.lifecycle.MyDestructionAwareBeanPostProcessor"/>

<bean class="com.qingsongxyz.lifecycle.MyDisposableBean"/>

<!--Bean工厂后置处理器-->
<bean class="com.qingsongxyz.lifecycle.MyBeanFactoryPostProcessor"/>

<!--自定义User类-->
<bean id="user" class="com.qingsongxyz.lifecycle.User" init-method="initMethod" destroy-method="destroyMethod">
    <property name="name" value="张三"/>
    <property name="age" value="18"/>
    <property name="gender" value="男"/>
</bean>
</bean>

测试:

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = context.getBean("user", User.class);
    System.out.println("=============" + user + "=============");
    ((ClassPathXmlApplicationContext)context).close(); 
    //容器关闭 销毁创建的Bean 先创建的后销毁
}

/*
0.MyBeanFactoryPostProcessor postProcessBeanFactory()被执行...beanFactoryorg.springframework.beans.factory.support.DefaultListableBeanFactory@4f970963

1.MyBeanNameAware setBeanName()被执行...name = com.qingsongxyz.lifecycle.MyBeanNameAware#0
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyBeanNameAware@29b5cd00 beanName = com.qingsongxyz.lifecycle.MyBeanNameAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyBeanNameAware@29b5cd00 beanName = com.qingsongxyz.lifecycle.MyBeanNameAware#0

2.MyBeanClassLoaderAware setBeanClassLoader()被执行...classLoader = sun.misc.Launcher$AppClassLoader@18b4aac2
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyBeanClassLoaderAware@60285225 beanName = com.qingsongxyz.lifecycle.MyBeanClassLoaderAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyBeanClassLoaderAware@60285225 beanName = com.qingsongxyz.lifecycle.MyBeanClassLoaderAware#0

3.MyBeanFactoryAware setBeanFactory()被执行...beanFactory = org.springframework.beans.factory.support.DefaultListableBeanFactory@4f970963
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyBeanFactoryAware@7113b13f beanName = com.qingsongxyz.lifecycle.MyBeanFactoryAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyBeanFactoryAware@7113b13f beanName = com.qingsongxyz.lifecycle.MyBeanFactoryAware#0

4.MyEnvironmentAware setEnvironment()被执行...environment = StandardEnvironment 
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyEnvironmentAware@45820e51 beanName = com.qingsongxyz.lifecycle.MyEnvironmentAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyEnvironmentAware@45820e51 beanName = com.qingsongxyz.lifecycle.MyEnvironmentAware#0

5.MyEmbeddedValueResolverAware setEmbeddedValueResolver()被执行...resolver = org.springframework.beans.factory.config.EmbeddedValueResolver@42d8062c
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware@6043cd28 beanName = com.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware@6043cd28 beanName = com.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware#0

6.MyResourceLoaderAware setResourceLoader()被执行...resourceLoader = org.springframework.context.support.ClassPathXmlApplicationContext@3cd1f1c8, started on Wed Jul 06 08:47:16 CST 2022
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyResourceLoaderAware@59906517 beanName = com.qingsongxyz.lifecycle.MyResourceLoaderAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyResourceLoaderAware@59906517 beanName = com.qingsongxyz.lifecycle.MyResourceLoaderAware#0

7.MyApplicationEventPublisherAware setApplicationEventPublisher()被执行...applicationEventPublisher = org.springframework.context.support.ClassPathXmlApplicationContext@3cd1f1c8, started on Wed Jul 06 08:47:16 CST 2022
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyApplicationEventPublisherAware@5bfbf16f beanName = com.qingsongxyz.lifecycle.MyApplicationEventPublisherAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyApplicationEventPublisherAware@5bfbf16f beanName = com.qingsongxyz.lifecycle.MyApplicationEventPublisherAware#0

8.MyMessageSourceAware setMessageSource()被执行...messageSource = org.springframework.context.support.ClassPathXmlApplicationContext@3cd1f1c8, started on Wed Jul 06 08:47:16 CST 2022
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyMessageSourceAware@25af5db5 beanName = com.qingsongxyz.lifecycle.MyMessageSourceAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyMessageSourceAware@25af5db5 beanName = com.qingsongxyz.lifecycle.MyMessageSourceAware#0

9.MyApplicationContextAware setApplicationContext()被执行...applicationContext = org.springframework.context.support.ClassPathXmlApplicationContext@3cd1f1c8, started on Wed Jul 06 08:47:16 CST 2022
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyApplicationContextAware@12cdcf4 beanName = com.qingsongxyz.lifecycle.MyApplicationContextAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyApplicationContextAware@12cdcf4 beanName = com.qingsongxyz.lifecycle.MyApplicationContextAware#0
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyServletContextAware@5bcea91b beanName = com.qingsongxyz.lifecycle.MyServletContextAware#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyServletContextAware@5bcea91b beanName = com.qingsongxyz.lifecycle.MyServletContextAware#0
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyInitializingBean@5f3a4b84 beanName = com.qingsongxyz.lifecycle.MyInitializingBean#0

10.MyInitializingBean afterPropertiesSet()被执行...
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyInitializingBean@5f3a4b84 beanName = com.qingsongxyz.lifecycle.MyInitializingBean#0
bean初始化之前执行前置处理器...bean--->com.qingsongxyz.lifecycle.MyDisposableBean@27f723 beanName = com.qingsongxyz.lifecycle.MyDisposableBean#0
bean初始化之后执行后置处理器...bean--->com.qingsongxyz.lifecycle.MyDisposableBean@27f723 beanName = com.qingsongxyz.lifecycle.MyDisposableBean#0

11.执行User的无参构造函数...
执行User的setName()...
执行User的setAge()...
执行User的setGender()...
bean初始化之前执行前置处理器...bean--->User{name='张三', age='18', gender='男'} beanName = user

12.init user...
bean初始化之后执行后置处理器...bean--->User{name='张三', age='18', gender='男'} beanName = user
=============User{name='张三', age='18', gender='男'}=============
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = User{name='张三', age='18', gender='男'} beanNameuser

13.destroy user...
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyDisposableBean@27f723 beanNamecom.qingsongxyz.lifecycle.MyDisposableBean#0

14.MyDisposableBean destroy()被执行...
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyInitializingBean@5f3a4b84 beanNamecom.qingsongxyz.lifecycle.MyInitializingBean#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyServletContextAware@5bcea91b beanNamecom.qingsongxyz.lifecycle.MyServletContextAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyApplicationContextAware@12cdcf4 beanNamecom.qingsongxyz.lifecycle.MyApplicationContextAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyMessageSourceAware@25af5db5 beanNamecom.qingsongxyz.lifecycle.MyMessageSourceAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyApplicationEventPublisherAware@5bfbf16f beanNamecom.qingsongxyz.lifecycle.MyApplicationEventPublisherAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyResourceLoaderAware@59906517 beanNamecom.qingsongxyz.lifecycle.MyResourceLoaderAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware@6043cd28 beanNamecom.qingsongxyz.lifecycle.MyEmbeddedValueResolverAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyEnvironmentAware@45820e51 beanNamecom.qingsongxyz.lifecycle.MyEnvironmentAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyBeanFactoryAware@7113b13f beanNamecom.qingsongxyz.lifecycle.MyBeanFactoryAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyBeanClassLoaderAware@60285225 beanNamecom.qingsongxyz.lifecycle.MyBeanClassLoaderAware#0
MyDestructionAwareBeanPostProcessor postProcessBeforeDestruction()被执行...bean = com.qingsongxyz.lifecycle.MyBeanNameAware@29b5cd00 beanNamecom.qingsongxyz.lifecycle.MyBeanNameAware#0
*/

总结:

Bean的生命周期:

一系列XXXAware接口执行 —> 实例化(无参构造) —> 注入属性 —> 后置处理器前置过程 —> 初始化

—> 后置处理器后置过程 —> 销毁

后置处理器中的方法只能进行检测，无法干扰Bean的初始化

八、循环依赖

1.循环依赖场景

Spring容器中的对象默认为singleton单例的, A类的对象初始化依赖类B, B类的对象初始化依赖类A

//类A中存在属性为B类的对象
public class A {

    private B b;

    private A(){

    }
    
    public A(B b) {
        this.b = b;
    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }
}

//类B中存在属性为A类的对象
public class B {

    private A a;

    public B() {

    }
    
    public B(A a) {
        this.a = a;
    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }
}

第一种：

<!--对象aa使用setter注入-->
<bean id="aa" class="com.qingsongxyz.circledependence.A">
    <property name="b" ref="bb"/> 
</bean>

<!--对象bb使用setter注入-->
<bean id="bb" class="com.qingsongxyz.circledependence.B">
    <property name="a" ref="aa"/>
</bean>

第二种：

<!--对象aa使用构造器注入-->
<bean id="aa" class="com.qingsongxyz.circledependence.A">
    <constructor-arg name="b" ref="bb"/>
</bean>

<!--对象bb使用构造器注入-->
<bean id="bb" class="com.qingsongxyz.circledependence.B">
	<constructor-arg name="a" ref="aa"/>
</bean>

第三种：

<!--对象aa使用setter注入-->
<bean id="aa" class="com.qingsongxyz.circledependence.A">
    <property name="b" ref="bb"/>
</bean>

<!--对象bb使用构造器注入-->
<bean id="bb" class="com.qingsongxyz.circledependence.B">
    <constructor-arg name="a" ref="aa"/>
</bean>

第四种：

<!--对象aa使用构造器注入-->
<bean id="aa" class="com.qingsongxyz.circledependence.A">
    <constructor-arg name="b" ref="bb"/>
</bean>

<!--对象bb使用构造器注入-->
<bean id="bb" class="com.qingsongxyz.circledependence.B">
    <property name="a" ref="aa"/>
</bean>

测试：

@Test
public void test(){

    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    A a = context.getBean("aa", A.class);
    B b = context.getBean("bb", B.class);
    System.out.println("A = " + a + ",属性 b = " + a.getB());
    System.out.println("B = " + b + "属性 a = " + b.getA());
}

/*
第一种 两个对象都是用setter注入
-------------------------------------------------------
A = com.qingsongxyz.circledependence.A@548ad73b,属性 b = com.qingsongxyz.circledependence.B@4c762604
B = com.qingsongxyz.circledependence.B@4c762604属性 a = com.qingsongxyz.circledependence.A@548ad73b
-------------------------------------------------------
第二种 两个对象都是用构造器注入
Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException:
Requested bean is currently in creation: Is there an unresolvable circular reference?
-------------------------------------------------------
第三种 A类对象用setter注入 B类对象用构造器注入
A = com.qingsongxyz.circledependence.A@5a4041cc,属性 b = com.qingsongxyz.circledependence.B@15b3e5b
B = com.qingsongxyz.circledependence.B@15b3e5b属性 a = com.qingsongxyz.circledependence.A@5a4041cc
-------------------------------------------------------
第四种 A类对象用构造器注入 B类对象用setter注入
Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException:
Requested bean is currently in creation: Is there an unresolvable circular reference?
*/

2.分析实例化非懒加载Bean过程

DefaultListableBeanFactory:
public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

    //所有的bean全限定名
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //非抽象 单例 非懒加载的bean被实例化
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //判断该bean是否实现FactoryBean接口
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                //获取Bean
                getBean(beanName);
            }
        }
    }
    
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                .tag("beanName", beanName);
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
            smartInitialize.end();
        }
    }
}

AbstractBeanFactory:
@Override
public Object getBean(String name) throws BeansException {
    //真正实例化Bean 
    return doGetBean(name, null, null, false);
}

AbstractBeanFactory:
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {

    String beanName = transformedBeanName(name);
    Object beanInstance;

    //先从缓存中获取对象的单例对象
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                             "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        //如果该对象正在被创建抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        //检查工厂中是否存在该Bean的定义信息
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
            .tag("beanName", name);
        try {
            if (requiredType != null) {
                beanCreation.tag("beanType", requiredType::toString);
            }
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            
            //检查创建的Bean的依赖
            //构造器注入的循环依赖无法解决直接抛出异常
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            if (mbd.isSingleton()) {
                //创建Bean的实例                
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {

                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                String scopeName = mbd.getScope();
                if (!StringUtils.hasLength(scopeName)) {
                    throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
                }
                Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new ScopeNotActiveException(beanName, scopeName, ex);
                }
            }
        }
        catch (BeansException ex) {
            beanCreation.tag("exception", ex.getClass().toString());
            beanCreation.tag("message", String.valueOf(ex.getMessage()));
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
        finally {
            beanCreation.end();
        }
    }

    return adaptBeanInstance(name, beanInstance, requiredType);
}

DefaultSingletonBeanRegistry：

在这里插入图片描述

/*
	获取对象顺序
	1.一级缓存 singletonObjects
	2.二级缓存 earlySingletonObjects
	3.三级缓存 singletonFactories
*/
DefaultSingletonBeanRegistry:
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //先从一级缓存singletonObjects中获取相应对象
    Object singletonObject = this.singletonObjects.get(beanName);
    //如果一级缓存中没有该对象并且该对象正在被创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        //再从二级缓存earlySingletonObjects中获取相应对象
        singletonObject = this.earlySingletonObjects.get(beanName);
        //如果二级缓存中没有该对象
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        //最后从三级缓存中获取相应对象
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        //如果三级缓存中有该对象
                        if (singletonFactory != null) {
                            //调用getObject 执行lambda表达式创建对象
                            singletonObject = singletonFactory.getObject();
                            //将对象加入二级缓存中
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            //将对象从三级缓存中清除
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

DefaultSingletonBeanRegistry:
//重载方法
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
        //先从一级缓存中获取该对象
        Object singletonObject = this.singletonObjects.get(beanName);
        //如果一级缓存中不存在该对象
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                                                          "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                                                          "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
              	//调用ObjectFactory函数式接口中的getObject()方法 
                //即执行lambda表达式 createBean(beanName, mbd, args);
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                //将创建的对象保存到一级缓存singletonObjects
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

DefaultSingletonBeanRegistry:
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        //将创建的对象添加到一级缓存中
        this.singletonObjects.put(beanName, singletonObject);
        //将对象从三级缓存中清除
        this.singletonFactories.remove(beanName);
        //将对象从二级缓存中清除
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

AbstractAutowireCapableBeanFactory:
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

    if (logger.isTraceEnabled()) {
        logger.trace("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;

    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    try {
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                                               beanName, "Validation of method overrides failed", ex);
    }

    try {
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                        "BeanPostProcessor before instantiation of bean failed", ex);
    }

    try {
        //创建Bean对象实例
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {

        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

AbstractAutowireCapableBeanFactory:
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        //创建对象
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
        }
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    Object exposedObject = bean;
    try {
        populateBean(beanName, mbd, instanceWrapper);
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] 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 " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

DefaultSingletonBeanRegistry：
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        //如果一级缓存中不存在该对象
        if (!this.singletonObjects.containsKey(beanName)) {
            //将该对象存入三级缓存 key:对象名 value:lambda表达式
            this.singletonFactories.put(beanName, singletonFactory);
            //将对象从二级缓存中清除
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

AbstractAutowireCapableBeanFactory:
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }

    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            return instantiateBean(beanName, mbd);
        }
    }

    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    //实例化Bean
    return instantiateBean(beanName, mbd);
}

AbstractAutowireCapableBeanFactory:
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        if (System.getSecurityManager() != null) {
            beanInstance = AccessController.doPrivileged(
                (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
                getAccessControlContext());
        }
        else {
            //instantiate()
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
        }
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
}


public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    if (!bd.hasMethodOverrides()) {
        Constructor<?> constructorToUse;
        synchronized (bd.constructorArgumentLock) {
            constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse == null) {
                final Class<?> clazz = bd.getBeanClass();
                if (clazz.isInterface()) {
                    throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }
                try {
                    if (System.getSecurityManager() != null) {
                        constructorToUse = AccessController.doPrivileged(
                            (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
                    }
                    else {
                        constructorToUse = clazz.getDeclaredConstructor();
                    }
                    bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                }
                catch (Throwable ex) {
                    throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                }
            }
        }
        
        //调用工具类BeanUtils 实例化Bean
        return BeanUtils.instantiateClass(constructorToUse);
    }
    else {
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
}

BeanUtils:
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    Assert.notNull(ctor, "Constructor must not be null");
    try {
        //访问构造器
        ReflectionUtils.makeAccessible(ctor);
        if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
            return KotlinDelegate.instantiateClass(ctor, args);
        }
        else {
            //参数
            Class<?>[] parameterTypes = ctor.getParameterTypes();
            Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
            Object[] argsWithDefaultValues = new Object[args.length];
            for (int i = 0 ; i < args.length; i++) {
                if (args[i] == null) {
                    Class<?> parameterType = parameterTypes[i];
                    argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
                }
                else {
                    argsWithDefaultValues[i] = args[i];
                }
            }
            
            //反射创建对象
            return ctor.newInstance(argsWithDefaultValues);
        }
    }
    catch (InstantiationException ex) {
        throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
    }
    catch (IllegalAccessException ex) {
        throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
    }
    catch (IllegalArgumentException ex) {
        throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
    }
    catch (InvocationTargetException ex) {
        throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
    }
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
            exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
        }
    }
    return exposedObject;
}

总结：

1.创建Bean实例过程

获取所有的beanDefinitionNames，循环调用getBean(beanName)方法，之后调用doGetBean()方法，

在这个方法中调用getSingleton()方法传入beanName和ObjectFactory对象(lambda表达式)，在lambda表达式

中调用createBean()方法，然后调用doCreateBean()方法，调用createBeanInstance()方法，调用

instantiateBean()方法，调用instantiate()方法，最后使用BeanUtils工具类的instantiateClass()方法反射创建

对象实例

2.使用三级缓存解决循环依赖

三级缓存只能解决单例情况的循环依赖问题

A类对象注入方式	B类对象注入方式	能否解决循环依赖问题
setter注入	setter注入	能
setter注入	构造器注入	能
构造器注入	setter注入	不能
构造器注入	构造器注入	不能

大致过程：

在这里插入图片描述

singletonObjects：存放完成初始化的单例对象的cache (一级缓存)

earlySingletonObjects ：存放完成实例化但是尚未初始化的，提前暴光的单例对象的Cache (二级缓存)

singletonFactories ：存放进入实例化阶段的单例对象工厂的cache (三级缓存)

首先实例化A类对象a，将其加入三级缓存singletonFactories中(key为对象名称a，value为lambda表达式，方法体中执行getEarlyBeanReference()函数)，然后设置对象a的属性值b(B类的对象)，先在一级缓存singletonObjects中查找有没有创建好的B类对象，此时显然没有，创建出的a对象b属性值为null
然后就会进行B类对象b的实例化，将其加入三级缓存singletonFactories中(key为对象名称b，value为lambda表达式，方法体中执行getEarlyBeanReference()函数)，然后设置对象b的属性值a(A类的对象)，先在一级缓存singletonObjects中查找有没有创建好的A类对象，由于a对象还在创建中，在一级缓存中找不到，创建出的b对象a属性值为null
此时从三级缓存中获取到之前存入的key为a的数据，调用objectFactory.getObject()方法，即调用之前存入的lambda表达式，将创建好的A类对象存入二级缓存earlySingletonObjects(key为对象名称a，value为创建好的对象a属性值b为null)并将三级缓存中的a数据清除，将这个对象暴露出去，然后设置属性值初始化对象b，此时b对象创建成功，将其加入一级缓存singletonObjects中并清除二级、三级缓存中b的数据，最后设置属性值初始化对象a，将其加入一级缓存singletonObjects中并清除二级、三级缓存中b的数据，解决循环依赖问题