spring生命周期二转载

最新推荐文章于 2023-08-18 22:20:19 发布
最新推荐文章于 2023-08-18 22:20:19 发布
阅读量114 收藏
点赞数
分类专栏： Spring

####首先你需要知道的知识
在IoC容器启动之后，并不会马上就实例化相应的bean，此时容器仅仅拥有所有对象的BeanDefinition(BeanDefinition：是容器依赖某些工具加载的XML配置信息进行解析和分析，并将分析后的信息编组为相应的BeanDefinition)。只有当getBean()调用时才是有可能触发Bean实例化阶段的活动

#####为什么说有可能触发Bean实例化阶段？

因为当对应某个bean定义的getBean()方法第一次被调用时，不管是显示的还是隐式的，Bean实例化阶段才会被触发，第二次被调用则会直接返回容器缓存的第一次实例化完的对象实例(因为默认是singleton单例，当然，这里的情况prototype类型的bean除外)

##该篇博客主要阐述
#####1、Bean的一生过程
#####2、Bean的后置处理器

###一、Bean的一生过程
####先来看以下的图(Bean的一生)

####可以简述为以下九步

实例化bean对象(通过构造方法或者工厂方法)
设置对象属性(setter等)（依赖注入）
如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。（和下面的一条均属于检查Aware接口）
如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身
将Bean实例传递给Bean的前置处理器的postProcessBeforeInitialization(Object bean, String beanname)方法
调用Bean的初始化方法
将Bean实例传递给Bean的后置处理器的postProcessAfterInitialization(Object bean, String beanname)方法
使用Bean
容器关闭之前，调用Bean的销毁方法
####先看一个最简单的一生(没有使用Bean的后置处理器)

Student.java

package com.linjie.cycle;

import org.springframework.beans.factory.BeanNameAware;

/**
 * @author LinJie
 * @Description:一个学生类(Bean)，能体现其生命周期的Bean
 */
public class Student implements BeanNameAware {
    private String name;

    //无参构造方法
    public Student() {
        super();
    }

    /** 设置对象属性
     * @param name the name to set
     */
    public void setName(String name) {
        System.out.println("设置对象属性setName()..");
        this.name = name;
    }
    
    //Bean的初始化方法
    public void initStudent() {
        System.out.println("Student这个Bean：初始化");
    }
    
    //Bean的销毁方法
    public void destroyStudent() {
        System.out.println("Student这个Bean：销毁");
    }
    
    //Bean的使用
    public void play() {
        System.out.println("Student这个Bean：使用");
    }

    /* 重写toString
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Student [name = " + name + "]";
    }

    //调用BeanNameAware的setBeanName()
    //传递Bean的ID。
    @Override
    public void setBeanName(String name) {
        System.out.println("调用BeanNameAware的setBeanName()..." ); 
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
测试类

package com.linjie.cycle;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试类
 * @author LinJie
 * 
 */
public class CycleTest {
    @Test
     public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        //Bean的使用
        student.play();
        System.out.println(student);
        //关闭容器
        ((AbstractApplicationContext) context).close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
   <!-- init-method：指定初始化的方法
        destroy-method：指定销毁的方法 -->
        <bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
        <property name="name" value="LINJIE"></property>
        </bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
控制台显示结果

可以在输出结果看出bean的一生，完全与之前的一生过程图相符(除了bean后置处理器部分)，这里还需要提及的是在xml配置中的两个属性

init-method：指定初始化的方法
destroy-method：指定销毁的方法
#####说到init-method和destroy-method，当然也要提及一下在< beans>的属性

default-init-method：为应用上下文中所有的Bean设置了共同的初始化方法
default-destroy-method：为应用上下文中所有的Bean设置了共同的销毁方法


###二、Bean的后置处理器

上面bean的一生其实已经算是对bean生命周期很完整的解释了，然而bean的后置处理器，是为了对bean的一个增强

####用法

分别在Bean的初始化前后对Bean对象提供自己的实例化逻辑

- 实现BeanPostProcessor接口
    - postProcessBeforeInitialization方法
    - postProcessAfterInitialization方法
1
2
3
####接上面的Student Demo

Student.java

package com.linjie.cycle;

import org.springframework.beans.factory.BeanNameAware;

/**
 * @author LinJie
 * @Description:一个学生类(Bean)，能体现其生命周期的Bean
 */
public class Student implements BeanNameAware {
    private String name;

    //无参构造方法
    public Student() {
        super();
    }

    /** 设置对象属性
     * @param name the name to set
     */
    public void setName(String name) {
        System.out.println("设置对象属性setName()..");
        this.name = name;
    }
    
    //Bean的初始化方法
    public void initStudent() {
        System.out.println("Student这个Bean：初始化");
    }
    
    //Bean的销毁方法
    public void destroyStudent() {
        System.out.println("Student这个Bean：销毁");
    }
    
    //Bean的使用
    public void play() {
        System.out.println("Student这个Bean：使用");
    }

    /* 重写toString
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Student [name = " + name + "]";
    }

    //调用BeanNameAware的setBeanName()
    //传递Bean的ID。
    @Override
    public void setBeanName(String name) {
        System.out.println("调用BeanNameAware的setBeanName()..." ); 
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
MyBeanPostProcessor.java（实现BeanPostProcessor接口）

package com.linjie.cycle;

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

/**
 * bean的后置处理器
 * 分别在bean的初始化前后对bean对象提供自己的实例化逻辑
 * postProcessAfterInitialization：初始化之后对bean进行增强处理
 * postProcessBeforeInitialization：初始化之前对bean进行增强处理
 * @author LinJie
 * 
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    //对初始化之后的Bean进行处理
    //参数：bean：即将初始化的bean
    //参数：beanname：bean的名称
    //返回值：返回给用户的那个bean,可以修改bean也可以返回一个新的bean
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanname) throws BeansException {
        Student stu = null;
        System.out.println("对初始化之后的Bean进行处理,将Bean的成员变量的值修改了");
        if("name".equals(beanname) || bean instanceof Student) {
            stu = (Student) bean;
            stu.setName("Jack");
        }
        return stu;
    }

    //对初始化之前的Bean进行处理
    //参数：bean：即将初始化的bean
    //参数：beanname：bean的名称
    //返回值：返回给用户的那个bean,可以修改bean也可以返回一个新的bean
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanname) throws BeansException {
        System.out.println("对初始化之前的Bean进行处理,此时我的名字"+bean);
        return bean;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
测试类

package com.linjie.cycle;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试类
 * @author LinJie
 * 
 */
public class CycleTest {
    @Test
     public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        //Bean的使用
        student.play();
        System.out.println(student);
        //关闭容器
        ((AbstractApplicationContext) context).close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <!-- init-method：指定初始化的方法
        destroy-method：指定销毁的方法 -->
        <bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
        <property name="name" value="LINJIE"></property>
        </bean>
        
        <!-- 配置bean的后置处理器,不需要id，IoC容器自动识别是一个BeanPostProcessor -->
        <bean class="com.linjie.cycle.MyBeanPostProcessor"></bean> 
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
控制台显示结果

可以在applicationContext.xml中看到配置Bean后置处理器，不需要ID，只需要其全类名，因为IoC容器自动识别一个BeanPostProcessor

#####在控制台显示结果可以看出,Bean的后置处理器强大之处，可以对Bean实现自己想要做的事情，比如我这里的Demo就是在postProcessAfterInitialization方法中将成员变量name偷偷修改了，最后输出的就是偷偷修改之后的值

好了以上就是bean的一生，在控制台下将bean的一生映射出来，对理解bean的一生(生命周期)更加直观咯

####参考
《Spring揭秘》
《Spring IN ACTION》
--------------------- 
作者：浅然_ 
来源：CSDN 
原文：https://blog.csdn.net/w_linux/article/details/80086950 
版权声明：本文为博主原创文章，转载请附上博文链接！

sunstubble
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Bean的生命周期详细介绍
09-01
主要介绍了Spring Bean的生命周期的相关资料,需要的朋友可以参考下
Spring——Bean 的生命周期
浪漫不死的博客
03-21 1万+
目录一、Bean 的生命周期二、代码演示三、主要步骤简述 一、Bean 的生命周期   对于普通的 Java 对象，new 的时候会去创建对象，而当它没有任何引用的时候则被垃圾回收机制回收。相较于前者，由Spring IoC 容器托管的对象，它们的生命周期完全由容器控制。Spring 中每个 Bean 的生命周期如下： 对于 ApplicationContext 容器，当容器启动结束后，实例化所有的 Bean。 设置对象属性，即依赖注入，动态将依赖关系注入到对象中。 紧接着，Spring 会检测该对象
SpringBean的生命周期
04-04 2万+
网络上对于spring生命周期的总结很多，对初学者来说看起来眼花缭乱，实际上Spring Bean的生命周期只有四个阶段。把这四个阶段和每个阶段对应的扩展点糅合在一起虽然没有问题，但是这样非常凌乱，难以记忆。要彻底搞清楚Spring的生命周期，首先要把这四个阶段牢牢记住。实例化和属性赋值对应构造方法和setter方法的注入，初始化和销毁是用户能自定义扩展的两个阶段。在这四步之间穿插的各种扩展点，稍后会讲。 实例化 Instantiation 属性赋值 Populate 初始化 Initializati
Spring Bean生命周期详解
永无止境
04-18 5590
文章目录Spring bean生命周期13个环节阶段1：Bean元信息配置阶段阶段2：Bean元信息解析阶段阶段3：Spring Bean注册阶段 Spring bean生命周期13个环节 阶段1：Bean元信息配置阶段 阶段2：Bean元信息解析阶段 阶段3：将Bean注册到容器中 阶段4：BeanDefinition合并阶段 阶段5：Bean Class加载阶段 阶段6：Bean实例化阶段（...
Spring bean生命周期详解
weixin_44145478的博客
10-27 1万+
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。 Spring bean生命周期 四个阶段 Bean的实例化阶段 Bean的设置属性阶段 Bean的 初始化阶段 Bean的销毁阶段 Spring bean生命周期13个环节 阶段1：Bean元信息配置阶段 阶段2：Bean元信息解析阶段 阶段3：将Bean注册到容器中 阶段4：BeanDefinition合并阶段 阶段5：Bean Class加载阶段 阶段6：Bean实例化阶
Spring + Quartz配置实例(转载)
04-08
4. **Job和Trigger定义**：Spring可以自动管理Job和Trigger的生命周期。你需要创建实现了`org.quartz.Job`接口的类，定义具体的作业逻辑。然后，创建一个或多个`Trigger`，定义何时触发这个Job。触发器可以是...
（转载）自己动手写一个spring
03-28
在模拟实现Spring的过程中，读者会接触到如Bean的生命周期管理、AOP的编织过程、以及如何通过XML或注解配置Bean等关键概念。这样的实践有助于加深对Spring框架的理解，也能锻炼编程和设计能力。 总之，Spring框架...
jsr168 portlet(struts2+spring2.5+hibernate3.3)（转载）
04-22
在这个portlet项目中，Spring2.5可能被用来管理对象的生命周期，进行依赖注入，以及整合其他框架如Hibernate。 Hibernate3.3是一个持久化框架，简化了Java应用与数据库之间的交互。它提供了ORM（对象关系映射）功能...
Spring中bean的生命周期
kykangyuky的博客
02-24 3万+
Spring中的bean的生命周期主要包含四个阶段：实例化Bean --＞ Bean属性填充 --＞ 初始化Bean --＞销毁Bean 首先是实例化Bean，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚末初始化的依赖时，容器就会调用doCreateBean()方法进行实例化，实际上就是通过反射的方式创建出一个bean对象 Bean实例创建出来后，接着就是给这个Bean对象进行属性填充，也就是注入这个Bean依赖的其它bean对象 属性填充完成后，进行...
Spring中Bean的生命周期
weixin_71786285的博客
12-11 4537
Spring Bean的生命周期是从Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为四个阶段：实例化——>属性注入——>初始化——>销毁。 一、实例化Bean:根据配置文件中Bean 的定义，利用Java Reflection反射技术创建Bean的实例 实例化Bean：根据配置文件中Bean的定义，利用Java反射反射技术创建Bean的实例。
Spring之Bean的生命周期
weixin_74352229的博客
08-18 1883
所谓 Bean 的生命周期，就是一个 Bean 从创建到销毁，所经历的各种方法调用。简单的来说，一个Bean的生命周期分为四个阶段实例化(Instantiation)属性设置(populate)初始化(Initialization)销毁(Destruction)。
一文详解Spring Bean生命周期
2301_76607156的博客
04-26 585
之前我们在总结Spring扩展点：后置处理器时谈到了SpringBean的生命周期和其对Spring框架原理理解的重要性，所以接下来我们就来分析一下Bean生命周期的整体流程。首先Bean就是一些Java对象，只不过这些Bean不是我们主动newBean的实例化(Instantiation)
java面试-Spring中bean的生命周期（详解）
qq_41810415的博客
10-03 8067
如果创建了一个类继承了InstantiationAwareBeanPostProcessorAdapter接口，并在配置文件中配置了该类的注入，即InstantiationAwareBeanPostProcessorAdapter和bean关联，则Spring将调用该接口的postProcessBeforeInstantiation（）方法。根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。
Spring Bean的生命周期
weixin_71751896的博客
02-07 144
Spring Bean的生命周期
springBean的生命周期
weixin_70298631的博客
02-13 437
springBean的生命周期
Spring IOC详解 以及 Bean生命周期详细过程 可以硬刚面试官的文章
叶新东老师的博客
05-23 9148
面试题 来自面试官发自灵魂深处的拷问：谈谈你对spring的理解； 一脸懵逼的求职者的内心活动：啥？ 具体的问题是什么？现在的面试都不按套路出牌了吗？ 抛出一个这么大的问题，你让我怎么回答？ 一脸懵逼的求职者的回答：额~ ~ ~ 这个。。。。 额~ ~ ~ 那个。。。。额~ ~ ~ 不知道唉。。。 为什么面试官要问这种问题？ 不可否认，现在的大多数的面试出题方式都是这样的，惊人的相似，就是面试官喜欢抛出一个问题，看你能讲多深，考的就是你对这项技术的深度和广度，深度就是你对技...
史上最完整的Spring Bean的生命周期
qq_2662385590的博客
05-29 840
Bean的生命周期总。
Spring中bean的生命周期（最详细）
热门推荐
qq_35634181的博客
02-26 14万+
Spring Bean的生命周期是Spring面试热点问题。Spring Bean的生命周期指的是从一个普通的Java类变成Bean的过程，深知Spring源码的人都知道这个给面试官讲的话大可讲30分钟以上，如果你不没有学习过Spring的源码，可能就知道Aware接口和调用init方法这样的生命周期，所以这个问题既考察对Spring的微观了解，又考察对Spring的宏观认识，想要答好并不容易！本文希望能够从源码角度入手，帮助面试者彻底搞定Spring Bean的生命周期。 首先你要明白一点，Sp
spring生命周期和bean生命周期
最新发布
10-25
Spring 生命周期和 Bean 生命周期是密切相关的。在 Spring 容器中，每个 Bean 都有一个完整的生命周期，即从实例化、依赖注入，到销毁的过程，Spring 容器为我们管理了这些过程。Bean 生命周期包括 Bean 的创建、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值