Spring Bean的生命周期

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

一、生命周期流程图

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


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

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

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

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

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

三、示例代码

自定义Bean实现BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean,DisposableBean接口

package com.cuisea.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * Bean生命周期
 */
public class Person implements BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean,DisposableBean {
    private String name;
    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;

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

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

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

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

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
        System.out.println("【ApplicationContextAware接口】调用ApplicationContextAware.setApplicationContext()");
    }

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

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

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

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

BeanFactoryPostProcessor接口实现类：

package com.cuisea.lifecycle;

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() {
        System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
    }

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

BeanPostProcessor接口实现类：

package com.cuisea.lifecycle;

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

public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor() {
        System.out.println("这是BeanPostProcessor实现类构造器！！");
    }

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

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

InstantiationAwareBeanPostProcessor接口实现类：

package com.cuisea.lifecycle;

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

import java.beans.PropertyDescriptor;

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 var1, PropertyDescriptor[] var2, Object var3, String var4) throws BeansException{
        System.out.println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
        return var1;
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <bean id="beanPostProcessor" class="com.cuisea.lifecycle.MyBeanPostProcessor"/>
    <bean id="instantiationAwareBeanPostProcessor" class="com.cuisea.lifecycle.MyInstantiationAwareBeanPostProcessor"/>
    <bean id="beanFactoryPostProcessor" class="com.cuisea.lifecycle.MyBeanFactoryPostProcessor"/>
    <bean id="person" class="com.cuisea.lifecycle.Person" init-method="initMethod" destroy-method="destroyMethod" scope="singleton">
        <property name="name" value="cuisea"/>
    </bean>
</beans>

测试代码：

package com.cuisea;

import com.cuisea.lifecycle.Person;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.concurrent.TimeUnit;

public class LifeCycleTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("Spring容器初始化成功");
        Person person=(Person)context.getBean("person");
        System.out.println(person);

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Spring容器开始关闭");
        context.close();
    }
}

运行结果：

参考：http://www.cnblogs.com/zrtqsk/p/3735273.html 流程中增加了ApplicationContextAware接口

cuisea
关注
专栏目录
SpringBean生命周期详解
weixin_43244698的博客
10-28 9536
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 126
在传统的Java应用中，Bean的生命周期非常简单。 Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。 相反，Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1.容器寻找Bean的定义信息并且将其实例化。 2.受用依赖注入，Spring按...
spring bean生命周期
weixin_34192993的博客
10-08 162
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Bean 生命周期
最新发布
Randy的博客
08-06 1339
生产：加载和创建 Bean 定义和实例。使用：在应用程序中管理和使用 Bean 实例。销毁：适当地销毁和清理 Bean 实例。加载 Bean 定义是 Spring 容器启动的第一步。这一步骤通过各种方式（如 XML 配置、注解扫描等）将项目中定义的所有 Bean 类找到，并放入中。
Spring bean的生命周期
Akaks的博客
04-18 248
Bean的完整的生命周期有十一个步骤: 1.instantiate bean对象实例化 2.populate properties 封装属性 3.如果Bean实现BeanNameAware 执行 setBeanName 4.如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setAppli...
Spring bean 的生命周期
sunshine_2017的博客
09-01 7570
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 82
Spring中Bean的生命周期 首先说一下Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy； Spring上下文中的Bean生命周期也类似，如下： （1）实例化Bean： 对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于Ap...
Spring-Bean 生命周期
hskw444273663的博客
07-03 221
准备工厂，然后调用invokeBeanFactoryPostProcessor去解析注解类，把他们分类放到Map当中，再调用registerBeanPostProcessor注册Bean的后置处理器，如果加了开启AOP的@EnableAspectJAutoProxy注解的话是8个，没加是7个。然后实例化所有剩余的非延迟的单例Bean，也就是Spring添加的后置处理器和扫描我们提...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值