Spring Bean 的生命周期

最新推荐文章于 2024-08-06 21:54:54 发布
最新推荐文章于 2024-08-06 21:54:54 发布
阅读量276 收藏
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qmqm011/article/details/84973113
版权

​我们知道 Servlet 拥有明确的生命周期，Spring 容器中的 Bean 也拥有相似的生命周期。Spring Bean 的生命周期从创建Spring容器开始，直到 Spring 容器销毁 Bean。Bean的生命周期由多个特定的生命阶段组成，每个生命阶段都开出了一扇门（提供一些接口），允许外界对 Bean 施加控制。在 Spring 中，可以从两个层面定义 Bean 的生命周期：第一个层面是 Bean 的作用范围；第二个层面是实例化 Bean 时所经历的一系列阶段。下面分别对 BeanFactory 和 ApplicationContext 中 Bean 的生命周期进行分析。

BeanFactory 中 Bean 的生命周期

下图展示了 BeanFactory 中 Bean 的生命周期：

1、当调用者通过 getBean(String name) 方法向容器请求某一个 Bean 时，如果容器注册了 InstantiationAwareBeanPostProcesser 接口，在实例化 Bean 之前，将调用接口的 postProcessBeforeInstantiation() 方法。

​2、根据配置调用 Bean 的构造函数或工厂方法实例化 Bean。

​3、如果容器注册了 InstantiationAwareBeanPostProcesser 接口，在实例化Bean之后，将调用接口的 postProcessAfterInstantiation() 方法。

​4、如果 Bean 配置了属性信息，容器将为 Bean 设置对应的属性值，不过在设置属性之前将调用 InstantiationAwareBeanPostProcesser 接口的 postProcessPropertyValues() 方法。

5、调用 Bean 的属性设置方法设置属性值。

6、如果 Bean 实现了 BeanNameAware 接口，将调用 setBeanName() 方法，将配置文件中该 Bean 对应的名称设置到 Bean 中。

7、如果 Bean 实现了 BeanFactoryAware 接口，将调用 setBeanFactory() 方法，将 BeanFactory 容器实例设置到 Bean 中。

​8、如果 BeanFactory 装配了 BeanPostProcesser 后处理器，将调用 BeanPostProcesser 的 postProcessBeforeInitialization(Object bean, String beanName) 方法对 Bean 进行加工操作。入参 bean 是当前正在操作的 Bean，beanName 是当前 Bean 的配置名，返回的对象是处理后的 Bean。可以使用该方法对 Bean 进行特殊处理，甚至改变 Bean 的行为。BeanPostProcesser 在 Spring 中占有重要地位，Spring 容器所提供的各种神奇的功能（如AOP，动态代理等）都是通过BeanPostProcesser 实施。

​9、如果 Bean 实现了 InitializingBean 接口，将调用接口的 AfterPropertiesSet() 方法。

10、如果在 bean 元素中指定了 init-method 方法，将执行这个方法。

11、BeanPostProcesser 后处理器定义了两个方法，其一在第八步执行，其二是 postProcessAfterInitialization(Object bean, String beanName)，在此时调用，容器将再次获得对 Bean 进行加工处理的机会。

12、如果在 bean 元素中指定了 Bean 的作用范围为 scope="prototype"，则将 Bean 返回给调用者，调用者负责后续 Bean 的生命周期管理，Spring 不再管理这个 Bean 的生命周期。如果作用范围设置为 scope="singleton"（默认就是单例），则将 Bean 放置到 Spring IoC 容器的缓存池中，并将 Bean 返回给调用者，Spring 继续对这些 Bean 进行后续生命周期管理。

13、对于 scope="singleton" 的 Bean，当容器关闭时，将触发 Spring 对 Bean 的后续生命周期管理工作。首先如果 Bean 实现了DisposableBean 接口，则将调用接口的 afterPropertiesSet() 方法，可以在此编写释放资源、记录日志等操作。

​14、对于 scope="singleton" 的 Bean，如果通过 bean 元素指定了 destroy-method 属性，Spring 将执行 Bean 的这个方法，完成 Bean 资源的释放操作。​

Bean 的完整生命周期从 Spring 容器着手实例化 Bean 开始，直到最终销毁 Bean，这当中经过了许多关键点，每个关键点都涉及特定的方法调用，可以将这些方法大致划分为三类：

• Bean 自身的方法：如调用 Bean 构造函数实例化 Bean，调用 Setter 设置 Bean 的属性值以及调用通过 init-method 和 destroy-method 所指定的方法；

• Bean 级生命周期接口方法：如 BeanNameAware、BeanFactoryAware、InitializingBean 和 DisposableBean，这些接口方法由 Bean 类直接实现。

• 容器级生命周期接口方法：上图中带 ★ 的步骤是由 InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为后处理器，后处理器一般不由 Bean 本身实现，它们独立于 Bean，它们的实现类以 Bean 的形式注册到 Spring 容器中，Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用，所以这些后处理器的影响是全局的。当然，可以通过合理的编写后处理器，让其仅对感兴趣的 Bean 进行加工处理（比如判断 Bean 的类型，或者 Bean 的名称）。

Bean 级生命周期接口和容器级生命周期接口是个性和共性辩证统一思想的体现，前者解决 Bean 个性化处理的问题；而后者解决容器中某些 Bean 共性化处理的问题。

Spring 容器中可以注册多个后处理器，通过 @Order 注解指定它们生效的顺序，容器将按照特定顺序依次调用这些后处理器。

下面看一下 BeanFactory 中 Bean 的生命周期的例子。

Car.java：

package com.wuychn.beanlifecycle.beanfactory;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

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

    private String brand;
    private String color;
    private int maxSpeed;

    private BeanFactory beanFactory;
    private String beanName;


    public Car() {
        System.out.println("调用Car()构造函数...");
    }

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

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

    // DisposableBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("调用DisposableBean.destroy()方法...");
    }

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

    // 通过<bean>的init-method属性指定的初始化方法
    public void myInit() {
        System.out.println("调用init-method指定的myinit()方法，将maxSpeed设置为240...");
        this.maxSpeed = 240;
    }

    // 通过<bean>destroy-method属性指定的销毁方法
    public void myDestroy() {
        System.out.println("调用destroy-myDestroy()方法...");
        this.maxSpeed = 240;
    }

    public void setBrand(String brand) {
        System.out.println("调用setBrand()设置属性...");
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }


    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        System.out.println("调用setColor()设置属性...");
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        System.out.println("调用setMaxSpeed()设置属性...");
        this.maxSpeed = maxSpeed;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    public String getBeanName() {
        return beanName;
    }

    public void introduce() {
        System.out.println("brand: " + brand + ", color: " + color + ", maxSpeed: " + maxSpeed);
    }


}

Car 类实现了 BeanFactoryAware、BeanNameAware、InitializingBean、DisposableBean 这些 Bean 级生命周期控制接口，定义了 myInit()、和 myDestroy() 方法，以便在配置文件中通过 init-method 和 destroy-method 属性定义初始化和销毁方法。

MyInstantiationAwareBeanPostProcessor.java：

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

import java.beans.PropertyDescriptor;

public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    // 在实例化Bean前调用
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // 仅对 Car Bean进行处理
        if ("car".equals(beanName)) {
            System.out.println("调用MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法...");
        }
        return null;
    }

    // 实例化 Bean 后调用
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // 仅对 Car Bean进行处理
        if ("car".equals(beanName)) {
            System.out.println("调用MyInstantiationAwareBeanPostProcessor.postProcessAfterInstantiation方法...");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return null;
    }

    // 设置某个属性时调用
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        // 仅对 Car Bean进行处理
        if ("car".equals(beanName)) {
            System.out.println("调用MyInstantiationAwareBeanPostProcessor.postProcessProperties方法...");
        }
        return pvs;
    }

}

MyInstantiationAwareBeanPostProcessor 中，仅对名为 car 的 Bean 进行处理。

MyBeanPostProcessor.java：

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 {
        if ("car".equals(beanName)) {
            Car car = (Car) bean;
            if (car.getColor() == null) {
                System.out.println("调用MyBeanPostProcessor.postProcessBeforeInitialization方法，color为空，设置为默认黑色");
                car.setColor("黑色");
            }
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("car".equals(beanName)) {
            Car car = (Car) bean;
            if (car.getMaxSpeed() >= 200) {
                System.out.println("调用MyBeanPostProcessor.postProcessAfterInitialization方法，将maxSpeed调整为200");
                car.setMaxSpeed(200);
            }
        }
        return bean;
    }
}

在 MyBeanPostProcessor 类的 postProcessBeforeInitialization() 方法中，首先判断处理的 Bean 是否名为 car，如果是，进一步判断该 Bean 的 color 属性是否为空，如果为空，将该属性设置为“黑色”。在 postProcessAfterInitialization() 方法中，也是只对名为 car 的 Bean 进行处理，判断其 maxSpeed 是否超过最大速度200，如果超过，将其设置为200。

applicationContext.xml 中，Car 的配置如下：

<?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="car" class="com.wuychn.beanlifecycle.beanfactory.Car"
          init-method="myInit"
          destroy-method="myDestroy">
        <property name="brand" value="奔驰S600L"/>
        <property name="maxSpeed" value="200"/>
    </bean>

</beans>

接下来启动容器，然后注册上面所提供的两个后处理器：

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

public class BeanFactoryLifeCycle {

    public static void startLifeCycle() {
        Resource resource = new PathMatchingResourcePatternResolver().getResource("classpath:applicationContext.xml");
        BeanFactory beanFactory = new XmlBeanFactory(resource);

        // 注册后处理器
        ((XmlBeanFactory) beanFactory).addBeanPostProcessor(new MyBeanPostProcessor());
        ((XmlBeanFactory) beanFactory).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());

        // 第一次从容器中获取Bean，将处罚容器实例化该Bean，这将引发Bean声明周期的调用
        Car car1 = (Car) beanFactory.getBean("car");
        car1.introduce();
        car1.setColor("白色");

        // 第二次从容器中获取Bean，将直接从缓存池中获取
        Car car2 = (Car) beanFactory.getBean("car");
        car2.introduce();

        // 两次获取到的是统一引用
        System.out.println("car2 == car1 " + (car2 == car1));

        // 关闭容器
        ((XmlBeanFactory) beanFactory).destroySingletons();
    }

    public static void main(String[] args) {
        startLifeCycle();
    }
}

需要强调的是，后处理器的实际调用顺序和注册顺序是无关的，在具有多个后处理器的情况下，必须通过实现的org.springframework.core.Ordered 接口以确定调用顺序。

运行 BeanFactoryLifeCycle，可以看到控制台打印如下：

调用MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法...
调用Car()构造函数...
调用MyInstantiationAwareBeanPostProcessor.postProcessAfterInstantiation方法...
调用MyInstantiationAwareBeanPostProcessor.postProcessProperties方法...
调用setBrand()设置属性...
调用setMaxSpeed()设置属性...
调用BeanNameAware.setBeanName()方法...
调用BeanFactoryAware.setBeanFactory()方法...
调用MyBeanPostProcessor.postProcessBeforeInitialization方法，color为空，设置为默认黑色
调用setColor()设置属性...
调用InitializingBean.afterPropertiesSet()方法...
调用init-method指定的myinit()方法，将maxSpeed设置为240...
调用MyBeanPostProcessor.postProcessAfterInitialization方法，将maxSpeed调整为200
调用setMaxSpeed()设置属性...
brand: 奔驰S600L, color: 黑色, maxSpeed: 200
调用setColor()设置属性...
brand: 奔驰S600L, color: 白色, maxSpeed: 200
car2 == car1 true
调用DisposableBean.destroy()方法...
调用destroy-myDestroy()方法...

仔细观察输出的信息，发现它验证了前面所介绍故的 Bean 生命周期的过程。最后通过 destroySingletons() 方法关闭了容器，由于 Car 实现了销毁接口并指定了销毁方法，所以容器将触发调用这两个方法。

了解了 BeanFactory 中 Bean 的生命周期之后，我们来看看这个过程中涉及到的一些接口。

BeanNameAware

BeanNameAware 接口的源码如下：

public interface BeanNameAware extends Aware {
    void setBeanName(String var1);
}

这个接口的作用是，让 Bean 获取自己在 BeanFactory 配置中的名字。就像上面的 Car 类，它实现了 BeanNameAware 接口，并重写了 setBeanName(String beanName) 方法，将配置的 beanName 设置到 Car 的成员变量中，Spring 会自动调用这个接口的方法。

BeanFactoryAware

BeanFactoryAware 接口的源码如下：

public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory var1) throws BeansException;
}

这个接口的作用是，可以在 Bean 中注入 Spring 的容器 BeanFactory，让 Bean 拥有访问 Spring 容器的能力，注入了 BeanFactory 之后，Bean 就可以访问容器中任意的其他 Bean 了。

InitializingBean

InitializingBean 接口的源码如下：

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

InitializingBean 接口为 bean 提供了初始化方法的方式，它只有一个 afterPropertiesSet() 方法，凡是实现该接口的类，在初始化 bean 的时候都会执行该方法。我们知道，init-method 也可以配置 Bean 的初始化方法，那么这二者有什么区别呢？通过分析上例中的执行结果，可知如果某个类同时实现了 InitializingBean 接口和指定了 init-method 初始化方法，那么 Spring 会先调用 InitializingBean.afterPropertieSet() 方法，然后再调用 init-method 指定的方法。

DisposableBean

DisposableBean 的源码如下：

public interface DisposableBean {
    void destroy() throws Exception;
}

如果某个类实现了 DisposableBean 接口，那么 Spring 容器释放该 bean 之后将调用这个接口的 destroy() 方法。我们知道，destroy-method 属性也可以知道 Bean 销毁时调用的方法，那么这二者有什么区别呢？通过分析上例的执行结果可知，DisposableBean.destroy() 方法会在 destroy-method 指定的方法之前调用。

InstantiationAwareBeanPostProcessor

InstantiationAwareBeanPostProcessor 的源码如下：

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    /** @deprecated */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

InstantiationAwareBeanPostProcessor 接口继承自 BeanPostProcessor 接口，InstantiationAwareBeanPostProcessor 接口的主要作用在于在目标对象的实例化前后以及属性设置前做一些操作，可以分析上例的执行结果得到结论。这个接口一般不由 Bean 去实现，而是单独提供一个实现类并注册到 Spring 容器中，对于 BeanFactory 需要手动注册，而 ApplicationContext 则会自动扫描容器中该接口的实现而自动注册，这个接口的作用范围是全局的，即所有 Bean 在实例化前后都会执行相应的操作。容器中可以有多个 InstantiationAwareBeanPostProcessor 接口的实现，需要通过 Order 接口指定它们的执行顺序。

BeanPostProcesser

BeanPostProcesser 接口的源码如下：

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

这个接口的作用是，在 Bean 初始化（注意区分初始化和实例化，实例化是调用构造函数，初始化是调用 InitializingBean.afterProperties() 和 init-method 指定的方法）前后做一些操作。如果想在 Bean 初始化前后做一些操作，比如修改 Bean 的某些属性，那么可以提供一个类实现 BeanPostProcesser 接口并将其注册到 Spring 容器中。这个接口一般不由 Bean 去实现，而是单独提供一个实现类并注册到 Spring 容器中，对于 BeanFactory 需要手动注册，而 ApplicationContext 则会自动扫描容器中该接口的实现而自动注册，这个接口的作用范围是全局的，即所有 Bean 在初始化前后都会执行相应的操作，当然可以通过编码的方式，选择对一些感兴趣的 Bean 进行处理，就像上例中只对名为 car 的 Bean 进行操作一样。容器中可以有多个 BeanPostProcessor 接口的实现，需要通过 Order 接口指定它们的执行顺序。

ApplicationContext中Bean的生命周期

ApplicationContext 中 Bean 的生命周期和在 BeanFactory 中生命周期类似，不同是，BeanFactory 启动时不会创建所有单例的 Bean，而是等到第一次调用某个 Bean 时创建，而 ApplicationContext 则会在容器启动时创建所有单例的 Bean，因此 ApplicationContext 的启动会比 BeanFactory 稍慢，但后续不会有“第一次惩罚”的问题，另外，如果 Bean 实现 ApplicationContextAware 接口，会增加一个调用该接口方法 setApplicationContext() 的步骤：

 

此外，如果配置文件中声明了工厂后处理器接口 BeanFactoryPostProcessor 的实现类，则应用上下文在装载配置文件之后、初始化 Bean 实例之前将调用这些 BeanFactoryPostProcessor 对配置信息进行加工处理。Spring 框架提供了多个工厂后处理器，比如 CustomEditorConfigurer、PopertyPlaceholderConfigurer 等。如果配置文件中定义了多个工厂后处理器，最好让它们实现 Ordered 接口，以便 Spring 以确定的顺序调用它们。工厂后处理器是容器级的，仅在应用上下文初始化时调用一次，其目的是完成一些配置文件的加工处理工作。

ApplicationContext 和 BeanFactory 另一个最大的不同之处在于：前者会利用 Java 反射机制自动识别出配置文件中定义的 BeanPostProcessor、InstantiationAwareBeanPostProcessor 和 BeanFactoryPostProcessor，并自动将它们注册到应用上下文中，而后者需要在代码中通过手工调用 addBeanPostProcessor() 方法进行注册。在 ApplicationContext 中，我们只需要在配置文件中通过 <bean> 定义工厂后处理器和 Bean 后处理器，它们就会按预期的方式运行（在实际应用中，提供一个相应的后处理器实现类，使用 @Component 注解标识即可生效）。

来看一个使用工厂后处理器的实例，假设我们希望对配置文件中 car 的 brand 配置属性进行调整，则可以编写一个如下的工厂后处理器：

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 {

    // 对car<bean>的brand属性配置信息进行修改
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("car");
        beanDefinition.getPropertyValues().addPropertyValue("brand", "宾利慕尚");
        System.out.println("调用MyBeanFactoryPostProcessor.postProcessBeanFactory方法...");
    }
}

ApplicationContext在启动时，将首先为配置文件中每个 <bean> 生成一个 BeanDefinition 对象，BeanDefinition 是 <bean> 在Spring 容器中的内部表示。当配置文件中所有的 <bean> 都被解析成 BeanDefinition 时，ApplicationContext 将调用工厂后处理器的方法，因此我们有机会通过程序的方式调整 Bean 的配置信息。在这里，我们将 car 对应的 BeanDefinition 进行调整，修改其 brand 属性值，下面是具体的配置：

<?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的brand属性值将被工厂后处理器改掉 -->
    <bean id="car" class="com.wuychn.beanlifecycle.beanfactory.Car"
          init-method="myInit"
          destroy-method="myDestroy">
        <property name="brand" value="奔驰S600L"/>
        <property name="maxSpeed" value="200"/>
    </bean>

    <!-- 注册Bean后处理器，这个后处理器会自动被 ApplicationContext 注册 -->
    <bean id="myBeanPostProcessor"
          class="com.wuychn.beanlifecycle.beanfactory.MyBeanPostProcessor"/>

    <!-- 注册工厂后处理器，这个后处理器会自动被 ApplicationContext 注册 -->
    <bean id="myBeanFactoryPostProcessor"
          class="com.wuychn.beanlifecycle.applicationcontext.MyBeanFactoryPostProcessor"/>

</beans>

最后，ApplicationContextLifeCycle 类如下：

package com.wuychn.beanlifecycle.applicationcontext;

import com.wuychn.beanlifecycle.beanfactory.Car;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ApplicationContextLifeCycle {

    public static void startLifeCycle() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 第一次从容器中获取Bean，将处罚容器实例化该Bean，这将引发Bean声明周期的调用
        Car car1 = (Car) applicationContext.getBean("car");
        car1.introduce();
        car1.setColor("白色");

        // 第二次从容器中获取Bean，将直接从缓存池中获取
        Car car2 = (Car) applicationContext.getBean("car");
        car2.introduce();

        // 两次获取到的是统一引用
        System.out.println("car2 == car1 " + (car2 == car1));

        // 关闭容器
        ((ClassPathXmlApplicationContext) applicationContext).destroy();
    }

    public static void main(String[] args) {
        startLifeCycle();
    }
}

运行 ApplicationContextLifeCycle，可以看到 car Bean 的 brand 属性被成功修改了：

调用MyBeanFactoryPostProcessor.postProcessBeanFactory方法...
调用Car()构造函数...
调用setBrand()设置属性...
调用setMaxSpeed()设置属性...
调用BeanNameAware.setBeanName()方法...
调用BeanFactoryAware.setBeanFactory()方法...
调用MyBeanPostProcessor.postProcessBeforeInitialization方法，color为空，设置为默认黑色
调用setColor()设置属性...
调用InitializingBean.afterPropertiesSet()方法...
调用init-method指定的myinit()方法，将maxSpeed设置为240...
调用MyBeanPostProcessor.postProcessAfterInitialization方法，将maxSpeed调整为200
调用setMaxSpeed()设置属性...
brand: 宾利慕尚, color: 黑色, maxSpeed: 200
调用setColor()设置属性...
brand: 宾利慕尚, color: 白色, maxSpeed: 200
car2 == car1 true
18:28:43.864 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@4f4a7090, started on Wed Dec 12 18:28:43 CST 2018
调用DisposableBean.destroy()方法...
调用destroy-myDestroy()方法...

 

wuychn
关注
专栏目录
SpringBean生命周期详解
weixin_43244698的博客
10-28 9561
SpringBean生命周期详解 一、简述： Spring是我们每天都在使用的框架，Bean是被Spring管理的Java对象，是Spring框架最重要的部分之一，那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从宏观的角度看一下Spring的生命周期： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201028174058916.png?x-oss-process=image/watermark,t ype_ZmFuZ3poZW5
Spring Bean生命周期详解
热门推荐
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
Spring bean生命周期
izhuhf的专栏
02-22 131
在传统的Java应用中，Bean的生命周期非常简单。 Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。 相反，Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1.容器寻找Bean的定义信息并且将其实例化。 2.受用依赖注入，Spring按...
spring bean生命周期
weixin_34192993的博客
10-08 168
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Bean 生命周期
最新发布
Randy的博客
08-06 1421
生产：加载和创建 Bean 定义和实例。使用：在应用程序中管理和使用 Bean 实例。销毁：适当地销毁和清理 Bean 实例。加载 Bean 定义是 Spring 容器启动的第一步。这一步骤通过各种方式（如 XML 配置、注解扫描等）将项目中定义的所有 Bean 类找到，并放入中。
Spring bean的生命周期
Akaks的博客
04-18 253
Bean的完整的生命周期有十一个步骤: 1.instantiate bean对象实例化 2.populate properties 封装属性 3.如果Bean实现BeanNameAware 执行 setBeanName 4.如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setAppli...
Spring bean 的生命周期
sunshine_2017的博客
09-01 7576
1. 实例化一个Bean，也就是我们通常说的new 2. 按照Spring上下文对实例化的Bean进行配置，也就是IOC注入 3. 如果这个Bean实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的是Spring配置文件中Bean的ID 4. 如果这个Bean实现了BeanFactoryAware接口，会调用它实现的set
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
spring bean的生命周期
01-16
- **XML配置**：在传统的Spring应用中，Bean的定义通常写在XML配置文件中，如`springbean-xml`中的配置。 - **注解配置**：使用`@Component`，`@Service`，`@Repository`和`@Controller`注解标记类，配合`@...
Spring中bean的生命周期
weixin_42236535的博客
08-31 83
Spring中Bean的生命周期 首先说一下Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy； Spring上下文中的Bean生命周期也类似，如下： （1）实例化Bean： 对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于Ap...
Spring-Bean 生命周期
hskw444273663的博客
07-03 225
准备工厂，然后调用invokeBeanFactoryPostProcessor去解析注解类，把他们分类放到Map当中，再调用registerBeanPostProcessor注册Bean的后置处理器，如果加了开启AOP的@EnableAspectJAutoProxy注解的话是8个，没加是7个。然后实例化所有剩余的非延迟的单例Bean，也就是Spring添加的后置处理器和扫描我们提...
Spring Bean的生命周期
戈多
02-19 857
原文地址：http://www.cnblogs.com/zrtqsk/p/3735273.html Spring作为当前Java最流行、最强大的轻量级框架，受到了程序员的热烈欢迎。准确的了解Spring Bean的生命周期是非常必要的。我们通常使用ApplicationContext作为Spring容器。这里，我们讲的也是 ApplicationContext中Bean的生命周期。而实际上B
Spring Bean生命周期详解与示例
在Spring框架中，Bean的生命周期管理是至关重要的，它涉及到从Bean的创建、初始化到销毁的整个过程。...对于学习Spring框架或进行Spring项目开发的人员来说，深入理解Bean生命周期是必不可少的知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值