【spring和容器系列】spring bean

POJO 、JavaBean与 SpringBean的区别

POJO（Plain Old Java Object）从字面上理解“简单老式的java对象”或者“普通java类”。

普通java对象

当我们谈论POJO时，我们所描述的是一个简单的类型，没有任何特定框架的引用。POJO对我们的属性和方法没有命名约定。
让我们创建一个基本的员工POJO。它将有三个属性；名字、姓氏和入职日期：

public class EmployeePojo {

    public String firstName;
    public String lastName;
    private LocalDate startDate;

    public EmployeePojo(String firstName, String lastName, LocalDate startDate) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.startDate = startDate;
    }

    public String name() {
        return this.firstName + " " + this.lastName;
    }

    public LocalDate getStart() {
        return this.startDate;
    }
}

这个类可以被任何Java程序使用，因为它不绑定到任何框架。但是，我们没有遵循任何真正的约定来构造、访问或修改类的状态。这种缺乏惯例的做法造成了两个问题：

1）如何使用它需要理解一下。

2）它可能会限制框架对其支持约定而不是配置、理解如何使用类以及增强其功能的能力。

为了探索第二点，让我们使用反射来处理EmployeePojo。因此，我们将开始发现它的一些局限性。

反射一个POJO

先添加一个依赖：

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

现在，让我们检查一下POJO的属性：

List<String> propertyNames =
  PropertyUtils.getPropertyDescriptors(EmployeePojo.class).stream()
    .map(PropertyDescriptor::getDisplayName)
    .collect(Collectors.toList());

如果要将propertyNames打印到控制台，我们只会看到：

[start]
在这里，只找到start(因为是getStart方法)。PropertyUtils未能找到其他两个。
如果我们使用像Jackson这样的其他库来处理EmployeePojo，我们也会看到同样的结果。
理想情况下，我们可以查看所有属性：firstName、lastName和startDate。好消息是许多Java库默认支持JavaBean命名约定。

JavaBeans

JavaBean仍然是一个POJO，但围绕如何实现它引入了一组严格的规则：

• 访问级别—要求属性是私有的，并暴露公开getter和setter方法。
• 方法名–getter和setter遵循getX和setX约定（对于布尔值，isX可以用于getter）
• 默认构造函数–必须存在无参数构造函数，以便在不提供参数的情况下创建实例，例如在反序列化期间
• Serializable–实现Serializable接口允许我们存储状态。

将EmployeePojo转换为一个JavaBean

public class EmployeeBean implements Serializable {

    private static final long serialVersionUID = -3760445487636086034L;
    private String firstName;
    private String lastName;
    private LocalDate startDate;

    public EmployeeBean() {
    }

    public EmployeeBean(String firstName, String lastName, LocalDate startDate) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.startDate = startDate;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    //  additional getters/setters

}

反射一个JavaBean

当我们用反射检查bean时，现在我们得到了属性的完整列表：

[firstName, lastName, startDate]

使用JavaBeans时的权衡

所以，我们展示了JavaBeans的一种有用方法。注意，每一个设计选择都会带来权衡。
在使用JavaBeans时，我们还应该注意一些潜在的缺点：
可变性–JavaBean由于其setter方法而具有可变性–这可能会导致并发性或一致性问题
样板文件–我们必须为所有属性引入getter，为大多数属性引入setter，其中大部分可能是不必要的零参数构造函数——我们经常需要构造函数中的参数来确保对象以有效状态实例化，但是JavaBean标准要求我们提供零参数构造函数。
考虑到这些权衡，这些年来，框架也适应了其他bean约定。

Spring Bean

Spring 官方文档对 bean 的解释是：

在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。

概念简单明了，我们提取处关键的信息：
1、bean是对象，一个或者多个不限定
2、bean由Spring中一个叫IoC的东西管理
3、我们的应用程序由一个个bean构成
第1和3好理解，那么IoC又是什么东西？

控制反转（IoC）

控制反转英文全称：Inversion of Control，简称就是IoC。 控制反转通过依赖注入（DI）方式实现对象之间的松耦合关系。程序运行时，依赖对象由【辅助程序】动态生成并注入到被依赖对象中，动态绑定两者的使用关系。Spring IoC容器就是这样的辅助程序，它负责对象的生成和依赖的注入，让后在交由我们使用。 简而言之，就是：IoC就是一个对象定义其依赖关系而不创建它们的过程。 这里我们可以细分为两个点。

私有属性保存依赖

第1点：使用私有属性保存依赖对象，并且只能通过构造函数参数传入，构造函数的参数可以是工厂方法、保存类对象的属性、或者是工厂方法返回值。 假设我们有一个Computer类：

public class Computer {
private String cpu;     // CPU型号
private int ram;        // RAM大小，单位GB

    public Computer(String cpu, int ram) {
        this.cpu = cpu;
        this.ram = ram;
    }
}

我们有另一个Person类依赖于Computer类，符合IoC的做法是这样：

public class Person {
    private Computer computer;

    public Person(Computer computer) {
        this.computer = computer;
    }
}

不符合IoC的做法如下：

// 直接在Person里实例化Computer类
public class Person {
    private Computer computer = new Computer(AMD, 3);
}

// 通过【非构造函数】传入依赖
public class Person {
    private Computer computer;

    public void init(Computer computer) {
        this.computer = computer;
    }
}

让Spring控制类构建过程

第2点：不用new，让Spring控制new过程。在Spring中，我们基本不需要 new 一个类，这些都是让 Spring 去做的。 Spring 启动时会把所需的类实例化成对象，如果需要依赖，则先实例化依赖，然后实例化当前类。 因为依赖必须通过构建函数传入，所以实例化时，当前类就会接收并保存所有依赖的对象。 这一步也就是所谓的依赖注入。

这就是IoC

在 Spring 中，类的实例化、依赖的实例化、依赖的传入都交由 Spring Bean 容器控制， 而不是用new方式实例化对象、通过非构造函数方法传入依赖等常规方式。 实质的控制权已经交由程序管理，而不是程序员管理，所以叫做控制反转。

Spring对bean做了增强实现了bean的依赖注入和AOP切面编程：

Class描述了类的信息一样，spring提供了对bean的一系列描述，让我们有机会扩展bean的能力，就是BeanDefinition描述了spring bean对象的信息
1、Spring在启动的时候需要「扫描」在XML/注解/JavaConfig 中需要被Spring管理的Bean信息；
2、随后，会将这些信息封装成BeanDefinition，最后会把这些信息放到一个beanDefinitionMap中

Spring bean属性列表包括：

• 类
• 名称
• 依赖
• 范围
• 初始化模式
• 初始化回调
• 破坏回调
  3、接着会遍历这个beanDefinitionMap，执行BeanFactoryPostProcessor这个Bean工厂后置处理器的逻辑；
  4、BeanFactoryPostProcessor后置处理器执行完了以后，就到了实例化对象。实例化又可以执行实例化前postProcessBeforeInstantiation和后postProcessAfterInstantiation来拓展
  5、下一步就是把对象的相关属性给注入
  6、相关属性注入完之后，往下接着就是初始化的工作了，初始化也分出初始化前postProcessBeforeInitialization和初始postProcessAfterInitialization
  大致过程如下图：
  
  
  为了简化bean定义，Spring为几乎所有属性提供了默认值。但是，了解如何自定义默认值非常重要。让我们逐个研究Spring bean属性。

1.Bean类

创建bean定义时，将其与应用程序中的单个具体类连接。这个类本身是bean的主要属性。
当Spring查找依赖项时，class属性是bean的默认标识符。这是否意味着你不能为单个类提供多个bean定义？不，这是可能的。但在这种情况下，为避免歧义，你应该使用另一个bean标识符：一个name名称。

2. Bean名称name

Spring bean名称是Spring用于标识bean的自定义字符串。与bean类不同，名称在整个应用程序中必须是唯一的。你不能定义两个具有相同名称的bean，即使它们的类型不同。
幸运的是，你不必为你创建的每个bean设置名称。Spring在运行时为其内部使用生成名称。除非你想按名称识别bean，否则可以安全地使用默认设置。
你需要使用bean名称的主要情况是为使用@Bean批注定义的同一个类提供了几个bean。在这种情况下，名称允许你标识要用作另一个bean的依赖项的特定实例。

3、如何命名Spring bean？

使用@Bean批注的name属性。这是两个具有相同类型的bean的示例。

@Configuration
class MyConfigurationClass {
 
 @Bean(name = "myBeanClass")
 MyBeanClass myBeanClass() {
 return new MyBeanClass();
 }
 
 @Bean(name = "anotherMyBeanClass")
 MyBeanClass anotherMyBeanClass() {
 return new MyBeanClass();
 }
 
}

实际上，你不经常定义bean名称。对于单个类具有多个bean是相当罕见的情况。然而，如果能了解命名bean的各种可能性也是不错的。

4. Bean依赖项

用作bean的对象可以使用其他bean来执行其作业。当Spring创建一个定义某些依赖项的对象时，框架需要首先创建这些依赖项。这些依赖项也可以有自己的依赖项。

在面向对象的应用程序中，我们通常使用相关对象的巨大图表。幸运的是，我们不必考虑如何构建此图。我们不必考虑应该创建对象的顺序。Spring为我们做了所有这些。

Spring对你的唯一期望是特定bean的依赖项列表。

5.如何定义bean依赖？

Bean依赖关系定义是一个复杂的主题，值得单独一篇文章。请考虑以下段落作为该主题的介绍。

当你有一个用@Component标记的类并且只有一个构造函数时，Spring使用构造函数参数列表作为必需依赖项列表。默认情况下，框架使用构造函数参数类型来提供适当的对象。

@Component
class BeanWithDependency {
 
 private final MyBeanClass beanClass;
 
 BeanWithDependency(MyBeanClass beanClass) {
 this.beanClass = beanClass;
 }
 
}

过去，我们在构造函数上使用@Autowired注释。但是，从Spring 4.3开始，如果只有一个构造函数，则不是强制性的。但是，如果bean类定义了多个构造函数，则应使用@Autowired标记一个。这样Spring知道哪个构造函数包含bean依赖项列表。

出于同样的原因，bean工厂方法可以定义其依赖关系。Spring使用适当的对象调用方法。

@Bean
BeanWithDependency beanWithOptionalDependency(MyBeanClass beanClass) {
 return new BeanWithDependency(beanClass);
}

6. Bean作用域

Spring bean的范围定义了框架在运行时创建的特定类的实例数。作用域还描述了创建新对象的条件。

Spring为你的bean提供了几个作用域。框架的核心有两个：

单例 - 单个实例
原型 - 多个实例
此外，Spring还附带了专门用于Web应用程序的bean作用域：

请求
会话
全局会话
应用级别Application
所有bean的默认作用域是单例。当bean具有单例作用域时，Spring只创建一个实例并在整个应用程序中共享它。单例是无状态对象的完美选择。如今，我们应用程序中的绝大多数bean都是无状态单例。

另一方面，如果对象包含状态，则应考虑其他作用域。要选择正确的一个，你应该问自己框架应该将该状态保留在内存中多长时间。但这是另一篇文章。

7. 如何设置作用域？

无论是使用@Component直接注释类还是使用@Bean创建工厂方法，该方法都是相同的。使用@Scope批注及其字符串属性选择范围。

@Component
@Scope("prototype")
class MyPrototypeClass {
 //...
}
@Bean
@Scope("prototype")
MyPrototypeClass myPrototypeClass() {
 return new MyPrototypeClass();
}

更重要的是，对于Web作用域，Spring附带了额外的别名注释。你可以使用这些注释代替@Scope：
@RequestScope
@SessionScope
@ApplicationScope

Bean初始化模式

当你的应用程序启动时，Spring会在启动时会立即创建所有单例bean。此默认行为允许我们快速检测bean定义中的错误。另一方面，立即性eager bean初始化会使应用程序的启动变慢。

幸运的是，你可以将bean的创建延迟到实际需要的时刻。你可以使用@Lazy注释执行此操作。

@Component
@Lazy
class MyLazyClass {
 //...
}

Bean初始化回调

一旦Spring根据bean定义创建新实例，你可能希望运行一些对象初始化逻辑。

如果此逻辑不依赖于框架，则可以在对象的构造函数中运行它。但是，为了确保在Spring初始化对象之后运行逻辑（例如，在可选的依赖注入之后），你应该使用初始化回调。

如何设置bean初始化回调？

如果使用@Component定义bean ，则有两个选项：

使bean类实现InitializingBean。接口将强制你实现初始化方法。

编写自定义初始化方法并使用javax @PostContruct注释进行标记。

在这两种情况下，Spring都会为你运行初始化回调。

用工厂方法定义的bean怎么样？

你可以使用@Bean及其名为initMethod的属性设置初始化回调。该属性需要一个具有初始化方法名称的字符串。

@Bean(initMethod = "someInitMethodName")
MySpringBeanClass meBeanClass() {
 return new MySpringBeanClass();
}

Bean销毁回调

与初始化回调类似，你可以定义Spring销毁bean时应调用的方法。Predestroy回调的使用要少得多，但要注意它们的存在是很好的。

如何设置bean销毁回调？

同样，如果你可以访问bean类的源代码，则可以使用以下两个选项之一：

实现DisposableBean接口。Spring使用其唯一的方法进行销毁回调。

编写自定义方法并使用Javax API中的@PreDestroy注释它。
对于工厂方法，使用@Bean批注及其destroyMethod属性

@Bean(name = "myBeanClass", destroyMethod = "cleanUpMethod")
MySpringBeanClass meBeanClass() {
 return new MySpringBeanClass();
}

演示

我们用一个简单的Spring Bean来演示一下Spring Bean的生命周期。

1、首先是一个简单的Spring Bean，调用Bean自身的方法和Bean级生命周期接口方法，为了方便演示，它实现了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这4个接口，同时有2个方法，对应配置文件中的init-method和destroy-method。如下：

package springBeanTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author qsk
 */
public class Person implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {

    private String name;
    private String address;
    private int phone;

    private BeanFactory beanFactory;
    private String beanName;

    public Person() {
        System.out.println("【构造器】调用Person的构造器实例化");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【注入属性】注入属性name");
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("【注入属性】注入属性address");
        this.address = address;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        System.out.println("【注入属性】注入属性phone");
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Person [address=" + address + ", name=" + name + ", phone="
                + phone + "]";
    }

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        System.out
                .println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = arg0;
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String arg0) {
        System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
        this.beanName = arg0;
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out
                .println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
    }

    // 通过<bean>的init-method属性指定的初始化方法
    public void myInit() {
        System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
    }

    // 通过<bean>的destroy-method属性指定的初始化方法
    public void myDestory() {
        System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
    }
}

接下来是演示BeanPostProcessor接口的方法，如下：

package springBeanTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author qsk
 */
public class Person implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {

    private String name;
    private String address;
    private int phone;

    private BeanFactory beanFactory;
    private String beanName;

    public Person() {
        System.out.println("【构造器】调用Person的构造器实例化");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【注入属性】注入属性name");
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("【注入属性】注入属性address");
        this.address = address;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        System.out.println("【注入属性】注入属性phone");
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Person [address=" + address + ", name=" + name + ", phone="
                + phone + "]";
    }

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        System.out
                .println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = arg0;
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String arg0) {
        System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
        this.beanName = arg0;
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out
                .println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
    }

    // 通过<bean>的init-method属性指定的初始化方法
    public void myInit() {
        System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
    }

    // 通过<bean>的destroy-method属性指定的初始化方法
    public void myDestory() {
        System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
    }
}

package springBeanTest;

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

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        super();
        System.out.println("这是BeanPostProcessor实现类构造器！！");
        // TODO Auto-generated constructor stub
    }

    @Override
    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out
        .println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
        return arg0;
    }

    @Override
    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out
        .println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
        return arg0;
    }
}

如上，BeanPostProcessor接口包括2个方法postProcessAfterInitialization和postProcessBeforeInitialization，这两个方法的第一个参数都是要处理的Bean对象，第二个参数都是Bean的name。返回值也都是要处理的Bean对象。这里要注意。

3、InstantiationAwareBeanPostProcessor 接口本质是BeanPostProcessor的子接口，一般我们继承Spring为其提供的适配器类InstantiationAwareBeanPostProcessor Adapter来使用它，如下：

package springBeanTest;

import java.beans.PropertyDescriptor;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

public class MyInstantiationAwareBeanPostProcessor extends
        InstantiationAwareBeanPostProcessorAdapter {

    public MyInstantiationAwareBeanPostProcessor() {
        super();
        System.out
                .println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
    }

    // 接口方法、实例化Bean之前调用
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass,
            String beanName) throws BeansException {
        System.out
                .println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
        return null;
    }

    // 接口方法、实例化Bean之后调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out
                .println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
        return bean;
    }

    // 接口方法、设置某个属性时调用
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs,
            PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException {
        System.out
                .println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
        return pvs;
    }
}

4、演示工厂后处理器接口方法，如下：

package springBeanTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
            throws BeansException {
        System.out
                .println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
        BeanDefinition bd = arg0.getBeanDefinition("person");
        bd.getPropertyValues().addPropertyValue("phone", "110");
    }

}

5、配置文件如下beans.xml，很简单，使用ApplicationContext,处理器不用手动注册：

5、配置文件如下beans.xml，很简单，使用ApplicationContext,处理器不用手动注册：

6、测试一下

package springBeanTest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifeCycle {

    public static void main(String[] args) {

        System.out.println("现在开始初始化容器");

        ApplicationContext factory = new ClassPathXmlApplicationContext("springBeanTest/beans.xml");
        System.out.println("容器初始化成功");
        //得到Preson，并使用
        Person person = factory.getBean("person",Person.class);
        System.out.println(person);

        System.out.println("现在开始关闭容器！");
        ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
    }
}```
关闭容器使用的是实际是AbstractApplicationContext的钩子方法。

我们来看一下结果：

```c
现在开始初始化容器
2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; root of context hierarchy
2014-5-18 15:46:20 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [springBeanTest/beans.xml]
这是BeanFactoryPostProcessor实现类构造器！！
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器！！
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
【构造器】调用Person的构造器实例化
InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
【注入属性】注入属性address
【注入属性】注入属性name
【注入属性】注入属性phone
【BeanNameAware接口】调用BeanNameAware.setBeanName()
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
容器初始化成功
Person [address=广州, name=张三, phone=110]
现在开始关闭容器！
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法

spring三级缓存

刚刚我们介绍了bean的生命周期，但是没有如果属性是对象，怎么实现依赖自动注入，又怎么规避循环依赖

循环依赖：A -> B ，B -> A
初始化时循环依赖借助三级缓存解决。利用半成品对象实现依赖，等初始化完成后就依赖了完整的对象。
SpringBean在实例化完成后、会放进三级缓存供其他对象使用（未初始化和设置属性的半成品）。

获取bean时、依次从一级缓存、二级缓存、三级缓存拿，可以看到从三级缓存拿到后会直接放进二级缓存（应对AOP情况下的循环依赖）
来看看三级缓存源码

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
        //第1级缓存 用于存放 已经属性赋值、完成初始化的 单列BEAN
        private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
        //第2级缓存 用于存在已经实例化，还未做代理属性赋值操作的 单例BEAN
        private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
        //第3级缓存 存储创建单例BEAN的工厂
        private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
        //已经注册的单例池里的beanName
        private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
        //正在创建中的beanName集合
        private final Set<String> singletonsCurrentlyInCreation =
                Collections.newSetFromMap(new ConcurrentHashMap<>(16));
        //缓存查找bean  如果第1级缓存没有，那么从第2级缓存获取。如果第2级缓存也没有，那么从第3级缓存创建，并放入第2级缓存。
        protected Object getSingleton(String beanName, boolean allowEarlyReference) {
            Object singletonObject = this.singletonObjects.get(beanName); //第1级
            if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
                synchronized (this.singletonObjects) {
                    singletonObject = this.earlySingletonObjects.get(beanName); //第2级
                    if (singletonObject == null && allowEarlyReference) {
                        //第3级缓存  在doCreateBean中创建了bean的实例后，封装ObjectFactory放入缓存的bean实例
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            //创建未赋值的bean
                            singletonObject = singletonFactory.getObject();
                            //放入到第2级缓存
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            //从第3级缓存删除
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
            return singletonObject;
        }   
    }

每次执行singleFactory.getObject()方法又会产生新的代理对象，假设这里只有一级和三级缓存的话，我每次从三级缓存中拿到singleFactory对象，执行getObject()方法又会产生新的代理对象，这是不行的，因为对象是单例的。
（2）“添加到第1级缓存”的源码：

 protected void addSingleton(String beanName, Object singletonObject) {
            synchronized (this.singletonObjects) {
                // 放入第1级缓存
                this.singletonObjects.put(beanName, singletonObject);
                // 从第3级缓存删除
                this.singletonFactories.remove(beanName);
                // 从第2级缓存删除
                this.earlySingletonObjects.remove(beanName);
                // 放入已注册的单例池里
                this.registeredSingletons.add(beanName);
            }
        }

（3）“添加到第3级缓存”的源码：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
            synchronized (this.singletonObjects) {
                // 若第1级缓存没有bean实例
                if (!this.singletonObjects.containsKey(beanName)) {
                    // 放入第3级缓存
                    this.singletonFactories.put(beanName, singletonFactory);
                    // 从第2级缓存删除，确保第2级缓存没有该bean
                    this.earlySingletonObjects.remove(beanName);
                    // 放入已注册的单例池里
                    this.registeredSingletons.add(beanName);
                }
            }
        }

（4）“创建Bean”的源码：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    
    if (instanceWrapper == null) {
        //实例化对象
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }
 
    final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
    Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
   
    //判断是否允许提前暴露对象，如果允许，则直接添加一个 ObjectFactory 到第3级缓存
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        //添加到第3级缓存
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
 
    //填充属性
    this.populateBean(beanName, mbd, instanceWrapper);
    //执行初始化方法，并创建代理
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    return exposedObject;
}

通过这段代码，我们可以知道：Spring 在实例化对象之后，就会为其创建一个 Bean 工厂，并将此工厂加入到三级缓存中。
因此，Spring 一开始提前暴露的并不是实例化的 Bean，而是将 Bean 包装起来的ObjectFactory。为什么要这么做呢？

这实际上涉及到 AOP。如果创建的 Bean 是有代理的，那么注入的就应该是代理 Bean，而不是原始的 Bean。但是，Spring一开始并不知道 Bean是否会有循环依赖，通常情况下（没有循环依赖的情况下），Spring 都会在“完成填充属性并且执行完初始化方法”之后再为其创建代理。但是，如果出现了循环依赖，Spring 就不得不为其提前创建"代理对象"；否则，注入的就是一个原始对象，而不是代理对象。因此，这里就涉及到"应该在哪里提前创建代理对象"？
Spring 的做法就是：在 ObjectFactory 中去提前创建代理对象。它会执行 getObject() 方法来获取到 Bean。实际上，它真正执行的方法如下：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                // 如果需要代理，这里会返回代理对象；否则，返回原始对象。
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

提前进行对象的代理工作，并在 earlyProxyReferences map中记录已被代理的对象，是为了避免在后面重复创建代理对象。

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 记录已被代理的对象
        this.earlyProxyReferences.put(cacheKey, bean);
        return wrapIfNecessary(bean, beanName, cacheKey);
    }
}

再次分析获取bean的方法getSingleton()方法，可知：

提前暴露的对象，虽然已实例化，但是没有进行属性填充，还没有完成初始化，是一个不完整的对象。 这个对象存放在二级缓存中，对于三级缓存机制十分重要，是解决循环依赖一个非常巧妙的设计。

让我们来分析一下“A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情景。

• A 调用doCreateBean()创建Bean对象：由于还未创建，从第1级缓存singletonObjects查不到，此时只是一个半成品（提前暴露的对象），放入第3级缓存singletonFactories。
• A在属性填充时发现自己需要B对象，但是在三级缓存中均未发现B，于是创建B的半成品，放入第3级缓存singletonFactories。
• B在属性填充时发现自己需要A对象，从第1级缓存singletonObjects和第2级缓存earlySingletonObjects中未发现A，但是在第3级缓存singletonFactories中发现A，将A放入第2级缓存earlySingletonObjects，同时从第3级缓存singletonFactories删除。
• 将A注入到对象B中。
• B完成属性填充，执行初始化方法，将自己放入第1级缓存singletonObjects中（此时B是一个完整的对象），同时从第3级缓存singletonFactories和第2级缓存earlySingletonObjects中删除。
• A得到“对象B的完整实例”，将B注入到A中。
• A完成属性填充，执行初始化方法，并放入到第1级缓存singletonObjects中。

在创建过程中，都是从第三级缓存(对象工厂创建不完整对象)，将提前暴露的对象放入到第二级缓存；从第二级缓存拿到后，完成初始化，并放入第一级缓存。

引用：
1、https://evernote.blog.csdn.net/article/details/122963121?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-122963121-blog-123629043.pc_relevant_3mothn_strategy_recovery&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-122963121-blog-123629043.pc_relevant_3mothn_strategy_recovery&utm_relevant_index=1
2、https://www.cnblogs.com/chengxuxiaoyuan/p/15394864.html#1%E5%BE%97%E5%88%B0beandefinition
3、https://blog.csdn.net/Java_3y/article/details/119871652?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166952459616782412555767%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=166952459616782412555767&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_blogfirst_rank_ecpm_v1~rank_v31_ecpm-1-119871652-null-null.nonecase&utm_term=spring&spm=1018.2226.3001.4450
4、https://www.cnblogs.com/cxxjohnson/p/14617248.html