Spring · IOC（面渣逆袭）

《面渣逆袭》Spring 篇 · 第 2/7 章。原版 PDF（下载 / 打印）

5.说一说什么是 IOC？什么是 DI?

Java 是面向对象的编程语言，一个个实例对象相互合作组成了业务逻辑，原来，我们都是在代码里创建对象和对象的依赖。

所谓的IOC（控制反转）：就是由容器来负责控制对象的生命周期和对象间的关系。以前是我们想要什么，就自己创建什么，现在是我们需要什么，容器就给我们送来什么。

也就是说，控制对象生命周期的不再是引用它的对象，而是容器。对具体对象，以前是它控制其它对象，现在所有对象都被容器控制，所以这就叫控制反转。

DI （依赖注入）：指的是容器在实例化对象的时候把它依赖的类注入给它。有的说法 IOC 和 DI 是一回事，有的说法是 IOC 是思想，DI是 IOC 的实现。

为什么要使用 IOC 呢？

最主要的是两个字解耦，硬编码会造成对象间的过度耦合，使用 IOC 之后，我们可以不用关心对象间的依赖，专心开发应用就行。

6.能简单说一下 Spring IOC 的实现机制吗？

PS: 这道题老三在面试中被问到过，问法是“你有自己实现过简单的 Spring 吗？”

Spring 的 IOC 本质就是一个大工厂，我们想想一个工厂是怎么运行的呢？

生产产品：一个工厂最核心的功能就是生产产品。在 Spring 里，不用 Bean 自己来实例化，而是交给 Spring ，应该怎么实现呢？— — 答案毫无疑问，反射。

那么这个厂子的生产管理是怎么做的？你应该也知道— —工厂模式。

库存产品：工厂一般都是有库房的，用来库存产品，毕竟生产的产品不能立马就拉走。Spring 我们都知道是一个容器，这个容器里存的就是对象，不能每次来取对象，都得现场来反射创建对象，得把创建出的对象存起来。

订单处理：还有最重要的一点，工厂根据什么来提供产品呢？订单。这些订单可能五花八门，有线上签签的、有到工厂签的、还有工厂销售上门签的… … 最后经过处理，指导工厂的出货。

在 Spring 里，也有这样的订单，它就是我们 bean 的定义和依赖关系，可以是 xml 形式，也可以是我们最熟悉的注解形式。

我们简单地实现一个 mini 版的 SpringIOC ：

Bean 定义：

Bean 通过一个配置文件定义，把它解析成一个类型。

beans.properties偷懒，这里直接用了最方便解析的 properties ，这里直接用一个**<key,value>**类型的配置来代表

Bean 的定义，其中 key 是 beanName，value 是 class

userDao:cn.fighter3.bean.UserDao

BeanDefinition.java

bean 定义类，配置文件中 bean 定义对应的实体

java

public class BeanDefinition {
    private String beanName;
    private Class beanClass;
     //省略getter、setter
 }

ResourceLoader.java资源加载器，用来完成配置文件中配置的加载

java

public class ResourceLoader {
    public static Map<String, BeanDefinition> getResource() {
        Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(16);
        Properties properties = new Properties();
        try {

InputStreaminputStream=

java

ResourceLoader.class.getResourceAsStream("/beans.properties");
            properties.load(inputStream);
            Iterator<String> it = properties.stringPropertyNames().iterator();
            while (it.hasNext()) {
                String key = it.next();
                String className = properties.getProperty(key);
                BeanDefinition beanDefinition = new BeanDefinition();
                beanDefinition.setBeanName(key);
                Class clazz = Class.forName(className);
                beanDefinition.setBeanClass(clazz);
                beanDefinitionMap.put(key, beanDefinition);
            }
            inputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return beanDefinitionMap;
    }
}

BeanRegister.java对象注册器，这里用于单例 bean 的缓存，我们大幅简化，默认所有 bean 都是单例的。可以看到所谓单例注册，也很简单，不过是往 HashMap 里存对象。

java

public class BeanRegister {
    //单例Bean缓存
    private Map<String, Object> singletonMap = new HashMap<>(32);

获取单例Bean * * @ parambeanNamebean 名称

     * @return

java

    public Object getSingletonBean(String beanName) {
        return singletonMap.get(beanName);
    }

注册单例bean * * @ parambeanName * @ parambean */

java

    public void registerSingletonBean(String beanName, Object bean) {
        if (singletonMap.containsKey(beanName)) {
            return;
        }
        singletonMap.put(beanName, bean);
    }
}

BeanFactory.java

对象工厂，我们最核心的一个类，在它初始化的时候，创建了 bean 注册器，完成了资源的加载。

获取 bean 的时候，先从单例缓存中取，如果没有取到，就创建并注册一个 bean

java

public class BeanFactory {
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
    private BeanRegister beanRegister;
    public BeanFactory() {
        //创建bean注册器
        beanRegister = new BeanRegister();
        //加载资源
        this.beanDefinitionMap = new ResourceLoader().getResource();
    }

获取bean * * @ parambeanNamebean 名称

     * @return

java

    public Object getBean(String beanName) {
        //从bean缓存中取
        Object bean = beanRegister.getSingletonBean(beanName);
        if (bean != null) {
            return bean;
        }
        //根据bean定义，创建bean
        return createBean(beanDefinitionMap.get(beanName));
    }

创建Bean * * @ parambeanDefinitionbean 定义

     * @return

java

    private Object createBean(BeanDefinition beanDefinition) {
        try {
            Object bean = beanDefinition.getBeanClass().newInstance();
            //缓存bean
            beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);
            return bean;
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试

UserDao.java我们的 Bean 类，很简单

java

public class UserDao {
    public void queryUserInfo(){
        System.out.println("A good man.");
    }
}

单元测试

java

public class ApiTest {

@ Test

java

    public void test_BeanFactory() {
        //1.创建bean工厂(同时完成了加载资源、创建注册单例bean注册器的操作)
        BeanFactory beanFactory = new BeanFactory();
        //2.第一次获取bean（通过反射创建bean，缓存bean）
        UserDao userDao1 = (UserDao) beanFactory.getBean("userDao");
        userDao1.queryUserInfo();
        //3.第二次获取bean（从缓存中获取bean）
        UserDao userDao2 = (UserDao) beanFactory.getBean("userDao");
        userDao2.queryUserInfo();
    }
}

运行结果

Agoodman.

Agoodman.至此，我们一个乞丐+ 破船版的 Spring 就完成了，代码也比较完整，有条件的可以跑一下。

PS: 因为时间+ 篇幅的限制，这个 demo 比较简陋，没有面向交叉、没有解耦、边界检查、异常处理… … 健壮性、扩展性都有很大的不足，感兴趣可以学习参考[ 15] 。

7.说说 BeanFactory 和 ApplicantContext?

可以这么形容，BeanFactory 是 Spring 的“ 心脏” ，ApplicantContext 是完整的“ 身躯” 。

BeanFactory （Bean 工厂）是 Spring 框架的基础设施，面向 Spring 本身。

ApplicantContext （应用上下文）建立在 BeanFactoty 基础上，面向使用 Spring 框架的开发者。

BeanFactory 交叉

BeanFactory 是类的通用工厂，可以创建并管理各种类的对象。

Spring 为 BeanFactory 提供了很多种实现，最常用的是 XmlBeanFactory ，但在 Spring3.2 中已被废弃，建议使用 XmlBeanDefinitionReader 、DefaultListableBeanFactory。

BeanFactory 接又位于类结构树的顶端，它最主要的方法就是 getBean(String var1)，这个方法从容

器中返回特定名称的 Bean 。

BeanFactory 的功能通过其它的交叉得到了不断的扩展，比如

AbstractAutowireCapableBeanFactory 定义了将容器中的 Bean 按照某种规则（比如按名字匹配、

按类型匹配等）进行自动装配的方法。

这里看一个 XMLBeanFactory （已过期）获取 bean 的例子：

java

public class HelloWorldApp{
   public static void main(String[] args) {
      BeanFactory factory = new XmlBeanFactory (new ClassPathResource("beans.xml"));
      HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");
      obj.getMessage();
   }
}

ApplicationContext 交叉

ApplicationContext 由 BeanFactory 派生而来，提供了更多面向实际应用的功能。可以这么说，使用 BeanFactory 就是手动档，使用 ApplicationContext 就是自动档。

ApplicationContext 继承了 HierachicalBeanFactory 和 ListableBeanFactory 交叉，在此基础上，还通过其他的交叉扩展了 BeanFactory 的功能，包括：

Beaninstantiation/wiring

Bean 的实例化/ 串联自动的 BeanPostProcessor 注册自动的 BeanFactoryPostProcessor 注册方便的 MessageSource 访问（i 18n ）

ApplicationEvent 的发布与 BeanFactory 懒加载的方式不同，它是预加载，所以，每一个 bean都在 ApplicationContext 启动之后实例化这是 ApplicationContext 的使用例子：

java

public class HelloWorldApp{
   public static void main(String[] args) {
      ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
   }
}

ApplicationContext 包含 BeanFactory 的所有特性，通常推荐使用前者。

8.你知道 Spring 容器启动阶段会干什么吗？

PS ：这道题老三面试被问到过

Spring 的 IOC 容器工作的过程，其实可以划分为两个阶段：容器启动阶段和Bean 实例化阶段。

其中容器启动阶段主要做的工作是加载和解析配置文件，保存到对应的 Bean 定义中。

容器启动开始，首先会通过某种途径加载 CongigurationMetaData ，在大部分情况下，容器需要依赖某些工具类（BeanDefinitionReader ）对加载的 CongigurationMetaData 进行解析和分析，并将分析后的信息组为相应的 BeanDefinition 。

最后把这些保存了 Bean 定义必要信息的 BeanDefinition ，注册到相应的

BeanDefinitionRegistry，这样容器启动就完成了。

9.能说一下 Spring Bean 生命周期吗？

可以看看：SpringBean 生命周期，好像人的一生。。

在 Spring 中，基本容器 BeanFactory 和扩展容器 ApplicationContext 的实例化时机不太一样，

BeanFactory 采用的是延迟初始化的方式，也就是只有在第一次 getBean() 的时候，才会实例化

Bean ；ApplicationContext 启动之后会实例化所有的 Bean 定义。

SpringIOC 中 Bean 的生命周期大致分为四个阶段：实例化（I nstantiation ）、属性赋值

（P opulate ）、初始化（I nitialization ）、销毁（D estruction ）。

我们再来看一个稍微详细一些的过程：

实例化：第 1 步，实例化一个 Bean 对象

属性赋值：第 2 步，为 Bean 设置相关属性和依赖

初始化：初始化的阶段的步骤比较多，5 、6 步是真正的初始化，第 3 、4 步为在初始化前执行，第 7 步在初始化后执行，初始化完成之后，Bean 就可以被使用了

销毁：第 8~10 步，第 8 步其实也可以算到销毁阶段，但不是真正意义上的销毁，而是先在使用前注册了销毁的相关调用交叉，为了后面第 9 、1 0 步真正销毁 Bean 时再执行相应的方法

简单总结一下，Bean 生命周期里初始化的过程相对步骤会多一些，比如前置、后置的处理。

最后通过一个实例来看一下具体的细节：

定义一个PersonBean类，实现DisposableBean,InitializingBean,BeanFactoryAware,

BeanNameAware这 4 个交叉，同时还有自定义的init-method和destroy-method。

java

public class PersonBean implements InitializingBean, BeanFactoryAware, BeanNameAware,
DisposableBean {

身份证号*/

java

    private Integer no;

姓名*/

java

    private String name;
    public PersonBean() {
        System.out.println("1.调用构造方法：我出生了！");
    }
    public Integer getNo() {
        return no;
    }
    public void setNo(Integer no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
        System.out.println("2.设置属性：我的名字叫"+name);
    }

@ Override

java

    public void setBeanName(String s) {
        System.out.println("3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名");
    }

@ Override

java

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4.调用BeanFactoryAware#setBeanFactory方法：选好学校了");
    }

@ Override

java

    public void afterPropertiesSet() throws Exception {
        System.out.println("6.InitializingBean#afterPropertiesSet方法：入学登记");
    }
    public void init() {
        System.out.println("7.自定义init方法：努力上学ing");
    }

@ Override

java

    public void destroy() throws Exception {
        System.out.println("9.DisposableBean#destroy方法：平淡的一生落幕了");
    }
    public void destroyMethod() {
        System.out.println("10.自定义destroy方法:睡了，别想叫醒我");
    }
    public void work(){
        System.out.println("Bean使用中：工作，只有对社会没有用的人才放假。。");
    }
}

定义一个MyBeanPostProcessor实现BeanPostProcessor交叉。

java

public class MyBeanPostProcessor implements BeanPostProcessor {

@ Override

java

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws
BeansException {
        System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法：到学校报
名啦");
        return bean;
    }

@ Override

java

    public Object postProcessAfterInitialization(Object bean, String beanName) throws
BeansException {
        System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕

业，拿到毕业证啦！" );

        return bean;
    }
}

配置文件，指定init-method和destroy-method属性<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns="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 name="myBeanPostProcessor" class="cn.fighter3.spring.life.MyBeanPostProcessor"

    <bean name="personBean" class="cn.fighter3.spring.life.PersonBean"

init-method="init"destroy-method="destroyMethod"><propertyname="idNo"value="80669865"/><propertyname="name"value=" 张铁钢" /></bean></beans>测试

java

public class Main {
    public static void main(String[] args) {

ApplicationContextcontext=newClassPathXmlApplicationContext("spring-

config.xml");
        PersonBean personBean = (PersonBean) context.getBean("personBean");
        personBean.work();
        ((ClassPathXmlApplicationContext) context).destroy();
    }
}

运行结果：

调用构造方法：我出生了！
设置属性：我的名字叫张铁钢
调用BeanNameAware#setBeanName 方法: 我要上学了，起了个学名
调用BeanFactoryAware#setBeanFactory 方法：选好学校了
BeanPostProcessor#postProcessBeforeInitialization 方法：到学校报名啦
InitializingBean#afterPropertiesSet 方法：入学登记
自定义init 方法：努力上学i ng
BeanPostProcessor#postProcessAfterInitialization 方法：终于毕业，拿到毕业证啦！

Bean 使用中：工作，只有对社会没有用的人才放假。。

DisposableBean#destroy 方法：平淡的一生落幕了
自定义destroy 方法: 睡了，别想叫醒我

关于源码，Bean 创建过程可以查看AbstractBeanFactory#doGetBean方法，在这个方法里可以看到

Bean 的实例化，赋值、初始化的过程，至于最终的销毁，可以看

看ConfigurableApplicationContext#close() 。

10.Bean 定义和依赖定义有哪些方式？

有三种方式：直接编码方式、配置文件方式、注解方式。

直接编码方式：我们一般接触不到直接编码的方式，但其实其它的方式最终都要通过直接编码来实现。

配置文件方式：通过 xml 、propreties 类型的配置文件，配置相应的依赖关系，Spring 读取配置文件，完成依赖关系的注入。

注解方式：注解方式应该是我们用的最多的一种方式了，在相应的地方使用注解修饰，Spring 会扫描注解，完成依赖关系的注入。

11.有哪些依赖注入的方法？

Spring 支持构造方法注入、属性注入、工厂方法注入, 其中工厂方法注入，又可以分为静态工厂方法注

入和非静态工厂方法注入。

构造方法注入

通过调用类的构造方法，将交叉实现类通过构造方法变量传入

java

 public CatDaoImpl(String message){
   this. message = message;
 }
<bean id="CatDaoImpl" class="com.CatDaoImpl">

<constructor-argvalue="message"></constructor-arg></bean>

属性注入

通过 Setter 方法完成调用类所需依赖的注入

java

 public class Id {
    private int id;
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
}
<bean id="id" class="com.id ">

<propertyname="id"value="123"></property></bean>

工厂方法注入

静态工厂注入

静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让 Spring 管理所有对象，我们不能直接通过" 工程类. 静态方法( )" 来获取对象，而是依然通过 Spring 注入的形式获取：

java

public class DaoFactory { //静态工厂
   public static final FactoryDao getStaticFactoryDaoImpl(){
      return new StaticFacotryDaoImpl();
   }
}
public class SpringAction {
 //注入对象
 private FactoryDao staticFactoryDao;
 //注入对象的 set 方法
 public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
     this.staticFactoryDao = staticFactoryDao;
 }
}
//factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法
 <bean name="springAction" class=" SpringAction" >

<!-- 使用静态工厂的方法注入对象, 对应下面的配置文件- ->

   <property name="staticFactoryDao" ref="staticFactoryDao"></property>

</bean><!-- 此处获取对象的方式是从工厂类中获取静态方法- ->

<bean name="staticFactoryDao" class="DaoFactory"

factory-method="getStaticFactoryDaoImpl"></bean>

非静态工厂注入

非静态工厂，也叫实例工厂，意思是工厂方法不是静态的，所以我们需要首先 new 一个工厂实例，再调用普通的实例方法。

java

//非静态工厂
public class DaoFactory {
   public FactoryDao getFactoryDaoImpl(){
     return new FactoryDaoImpl();
   }
 }
public class SpringAction {
  //注入对象
  private FactoryDao factoryDao;
  public void setFactoryDao(FactoryDao factoryDao) {
    this.factoryDao = factoryDao;
  }
}
 <bean name="springAction" class="SpringAction">

<!-- 使用非静态工厂的方法注入对象, 对应下面的配置文件- -><propertyname="factoryDao"ref="factoryDao"></property></bean><!-- 此处获取对象的方式是从工厂类中获取实例方法- ->

 <bean name="daoFactory" class="com.DaoFactory"></bean>

<beanname="factoryDao"factory-bean="daoFactory"factory-

method="getFactoryDaoImpl"></bean>

12.Spring 有哪些自动装配的方式？

什么是自动装配？

SpringIOC 容器知道所有 Bean 的配置信息，此外，通过 Java 反射机制还可以获知实现类的结构信息，如构造方法的结构、属性等信息。掌握所有 Bean 的这些信息后，SpringIOC 容器就可以按照某种规则对容器中的 Bean 进行自动装配，而无须通过显式的方式进行依赖配置。

Spring 提供的这种方式，可以按照某些规则进行 Bean 的自动装配，**<bean>**元素提供了一个指定自动装配类型的属性：autowire="< 自动装配类型> "

Spring 提供了哪几种自动装配类型？

Spring 提供了 4 种自动装配类型：

byName：根据名称进行自动匹配，假设 Boss 又一个名为 car 的属性，如果容器中刚好有一个名为 car 的 bean ，Spring 就会自动将其装配给 Boss 的 car 属性

byType：根据类型进行自动匹配，假设 Boss 有一个 Car 类型的属性，如果容器中刚好有一个

Car 类型的 Bean ，Spring 就会自动将其装配给 Boss 这个属性

constructor：与 byType 类似，只不过它是针对构造函数注入而言的。如果 Boss 有一个构造函数，构造函数包含一个 Car 类型的入参，如果容器中有一个 Car 类型的 Bean ，则 Spring 将自动把这个 Bean 作为 Boss 构造函数的入参；如果容器中没有找到和构造函数入参匹配类型的

Bean ，则 Spring 将抛出异常。

autodetect：根据 Bean 的自省机制决定采用 byType 还是 constructor 进行自动装配，如果

Bean 提供了默认的构造函数，则采用 byType ，否则采用 constructor 。

13.Spring 中的 Bean 的作用域有哪些?

Spring 的 Bean 主要支持五种作用域：

singleton: 在 Spring 容器仅存在一个 Bean 实例，Bean 以单实例的方式存在，是 Bean 默认的作用域。

prototype: 每次从容器重调用 Bean 时，都会返回一个新的实例。

以下三个作用域于只在 We b 应用中适用：

request: 每一次 HTTP 请求都会产生一个新的 Bean ，该 Bean 仅在当前 HTTPRequest 内有效。

session: 同一个 HTTPSession 共享一个 Bean ，不同的 HTTPSession 使用不同的 Bean 。

globalSession：同一个全局 Session 共享一个 Bean ，只用于基于 Protlet 的 We b 应用，

Spring5 中已经不存在了。

14.Spring 中的单例 Bean 会存在线程安全问题吗？

首先结论在这：Spring 中的单例 Bean不是线程安全的。

因为单例 Bean ，是全局只有一个 Bean ，所有线程共享。如果说单例 Bean ，是一个无状态的，也就是线程中的操作不会对 Bean 中的成员变量执行查询以外的操作，那么这个单例 Bean 是线程安全的。

比如 Springmvc 的 Controller 、Service 、D ao 等，这些 Bean 大多是无状态的，只关注于方法本身。

假如这个 Bean 是有状态的，也就是会对 Bean 中的成员变量进行写操作，那么可能就存在线程安全的问题。

单例 Bean 线程安全问题怎么解决呢？

常见的有这么些解决办法：

将 Bean 定义为多例

这样每一个线程请求过来都会创建一个新的 Bean ，但是这样容器就不好管理 Bean ，不能这么办。

在 Bean 对象中尽量避免定义可变的成员变量

削足适履了属于是，也不能这么干。

将 Bean 中的成员变量保存在 ThreadLocal 中

⭐我们知道 ThredLoca 能保证多线程下变量的隔离，可以在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal 里，这是推荐的一种方式。

15.说说循环依赖?

什么是循环依赖？

Spring 循环依赖：简单说就是自己依赖自己，或者和别的 Bean 相互依赖。

只有单例的 Bean 才存在循环依赖的情况，原型(Prototype) 情况下，Spring 会直接抛出异常。原因很简单，AB循环依赖，A 实例化的时候，发现依赖 B ，创建 B 实例，创建 B 的时候发现需要 A ，创建

A1 实例… … 无限套娃，直接把系统干垮。

Spring 可以解决哪些情况的循环依赖？

Spring 不支持基于构造器注入的循环依赖，但是假如 AB 循环依赖，如果一个是构造器注入，一个是

setter 注入呢？

看看几种情形：

第四种可以而第五种不可以的原因是 Spring 在创建 Bean 时默认会根据自然排序进行创建，所以 A会先于 B 进行创建。

所以简单总结，当循环依赖的实例都采用 setter 方法注入的时候，Spring 可以支持，都采用构造器注入的时候，不支持，构造器注入和 setter 注入同时存在的时候，看天。

16.那 Spring 怎么解决循环依赖的呢？

PS ：其实正确答案是开发人员做好设计，别让 Bean 循环依赖，但是没办法，面试官不想听这个。

我们都知道，单例 Bean 初始化完成，要经历三步：

注入就发生在第二步，属性赋值，结合这个过程，Spring 通过三级缓存解决了循环依赖：

一级缓存 😗*Map<String,Object>**singletonObjects，单例池，用于保存实例化、属性赋值

（注入）、初始化完成的 bean 实例

二级缓存 😗*Map<String,Object>**earlySingletonObjects，早期曝光对象，用于保存实例化完

成的 bean 实例

三级缓存 😗*Map<String,ObjectFactory<?>>**singletonFactories，早期曝光对象工厂，用于

保存 bean 创建工厂，以便于后面扩展有机会创建代理对象。

我们来看一下三级缓存解决循环依赖的过程：

当 A 、B 两个类发生循环依赖时：

A 实例的初始化过程：

创建 A 实例，实例化的时候把 A 对象工厂放入三级缓存，表示 A 开始实例化了，虽然我这个对

象还不完整，但是先曝光出来让大家知道

A 注入属性时，发现依赖 B ，此时 B 还没有被创建出来，所以去实例化 B
同样，B 注入属性时发现依赖 A ，它就会从缓存里找 A 对象。依次从一级到三级缓存查询 A ，

从三级缓存通过对象工厂拿到 A ，发现 A 虽然不太完善，但是存在，把 A 放入二级缓存，同时删除三级缓存中的 A ，此时，B 已经实例化并且初始化完成，把 B 放入一级缓存。

接着 A 继续属性赋值，顺利从一级缓存拿到实例化且初始化完成的 B 对象，A 对象创建也完

成，删除二级缓存中的 A ，同时把 A 放入一级缓存

最后，一级缓存中保存着实例化、初始化都完成的 A 、B 对象

所以，我们就知道为什么 Spring 能解决 setter 注入的循环依赖了，因为实例化和属性赋值是分开的，所以里面有操作的空间。如果都是构造器注入的化，那么都得在实例化这一步完成注入，所以自然是无法支持了。

17.为什么要三级缓存？二级不行吗？

不行，主要是为了生成代理对象。如果是没有代理的情况下，使用二级缓存解决循环依赖也是 OK的。但是如果存在代理，三级没有问题，二级就不行了。

因为三级缓存中放的是生成具体对象的匿名内部类，获取 Object 的时候，它可以生成代理对象，也可以返回普通对象。使用三级缓存主要是为了保证不管什么时候使用的都是一个对象。

假设只有二级缓存的情况，往二级缓存中放的显示一个普通的 Bean 对象，Bean 初始化过程中，通过

BeanPostProcessor 去生成代理对象之后，覆盖掉二级缓存中的普通 Bean 对象，那么可能就导致取到的 Bean 对象不一致了。

18.@Autowired 的实现原理？

实现@ Autowired 的关键是：AutowiredAnnotationBeanPostProcessor

在 Bean 的初始化阶段，会通过 Bean 后置处理器来进行一些前置和后置的处理。

实现@ Autowired 的功能，也是通过后置处理器来完成的。这个后置处理器就是

AutowiredAnnotationBeanPostProcesso r。

Spring 在创建 bean 的过程中，最终会调用到 doCreateBean()方法，在 doCreateBean()方法中

会调用 populateBean() 方法，来为 bean 进行属性填充，完成自动装配等工作。

在 populateBean() 方法中一共调用了两次后置处理器，第一次是为了判断是否需要属性填充，如果不需要进行属性填充，那么就会直接进行 return ，如果需要进行属性填充，那么方法就会继续向下执行，后面会进行第二次后置处理器的调用，这个时候，就会调用到

AutowiredAnnotationBeanPostProcessor 的 postProcessPropertyValues()方法，在该方法中

就会进行@ Autowired 注解的解析，然后实现自动装配。

属性赋值

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable
BeanWrapper bw) {
          //…………
          if (hasInstAwareBpps) {
              if (pvs == null) {
                  pvs = mbd.getPropertyValues();
              }
              PropertyValues pvsToUse;
              for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator();
var9.hasNext(); pvs = pvsToUse) {

InstantiationAwareBeanPostProcessorbp=

(InstantiationAwareBeanPostProcessor)var9.next();

pvsToUse=bp.postProcessProperties((PropertyValues)pvs,

bw.getWrappedInstance(), beanName);
                  if (pvsToUse == null) {
                      if (filteredPds == null) {

filteredPds=this.filterPropertyDescriptorsForDependencyCheck(bw,

mbd.allowCaching);
                      }
                      //执行后处理器，填充属性，完成自动装配
                      //调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方

法

pvsToUse=bp.postProcessPropertyValues((PropertyValues)pvs,filteredPds,

java

bw.getWrappedInstance(), beanName);
                      if (pvsToUse == null) {
                          return;
                      }
                  }
              }
          }
         //…………
  }
postProcessorPropertyValues()方法的源码如下，在该方法中，会先调用
findAutowiringMetadata()方法解析出 bean 中带有@Autowired 注解、@Inject 和@Value 注
解的属性和方法。然后调用 metadata.inject()方法，进行属性填充。
  public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String
beanName) {
      //@Autowired注解、@Inject和@Value注解的属性和方法
      InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(),
pvs);
      try {
          //属性填充
          metadata.inject(bean, beanName, pvs);
          return pvs;
      } catch (BeanCreationException var6) {
          throw var6;
      } catch (Throwable var7) {
          throw new BeanCreationException(beanName, "Injection of autowired dependencies
failed", var7);
      }
  }

5.说一说什么是 IOC？什么是 DI? ​

6.能简单说一下 Spring IOC 的实现机制吗？ ​

7.说说 BeanFactory 和 ApplicantContext? ​

8.你知道 Spring 容器启动阶段会干什么吗？ ​

9.能说一下 Spring Bean 生命周期吗？ ​

10.Bean 定义和依赖定义有哪些方式？ ​

11.有哪些依赖注入的方法？ ​

12.Spring 有哪些自动装配的方式？ ​

13.Spring 中的 Bean 的作用域有哪些? ​

14.Spring 中的单例 Bean 会存在线程安全问题吗？ ​

15.说说循环依赖? ​

16.那 Spring 怎么解决循环依赖的呢？ ​

17.为什么要三级缓存？二级不行吗？ ​

18.@Autowired 的实现原理？ ​

5.说一说什么是 IOC？什么是 DI?

6.能简单说一下 Spring IOC 的实现机制吗？

7.说说 BeanFactory 和 ApplicantContext?

8.你知道 Spring 容器启动阶段会干什么吗？

9.能说一下 Spring Bean 生命周期吗？

10.Bean 定义和依赖定义有哪些方式？

11.有哪些依赖注入的方法？

12.Spring 有哪些自动装配的方式？

13.Spring 中的 Bean 的作用域有哪些?

14.Spring 中的单例 Bean 会存在线程安全问题吗？

15.说说循环依赖?

16.那 Spring 怎么解决循环依赖的呢？

17.为什么要三级缓存？二级不行吗？

18.@Autowired 的实现原理？