springbean生命周期通俗一点_spring为啥是单例模式

一、Spring核心模块介绍

1. Spring Core：
Core封装包是框架的最基础部分，提供IOC和依赖注入特性。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

2.Spring Context:
构建于Core封装包基础上的 Context封装包，提供了一种框架式的对象访问方法，有些象JNDI注册器。Context封装包的特性得自于Beans封装包，并添加了对国际化（I18N）的支持（例如资源绑定），事件传播，资源装载的方式和Context的透明创建，比如说通过Servlet容器。

3.Spring DAO:
DAO (Data Access Object)提供了JDBC的抽象层，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。并且，JDBC封装包还提供了一种比编程性更好的声明性事务管理方法，不仅仅是实现了特定接口，而且对所有的POJOs（plain old Java objects）都适用。

4.Spring ORM:
ORM 封装包提供了常用的“对象/关系”映射APIs的集成层。其中包括JPA、JDO、Hibernate 和 iBatis 。利用ORM封装包，可以混合使用所有Spring提供的特性进行“对象/关系”映射，如前边提到的简单声明性事务管理。

5.Spring AOP:
Spring的 AOP 封装包提供了符合AOP Alliance规范的面向方面的编程实现，让你可以定义，例如方法拦截器（method-interceptors）和切点（pointcuts），从逻辑上讲，从而减弱代码的功能耦合，清晰的被分离开。而且，利用source-level的元数据功能，还可以将各种行为信息合并到你的代码中。

6.Spring Web:
Spring中的 Web 包提供了基础的针对Web开发的集成特性，例如多方文件上传，利用Servlet listeners进行IOC容器初始化和针对Web的ApplicationContext。当与WebWork或Struts一起使用Spring时，这个包使Spring可与其他框架结合。

7.Spring Web MVC:
Spring中的MVC封装包提供了Web应用的Model-View-Controller（MVC）实现。Spring的MVC框架并不是仅仅提供一种传统的实现，它提供了一种清晰的分离模型，在领域模型代码和Web Form之间。并且，还可以借助Spring框架的其他特性。

二、BeanFactory、ApplicationContext和FactoryBean的区别

1、 BeanFactory 和 ApplicationContext 的区别

Spring提供了两种不同的 IOC 容器，一个是BeanFactory，另外一个是ApplicationContext，它们都是Java interface，ApplicationContext 继承于 BeanFactory【ApplicationContext继承ListableBeanFactory；它们都可以用来配置XML属性，也支持属性的自动注入。而ListableBeanFactory继承BeanFactory】，BeanFactory 和 ApplicationContext 都提供了一种方式，使用getBean(“bean name”)获取bean

Spring IOC容器初始化的过程

什么是IOC容器呢? 所谓的IOC容器是指的spring bean 工厂里面Map存储结构 (存储了bean的实例)

BeanFactory：BeanFactory 是 IoC 容器的顶级接口，是IoC容器的最基础实现，也是访问Spring容器的根接口，负责对bean的创建，访问等工作。实现类功能比较单一，BeanFactory接口实现的容器，特点是在每次获取对象时才会创建对象。
ApplicationContext：继承了BeanFactory接口，拥有BeanFactory的全部功能，并且扩展了很多高级特性，每次容器启动时就会创建所有的对象。

两者装载bean的区别

BeanFactory：BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；

延迟实例化的优点：

应用启动的时候占用资源很少；对资源要求较高的应用，比较有优势；

ApplicationContext：ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化；

不延迟实例化的优点：

所有的Bean在启动的时候都加载，系统运行的速度快；

在启动的时候所有的Bean都加载了，我们就能在系统启动的时候，尽早的发现系统中的配置问题

建议web应用，在启动的时候就把所有的Bean都加载了。（把费时的操作放到系统启动中完成）

2、FactoryBean

首先它是一个Bean，但又不仅仅是一个Bean。它是一个能生产或修饰对象生成的工厂Bean，类似于设计模式中的工厂模式和装饰器模式。它能在需要的时候生产一个对象，且不仅仅限于它自身，它能返回任何Bean的实例

BeanFactory:

1: 负责生产和管理bean的一个工厂。

2：事IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象的依赖。

3：多种实现：如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是常用的一个，该实现将以XML方式描述组成应用的对象及对象间的依赖关系。

三、Spring IOC容器启动加载流程（重点）

整体流程如此图

1、Bean信息扫描加载进Bean定义信息注册表（BeanDefiniton）

2、Bean的生命周期（创建流程）

核心流程就几个：getBean –》实例化 –》填充属性 –》初始化 –》加入IOC容器

实例化有拆分流程：在内存开辟空间，实例化对象的属性都是默认值

填充属性有拆分流程：三级缓存循环依赖问题的流程

初始化有拆分流程：一系列的 Aware–》一系列的 PostProcessor

四、Bean的生命周期

Spring bean的生命周期颇为复杂，以下是整个过程，参考org.springframework.beans.factory.BeanFactory

在传统的Java应用中，bean的生命周期很简单，使用Java关键字 new 进行Bean 的实例化，然后该Bean 就能够使用了。一旦bean不再被使用，则由Java自动进行垃圾回收。

相比之下，Spring管理Bean的生命周期就复杂多了，正确理解Bean 的生命周期非常重要，因为Spring对Bean的管理可扩展性非常强，下面展示了一个Bean的构造过程

Bean 的生命周期

如上图所示，Bean 的生命周期还是比较复杂的，下面来对上图每一个步骤做文字描述:

Spring启动，查找并加载需要被Spring管理的bean，进行Bean的实例化

Bean实例化后对将Bean的引入和值注入到Bean的属性中

如果Bean实现了BeanNameAware接口，Spring将Bean的Id传递给setBeanName()方法

如果Bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入

如果Bean实现了ApplicationContextAware接口，Spring将调用Bean的setApplicationContext()方法，将应用上下文的引用传入到bean中

如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessBeforeInitialization()方法

如果Bean 实现了InitializingBean接口，Spring将调用他们的afterPropertiesSet()方法。类似的，如果bean使用init-method声明了初始化方法，该方法也会被调用

如果Bean 实现了BeanPostProcessor接口，Spring就将调用他们的postProcessAfterInitialization()方法

此时，Bean已经准备就绪，可以被应用程序使用了。他们将一直驻留在应用上下文中，直到应用上下文被销毁。

如果Bean实现了DisposableBean接口，Spring将调用它的destory()接口方法，同样，如果bean使用了destory-method 声明销毁方法，该方法也会被调用

上面是Spring 中Bean的核心接口和生命周期，面试回答上述过程已经足够了。但是翻阅JavaDoc文档发现除了以上接口外，还有另外的初始化过程涉及的接口：
摘自org.springframework.beans.factory.BeanFactory，全部相关接口如下，上述已有的就不用着重标注，把额外的相关接口着重标注下

Bean 完整的生命周期

文字解释如下：

————————————初始化————————————

BeanNameAware.setBeanName() 在创建此bean的bean工厂中设置bean的名称，在普通属性设置之后调用，在InitializinngBean.afterPropertiesSet()方法之前调用

BeanClassLoaderAware.setBeanClassLoader(): 在普通属性设置之后，InitializingBean.afterPropertiesSet()之前调用

BeanFactoryAware.setBeanFactory() : 回调提供了自己的bean实例工厂，在普通属性设置之后，在InitializingBean.afterPropertiesSet()或者自定义初始化方法之前调用

EnvironmentAware.setEnvironment(): 设置environment在组件使用时调用

EmbeddedValueResolverAware.setEmbeddedValueResolver(): 设置StringValueResolver 用来解决嵌入式的值域问题

ResourceLoaderAware.setResourceLoader(): 在普通bean对象之后调用，在afterPropertiesSet 或者自定义的init-method 之前调用，在 ApplicationContextAware 之前调用。

ApplicationEventPublisherAware.setApplicationEventPublisher(): 在普通bean属性之后调用，在初始化调用afterPropertiesSet 或者自定义初始化方法之前调用。在 ApplicationContextAware 之前调用。

MessageSourceAware.setMessageSource(): 在普通bean属性之后调用，在初始化调用afterPropertiesSet 或者自定义初始化方法之前调用，在 ApplicationContextAware 之前调用。

ApplicationContextAware.setApplicationContext(): 在普通Bean对象生成之后调用，在InitializingBean.afterPropertiesSet之前调用或者用户自定义初始化方法之前。在ResourceLoaderAware.setResourceLoader，ApplicationEventPublisherAware.setApplicationEventPublisher，MessageSourceAware之后调用。

ServletContextAware.setServletContext(): 运行时设置ServletContext，在普通bean初始化后调用，在InitializingBean.afterPropertiesSet之前调用，在 ApplicationContextAware 之后调用注：是在WebApplicationContext 运行时

BeanPostProcessor.postProcessBeforeInitialization() : 将此BeanPostProcessor 应用于给定的新bean实例在任何bean初始化回调方法(像是InitializingBean.afterPropertiesSet或者自定义的初始化方法）之前调用。这个bean将要准备填充属性的值。返回的bean示例可能被普通对象包装，默认实现返回是一个bean。

BeanPostProcessor.postProcessAfterInitialization() : 将此BeanPostProcessor 应用于给定的新bean实例在任何bean初始化回调方法(像是InitializingBean.afterPropertiesSet或者自定义的初始化方法)之后调用。这个bean将要准备填充属性的值。返回的bean示例可能被普通对象包装

InitializingBean.afterPropertiesSet(): 被BeanFactory在设置所有bean属性之后调用(并且满足BeanFactory 和 ApplicationContextAware)。

————————————销毁————————————

在BeanFactory 关闭的时候，Bean的生命周期会调用如下方法:

DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(): 在销毁之前将此BeanPostProcessor 应用于给定的bean实例。能够调用自定义回调，像是DisposableBean 的销毁和自定义销毁方法，这个回调仅仅适用于工厂中的单例bean(包括内部bean)

实现了自定义的destory()方法

在 Spring 中，那些组成应用程序的主体及由 Spring IOC 容器所管理的对象，被称之为 bean。简单地讲，bean 就是由 IOC 容器初始化、装配及管理的对象，除此之外，bean 就与应用程序中的其他对象没有什么区别了。而 bean 的定义以及 bean 相互间的依赖关系将通过配置元数据来描述。

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。

1、各种接口方法分类

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

Bean自身的方法：这个包括了Bean本身调用的方法和通过配置文件中的init-method 和 destroy-method指定的方法

Bean级生命周期接口方法：这个包括了BeanNameAware、BeanFactoryAware、InitializingBean 和 DiposableBean这些接口的方法

容器级生命周期接口方法：这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。

工厂后处理器接口方法：这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

只有四个！

是的，Spring Bean的生命周期只有这四个阶段。把这四个阶段和每个阶段对应的扩展点糅合在一起虽然没有问题，但是这样非常凌乱，难以记忆。要彻底搞清楚Spring的生命周期，首先要把这四个阶段牢牢记住。实例化和属性赋值对应构造方法和setter方法的注入，初始化和销毁是用户能自定义扩展的两个阶段。在这四步之间穿插的各种扩展点，稍后会讲。

实例化 Instantiation

属性赋值 Populate

初始化 Initialization

销毁 Destruction

实例化 -> 属性赋值 -> 初始化 -> 销毁

IoC容器的初始化过程
一.Resource的定位
也就是BeanDefinition的资源定位，ResourceLoader接口完成，方式包括ClassPathContextResource,FileSystemContextResource,SerlvetContextResource
二.BeanDefinition载入
将配置文件中的Bean，表示成IoC容器中的数据结构BeanDefinition，使IoC容器可以对其管理
三.向IoC容器中注册BeanDefinition
将BeanDefinition注册到IoC中的HashMap中
四.依赖注入
lazy-init:在IoC容器中实例化时查找其的依赖，并将依赖设置为其的属性
正常是在第一次getBean时进行依赖注入
五.初始化Bean
回调设置的postProcessBeforeInitialization/postProcessAfterInitialization,执行初始化方法

Bean的生命周期
1.Bean实例的创建（一，二，三）
2.为Bean设置属性（四）
3.调用Bean的初始化方法（五）
4.通过IoC容器使用Bean
5.当容器销毁时，调用Bean的销毁方法

五、Bean 的生命周期验证

为了验证Bean生命周期的过程，有两种形式：一种是为面试而准备的，一种是为了解全过程而准备的，下面来看代码：

Book.class

public class Book implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {



    private String bookName;

    public String getBookName() {

        return bookName;

    }

    public void setBookName(String bookName) {

        this.bookName = bookName;

        System.out.println("setBookName: Book name has set.");

    }





    public Book(){

        System.out.println("Book Initializing ");

    }



    //重写自BeanNameAware

    @Override

    public void setBeanName(String s) {

        System.out.println("Book.setBeanName invoke");

    }

    //重写自BeanFactoryAware

    @Override

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

        System.out.println("Book.setBeanFactory invoke");

    }

    //重写自ApplicationContextAware

    @Override

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        System.out.println("Book.setApplicationContext invoke");

    }

    //重写自InitializingBean

    @Override

    public void afterPropertiesSet() throws Exception {

        System.out.println("Book.afterPropertiesSet invoke");

    }

    //重写自DisposableBean

    @Override

    public void destroy() throws Exception {

        System.out.println("Book.destory invoke");

    }



    // 自定义初始化方法

    @PostConstruct

    public void springPostConstruct(){

        System.out.println("@PostConstruct");

    }

    // 自定义销毁方法

    @PreDestroy

    public void springPreDestory(){

        System.out.println("@PreDestory");

    }





    //xml文件配置的init-method

    public void myPostConstruct(){

        System.out.println("Book.myPostConstruct invoke");

    }

    //xml文件配置的destroy-method

    public void myPreDestory(){

        System.out.println("Book.myPreDestory invoke");

        System.out.println("---------------destroy-----------------");

    }



    @Override

    protected void finalize() throws Throwable {

        System.out.println("------inside finalize-----");

    }





}

自定义实现BeanPostProcessor 的MyBeanPostProcessor：

public class MyBeanPostProcessor implements BeanPostProcessor {



    // 容器加载的时候会加载一些其他的bean，会调用初始化前和初始化后方法

    // 这次只关注book(bean)的生命周期

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        if(bean instanceof Book){

            System.out.println("MyBeanPostProcessor.postProcessBeforeInitialization");

        }

        return bean;

    }



    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        if(bean instanceof Book){

            System.out.println("MyBeanPostProcessor.postProcessAfterInitialization");

        }

        return bean;

    }

}

在resources 目录下新建Bean-Lifecycle.xml


       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

做一个启动类的测试，新建SpringBeanLifecycleApplication

public class SpringBeanLifecycleApplication {



    public static void main(String[] args) throws InterruptedException {

        // 为面试而准备的Bean生命周期加载过程

        ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");

        Book book = (Book)context.getBean("book");

        System.out.println("Book name = " + book.getBookName());

        ((ClassPathXmlApplicationContext) context).destroy();



    }



}

启动测试，输出结果如下：

Book Initializing
setBookName: Book name has set.
Book.setBeanName invoke
Book.setBeanFactory invoke
Book.setApplicationContext invoke
MyBeanPostProcessor.postProcessBeforeInitialization
@PostConstruct
Book.afterPropertiesSet invoke
Book.myPostConstruct invoke
MyBeanPostProcessor.postProcessAfterInitialization
Book name = thingking in java
@PreDestory
Book.destory invoke
Book.myPreDestory invoke
—————destroy—————–

为了验证Bean完整的生命周期，需要新建一个SubBookClass 继承Book类

public class SubBookClass extends Book implements BeanClassLoaderAware,

        EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,

        ApplicationEventPublisherAware,MessageSourceAware{



    private String bookSystem;



    public String getBookSystem() {

        return bookSystem;

    }



    public void setBookSystem(String bookSystem) {

        System.out.println("设置BookSystem 的属性值");

        this.bookSystem = bookSystem;

    }



    public void setBeanClassLoader(ClassLoader classLoader) {

        System.out.println("SubBookClass.setBeanClassLoader() 方法被调用了");

    }



    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {

        System.out.println("SubBookClass.setApplicationEventPublisher() 方法被调用了");

    }



    public void setEmbeddedValueResolver(StringValueResolver resolver) {

        System.out.println("SubBookClass.setEmbeddedValueResolver() 方法被调用了");

    }



    public void setEnvironment(Environment environment) {

        System.out.println("SubBookClass.setEnvironment() 方法被调用了");

    }



    public void setMessageSource(MessageSource messageSource) {

        System.out.println("SubBookClass.setMessageSource() 方法被调用了");

    }



    public void setResourceLoader(ResourceLoader resourceLoader) {

        System.out.println("SubBookClass.setResourceLoader() 方法被调用了");

    }



}

上述SubBookClass类与Book是互补关系。

新建一个SubBean-Lifecycle.xml，注入SubBookClass


       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

完整的SpringBeanLifecycleApplication 如下：

public class SpringBeanLifecycleApplication {



    public static void main(String[] args) throws InterruptedException {

        // 为面试而准备的Bean生命周期加载过程

        ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");

        Book book = (Book)context.getBean("book");

        System.out.println("Book name = " + book.getBookName());

        ((ClassPathXmlApplicationContext) context).destroy();



        // 完整的加载过程，当然了解的越多越好

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("SubBean-Lifecycle.xml");

        SubBookClass subBookClass = (SubBookClass) applicationContext.getBean("bookClass");

        System.out.println("BookSystemName = " + subBookClass.getBookSystem());

        ((ClassPathXmlApplicationContext) applicationContext).registerShutdownHook();

    }



}

输出完整的结果：

Book Initializing
setBookName: Book name has set.
Book.setBeanName invoke
Book.setBeanFactory invoke
Book.setApplicationContext invoke
MyBeanPostProcessor.postProcessBeforeInitialization
@PostConstruct
Book.afterPropertiesSet invoke
Book.myPostConstruct invoke
MyBeanPostProcessor.postProcessAfterInitialization
Book name = thingking in java
@PreDestory
Book.destory invoke
Book.myPreDestory invoke
—————destroy—————–
Book Initializing
设置BookSystem 的属性值
Book.setBeanName invoke
SubBookClass.setBeanClassLoader() 方法被调用了
Book.setBeanFactory invoke
SubBookClass.setEnvironment() 方法被调用了
SubBookClass.setEmbeddedValueResolver() 方法被调用了
SubBookClass.setResourceLoader() 方法被调用了
SubBookClass.setApplicationEventPublisher() 方法被调用了
SubBookClass.setMessageSource() 方法被调用了
Book.setApplicationContext invoke
MyBeanPostProcessor.postProcessBeforeInitialization
Book.afterPropertiesSet invoke
Book.myPostConstruct invoke
MyBeanPostProcessor.postProcessAfterInitialization
BookSystemName = Java System
Book.destory invoke
Book.myPreDestory invoke
—————destroy—————–