Spring注解之Bean生命周期

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

简记Bean生命周期（xml方式与注解方式）

什么是Bean

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

1. xml方式

1.1. 在 Spring中有两种bean： 普通Bean 和 工厂Bean

  • 普通bean：配置文件中定义bean类型就是返回类型
<bean id="user" class="com.demo.pojo.User">
</bean>

*工厂bean（FactoryBean）：配置文件中定义bean类型可以和返回类型不同
（1）创建类，让这个类作为工厂bean，实现接口FactoryBean
（2）实现接口里的方法，在实现的方法里定义返回的bean类型

1.1.1. FactoryBean举例代码

// 设置Mybean返回的类型为Course
public class MyBean implements FactoryBean<Course> {
    @Override
    /**
     * 返回bean实例；自定义返回bean
     */
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    /**
     * 返回bean类型
     */
    public Class<?> getObjectType() {
        return Course.class;
    }

    @Override
    /**
     * 判断是否为单例
     */
    public boolean isSingleton() {
        return false;
    }
}
#####################################################################
配置文件中配置

<bean id="mybean" class="com.demo.factorybean.MyBean"></bean>

1.2. Bean作用域

  • 在Spring中可以设置创建bean实例是单实例还是多实例 （单实例对象地址值相同）
  • 在Spring中，默认情况下创建的bean实例为单实例
  • 在Spring配置文件中的bean标签中有属性（scope）用于设置单实例还是多实例

1.2.1. 举例代码


public class Books {
    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }

    public void testbooks() {
        System.out.println( "books{" +
                "list=" + list +
                '}');
    }
}

             ##########################################
xml中配置：

   <util:list id="booksList">
        <value>java修炼之路</value>
        <value><![CDATA[
        <<java手册>>
        ]]></value>
        <value>《jvm调优》</value>
        <value><![CDATA[
        <<Spring实战>>
        ]]></value>
    </util:list>
    
<bean id="books" class="com.demo.pojo.Books" scope="prototype">
        <property name="list" ref="booksList"></property>
    </bean>

scope属性值：
     singleton 表示单实例对象（默认值）加载Spring配置文件时就会创建单实例对象
     prototype 表示多实例对象 调用getBean方法时候创建多实例对象

1.3. bean生命周期以及bean的后置处理器

  • bean的生命周期：创建-初始化-销毁

  • 未配置后置处理器时的bean生命周期

（1）通过构造器创建bean实例 (无参数构造）
（2）为bean的属性设置值和对其他bean的引用 (调用set方法)
（3）调用bean的初始化方法（需要进行配置初始化方法）
（4）使用bean（获取bean实例对象）
（5）当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁方法）
  • 添加后置处理器之后的bean生命周期
（1）通过构造器创建bean实例 (无参数构造）
（2）为bean的属性设置值和对其他bean的引用 (调用set方法)
 （   将bean实例传递给bean后置处理器的方法 postProcessBeforeInitialization
（3）调用bean的初始化方法（需要进行配置初始化方法）
 （   将bean实例传递给bean后置处理器的方法 postProcessAfterInitialization
（4）使用bean（获取bean实例对象）
（5）当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁方法）
      
 *  注： 创建后置处理器后，会为配置文件中的每一个bean实例都配置后置处理器

1.3.1. 举例代码：

                            后置处理器实现类
public class MyBeanPost implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后执行的方法");
        return bean;
    }
}
                #########################################
                                  xml配置
<!--    配置bean生命周期演示
        init-method 配置初始化方法
        destroy-method 配置销毁方法
-->
    <bean id="orders" class="com.demo.pojo.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="篮球"></property>
    </bean>

<!--    配置后置处理器-->
    <bean id="myBeanPost" class="com.spring5.bean.MyBeanPost"></bean>
    
            ################################################
                             测试bean
/**
 * bean生命周期演示
 *       （1）通过构造器创建bean实例 (无参数构造）
 *       （2）为bean的属性设置值和对其他bean的引用 (调用set方法)
 *       （3）调用bean的初始化方法（需要进行配置初始化方法）
 *       （4）使用bean（获取bean实例对象）
 *       （5）当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁方法）
 */
public class Orders {
    private String oname;

    public Orders() {
        System.out.println("第一步：执行无参构造器创建bean实例");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步：调用set方法设置属性值");
    }

    // 创建执行的初始化方法
    public void initMethod(){
        System.out.println("第三步：执行初始化方法");
    }

    // 创建执行的销毁方法
    public void destroyMethod(){
        System.out.println("第五步：执行销毁方法");
    }
}

               #######################################
                            测试代码
    /**
     * 测试bean的生命周期
     */
    public void testBean(){
//        ApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml");
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml");
        com.spring5.bean.Orders orders = context.getBean("orders", com.spring5.bean.Orders.class);
        System.out.println("第四步：获取创建的bean实例对象");
        System.out.println(orders);
        // 手动销毁bean实例
//        ((ClassPathXmlApplicationContext)context).close();
        context.close();
    }

测试结果：
在这里插入图片描述

2. 注解方式

此处主要记录关于注解方式如何指定初始化以及销毁方法

2.1. IOC容器管理Bean生命周期

自定义初始化和销毁方法：
          容器在bean进行到当前生命周期的时候来调用自定义的初始化和销毁方法

2.2. 构造对象

  • 单实例：在容器启动时创建对象
  • 多实例：在每次获取时创建对象

2.3. 初始化

  • 对象创建完成并为其赋值后才开始调用初始化方法

2.4. 销毁

  • 单例：容器关闭时调用销毁方法
  • 多例：容器不调用（不销毁）需要手动调用销毁方法

2.5. 指定初始化和销毁方法

2.5.1 @Bean(initMethod = “init”,destroyMethod = “destory”)

2.5.1 代码测试（单例），（多例测试标记@Scope(“prototype”)，需手动调用销毁方法）
                       配置类
@Configuration
@ComponentScan(value = "com.liuqiang.pojo")
public class MyConfigOfLifeCycle {

    // @Scope("prototype")
    @Bean(initMethod = "init",destroyMethod = "destory")
    public Car getCar(){
        return new Car();
    }

}
               #####################################
                            测试bean
public class Car {
    public Car() {
        System.out.println("Car constructor");
    }
    public void init(){
        System.out.println("Car initMethod");
    }

    public void destory(){
        System.out.println("Car destoryMethod");
    }
}

             #######################################
                         测试代码
    @Test
    public void test1(){
        //  创建容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfLifeCycle.class);
        System.out.println("容器创建完成");
        Car bean = applicationContext.getBean(Car.class);
        applicationContext.close(); // 销毁容器
//        bean.destory(); // 手动调用销毁方法
    }

测试结果：
在这里插入图片描述
多例测试结果：
在这里插入图片描述

2.5.2 . 实现initializingBean接口与DisposableBean接口

initializingBean接口：
当BeanFactory创建好对象并且为所有属性设置好值之后调用afterPropertiesSet方法，完成初始化
DisposableBean接口：
当BeanFactory销毁掉单实例Bean时，调用destory方法完成销毁

2.5.2. 代码测试
                     接口实现类
@Component
public class Cat implements InitializingBean, DisposableBean {


    public Cat(){
        System.out.println("Cat constructor...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Cat destory...");
    }

    // 在bean创建好并对其属性赋值之后才被调用
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Cat afterPropertiesSet。。。");
    }
}
                  ###############################
                           测试代码
    @Test
    public void test2(){  // InitializingBean DisposableBean 
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfLifeCycle.class);
        System.out.println("容器创建完成");
        applicationContext.close();

    }

测试结果：
在这里插入图片描述

2.5.3. 使用JSR250

注解@PostConstruct
当Bean都装配完成之后执行一些初始化
注解@PreDestory
当Bean在容器中被移除之前给予通知进行销毁

2.5.3. 代码测试

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class Dog {

    private ApplicationContext applicationContext;
    public Dog() {
        System.out.println("Dog constructor");
    }

   @PostConstruct
    public void init(){  // 对象创建并赋值之后调用
        System.out.println("Dog @PostConstruct");
    }

    @PreDestroy
    public void destory(){  // 容器移除对象之前
        System.out.println("Dog @PreDestroy");
    }
}

               #####################################
                         测试代码
   @Test
    public void test2(){  // JSR250
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfLifeCycle.class);
        System.out.println("容器创建完成");
        applicationContext.close();

    }

测试结果
在这里插入图片描述

2.5.4. BeanPostProcessor接口实现 bean的后置处理器：

在bean初始化前后进行一些处理工作，后置处理器需要自己实现BeanPostProcessor接口，重写以下两个方法
postProcessBeforeInitialization:
Spring在已经创建好Bean实例，在任何初始化方法调用之前，调用后置处理器
postProcessAfterInitialization:
Spring在已经创建好Bean实例，在任何初始化方法调用之后，调用后置处理器

  • 实现流程
BeanPostProcessor.postProcessBeforeInitialization ->
                     初始化 ->
  BeanPostProcessor.postProcessAfterInitialization
  • BeanPostProcessor原理流程
     populateBean(beanName,mbd,instanceWrapper); // 先给Bean进行属性赋值
 
     initializeBean(){  // 	遍历执行进行初始化
          applyBeanPostProcessBeforeInitialization(wrappedBean,beanName);
          invokeInitMethods(beanName,WrappedBean,mbd); 执行自定义初始化
          applyBeanPostProcessAfterInitialization(wrappedBean,beanName);
      }
2.5.4. 代码测试
// 后置处理器，在初始化前后进行工作
@Component  // 将后置处理器加入到容器中
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     *
     * @param bean 容器刚创建好的bean实例
     * @param beanName bean实例名字
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization-->"+beanName+"="+bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization-->"+beanName+"="+bean);
        return bean;
    }
}
                 ######################################
                               测试代码
    @Test
    public void test2(){  
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfLifeCycle.class);
        System.out.println("容器创建完成");
        applicationContext.close();

    }

测试结果：
在这里插入图片描述

小刘想做程序员
关注
专栏目录
Spring中Bean的生命周期详解
fudaihb的博客
06-01 1213
Spring框架作为Java开发中最重要的框架之一，受到了广泛的关注和使用。Spring的核心概念之一就是Bean，它是Spring IoC（Inversion of Control，控制反转）容器管理的基础。在Spring中，Bean的生命周期是一个非常重要的概念。本文将详细解析Spring中Bean的生命周期，包括每个阶段的详解和对应的实现机制，帮助开发者更好地理解和掌握Spring框架。
Spring Boot 纯注解实现Bean的生命周期
Dennis学习小站
09-15 408
最近在准备面试，有关Bean的生命周期被问到了，下来巩固一下，之前都是针对Spring在回答Bean的各项注意事项，由于现在Spring Boot用的更多，因此找了一些如何用纯注解实现的方式。 首先是Bean的完整加载流程： 接下来是代码实现(已经按照顺序)： @Component public class Person implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean
spring注解版 Bean的生命周期
qq_39023116的博客
10-19 258
这里说的生命周期就只是初始化和销毁两个阶段，没有深究。主要有四种 一、注解@bean指定 public class ZhangSan { public ZhangSan() { System.out.println("ZhangSan......"); } public void init() { System.out.println("init......"); } ...
Bean 生命周期具体内容介绍和注解代码实现
最新发布
weixin_45428910的博客
09-16 999
Bean 生命周期具体内容介绍和注解代码实现
【Spring注解系列10】SpringBean的生命周期
Java仗剑走天涯
04-04 524
1.SpringBean生命周期定义 指bean创建---初始化----销毁的过程。 构造（对象创建）： 单实例：在容器启动的时候创建对象 多实例：在每次获取的时候创建对象 初始化和销毁方式： 指定初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法。 @Bean中指定的 initMethod 和destroyMet...
Spring-bean的生命周期，注解版
Alphr的博客
06-29 677
由于本人能力有限不能深入源码讲解，这里知识粗略的介绍一下bean的生命周期，先看一下图： 用简单的话来说就是： 第一步：通过构造器创建bean实例，默认是无参构造器 第二步：设置bean的属性值和引入其他的bean(spring的循环依赖)，如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID），如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身，由于我们是通过@value
知识储备：Spring中Bean的生命周期（基于注解版）
qq_36625757的博客
11-01 4035
一：前言 在Spring项目中，通常配置Spring都是使用XML的形式进行配置，配置bean是通过&lt;bean&gt;&lt;/bean&gt;标签将bean加入IOC容器中，但在Spring注解版中，可以通过Java代码进行配置，即创建一个java类在其类头上标注@Configuration注解即表示当前类为一个配置类，作用相当于之前的.xml配置文件，那如何将bean加入到IOC容器中...
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
Spring学习笔记之bean生命周期
08-28
《Spring学习笔记之bean生命周期》 在Spring框架中，Bean是核心组件，它们构成了应用程序的主要结构。理解Spring Bean的生命周期对于有效地管理和优化Spring应用程序至关重要。本文将深入探讨Spring Bean的生命周期...
spring bean的生命周期
01-16
Spring Bean的生命周期是Spring框架中的核心概念，它涵盖了Bean从创建到销毁的全过程。了解这一过程对于优化应用程序的性能和管理资源至关重要。在Spring中，Bean的生命周期主要分为以下几个阶段： 1. **初始化阶段...
Spring 注解 bean的生命周期
paperbook的专栏
09-12 384
Spring注解定义bean的时候，默认都是singleton的，想要成多例需要在
spring全注解方式下Bean的生命周期
qq_39746820的博客
06-04 449
spring全注解方式下Bean的生命周期
bean的生命周期注解
fwk19840301的博客
07-13 345
import org.springframework.context.ApplicationListener;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context...
【雷丰阳】Spring纯注解版 bean的生命周期
Jsu蘇的博客
08-05 412
Spring纯注解开发(雷丰阳) 本文为个人学习笔记： 资料来源： 个人学习尚硅谷 雷丰阳老师的视频 自己总结 学习视频：https://www.bilibili.com/video/BV1gW411W7wy 组件添加 @Configuration // 配置类 等于之前的配置文件 @Configuration // 告诉Spring 这是一个配置类 public class MainConfig { /** * 功能描述: 配置person * @Param: []
spring全注解-bean生命周期
优雅永不过时
10-14 213
bean的生命周期 bean->初始化->销毁 容器帮我们管理bean的生命周期 构造(对象创建) 单实例：再容器启动的时候创建对象，销毁时容器会帮我们调用destory 多实例：每次获取对象的时候创建对象，容器不会管理这个bean，容器不会调用销毁方法 我们可以自定义初始化和销毁方法：容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法 指定初始化和销毁方法，初始化的时候需要赋值，销毁的时候关闭一些数据源 初始化对象创建完成，并赋值好，调用初始化方法 销毁：容器关
Spring注解--bean生命周期的相关方法
方新德的博客
09-19 363
bean对象的生命周期主要是：实例的创建→实例的初始化→实例的销毁，三个时刻，对应着类中三个方法： 构造器、类的初始化方法（无特殊情况，类实例化后立即执行此方法）、实例销毁时立即执行的方法。  1.通过@Bean指定init-method和destroy-method； 2.通过让Bean实现InitializingBean（定义初始化逻辑）， DisposableBean（定义销毁逻辑）；...
spring注解Bean的生命周期 和 BeanPostProcessor
方亚军的博客
06-05 467
bean的生命周期 bean的生命周期： bean的创建—初始化—销毁的过程 容器管理bean的生命周期： 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法 指定初始化和销毁方法：指定init-method和destory-method 指定初始化和销毁的方法： 通过@Bean指定init-method和destory-method...
spring中关于bean的生命周期的常用注解
weixin_43810802的博客
11-29 1201
singleton的，非lazy的bean，在IOC容器初始化的时候就被加载了，像基本的servlet有生命周期一样，spring的bean，也是有生命周期的。这也是spring的bean与java中的class不一样的地方，它远比class丰富。 今天，我们就介绍与spring的bean的lifeCycle有关的几个注解。 preparation： 我们有个Customer.java（pack...
Spring Bean生命周期详解与示例
在Spring框架中，Bean的生命周期管理是至关重要的，它涉及到从Bean的创建、初始化到销毁的整个过程。...对于学习Spring框架或进行Spring项目开发的人员来说，深入理解Bean生命周期是必不可少的知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值