Spring注解驱动开发（二）

最新推荐文章于 2024-04-24 16:48:26 发布
最新推荐文章于 2024-04-24 16:48:26 发布
阅读量120 收藏
点赞数
分类专栏： spring
原文链接：http://blog.cuzz.site/2018/09/24/Spring%E6%B3%A8%E8%A7%A3%E9%A9%B1%E5%8A%A8%E5%BC%80%E5%8F%91%EF%BC%88%E4%BA%8C%EF%BC%89/
版权

The Spring Framework provides a comprehensive programming and configuration model for modern Java-based enterprise applications - on any kind of deployment platform.

声明周期@Bean指定初始化和销毁方法

Bean的生命周期

Bean的创建、初始化和销毁是由容器帮我们管理的

我们可以自定义初始化和销毁方法，容器在进行到当前生命周期的时候来调用我买自定义的初始化和销毁方法

构造（对象创建）

​ 单实例： 在容器启动的时候创建

​ 多实例： 在每次获取的时候创建对象

指定初始化方法

初始化：对象创建完成后，并赋值化，调用初始化方法

销毁：单实例是在容器关闭的时候销毁，多实例容器不会管理这个Bean，容器不会调用销毁方法

编写一个Car类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * @Author: cuzz
 * @Date: 2018/9/23 21:20
 * @Description:
 */
public class Car {

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

    public void init() {
        System.out.println("car...init...");
    }

    public void destroy() {
        System.out.println("car...destroy...");
    }
}

在xml中我们可以指定init-method和destroy-method方法，如

1

<bean id="car" class="com.cuzz.bean.Car" init-method="init" destroy-method="destroy"></bean>

使用注解我们可以

1
2
3
4
5
6
7
8
9
10
11
12
13

/**
 * @Author: cuzz
 * @Date: 2018/9/24 12:49
 * @Description: 配置类
 */
@Configuration
public class MainConfigOfLifecycle {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * @Author: cuzz
 * @Date: 2018/9/24 13:00
 * @Description:
 */
public class IOCTestLifeCycle {

    @Test
    public void test01() {
        // 创建ioc容器
        AnnotationConfigApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(MainConfigOfLifecycle.class);
        System.out.println("容器创建完成...");
        // 关闭容器
        System.out.println("--->开始关闭容器");
        applicationContext.close();
        System.out.println("--->已经关闭容器");
    }
}

可以看出先创建car，再调用init方法，在容器关闭时销毁实例

1
2
3
4
5
6

car constructor...
car...init...
容器创建完成...
--->开始关闭容器
car...destroy...
--->已经关闭容器

在配置数据源的时候，有很多属性赋值，销毁的时候要把连接给断开

生命周期InitializingBean和DisposableBean

InitializingBean

可以通过Bean实现InitializingBean来定义初始化逻辑，是设置好所有属性会调用afterPropertiesSet()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public interface InitializingBean {

	/**
	 * Invoked by a BeanFactory after it has set all bean properties supplied
	 * (and satisfied BeanFactoryAware and ApplicationContextAware).
	 * <p>This method allows the bean instance to perform initialization only
	 * possible when all bean properties have been set and to throw an
	 * exception in the event of misconfiguration.
	 * @throws Exception in the event of misconfiguration (such
	 * as failure to set an essential property) or if initialization fails.
	 */
	void afterPropertiesSet() throws Exception;

}

DisposableBean

可以通过Bean实现DisposableBean来定义销毁逻辑，会调用destroy()方法

1
2
3
4
5
6
7
8
9
10
11

public interface DisposableBean {

	/**
	 * Invoked by a BeanFactory on destruction of a singleton.
	 * @throws Exception in case of shutdown errors.
	 * Exceptions will get logged but not rethrown to allow
	 * other beans to release their resources too.
	 */
	void destroy() throws Exception;

}

例子

编写一个Cat类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
 * @Author: cuzz
 * @Date: 2018/9/24 13:36
 * @Description:
 */
public class Cat implements InitializingBean, DisposableBean{

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


    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat...init...");
    }

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

}

测试

1
2
3
4
5
6

cat constructor...
cat...init...
容器创建完成...
--->开始关闭容器
cat...destroy...
--->已经关闭容器

生命周期@PostContruct和@PreDestroy注解

@PostContruct在Bean创建完成并且属性赋值完成，来执行初始化

@PreDestroy在容器销毁Bean之前通知我们进行清理工作

编写一个Dog类，并把他注入到配置类中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * @Author: cuzz
 * @Date: 2018/9/24 14:03
 * @Description:
 */
public class Dog {

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

    @PostConstruct
    public void postConstruct() {
        System.out.println("post construct...");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("pre destroy...");
    }
}

测试结果

1
2
3
4
5
6

dog constructor...
post construct...
容器创建完成...
--->开始关闭容器
pre destroy...
--->已经关闭容器

生命周期BeanPostProscessor后置处理器

我们先看看源码，解释的很清楚，BeanPostProscessor 中postProcessBeforeInitialization方法会在每一个bean对象的初始化方法调用之前回调；postProcessAfterInitialization方法会在每个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
42
43
44
45
46
47
48
49
50
51
52
53

/**
 * Factory hook that allows for custom modification of new bean instances,
 * e.g. checking for marker interfaces or wrapping them with proxies.
 *
 * <p>ApplicationContexts can autodetect BeanPostProcessor beans in their
 * bean definitions and apply them to any beans subsequently created.
 * Plain bean factories allow for programmatic registration of post-processors,
 * applying to all beans created through this factory.
 *
 * <p>Typically, post-processors that populate beans via marker interfaces
 * or the like will implement {@link #postProcessBeforeInitialization},
 * while post-processors that wrap beans with proxies will normally
 * implement {@link #postProcessAfterInitialization}.
 */
public interface BeanPostProcessor {

	/**
	 * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
	 * or a custom init-method). The bean will already be populated with property values.
	 * The returned bean instance may be a wrapper around the original.
	 * @param bean the new bean instance
	 * @param beanName the name of the bean
	 * @return the bean instance to use, either the original or a wrapped one;
	 * if {@code null}, no subsequent BeanPostProcessors will be invoked
	 * @throws org.springframework.beans.BeansException in case of errors
	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
	 */
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

	/**
	 * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
	 * or a custom init-method). The bean will already be populated with property values.
	 * The returned bean instance may be a wrapper around the original.
	 * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean
	 * instance and the objects created by the FactoryBean (as of Spring 2.0). The
	 * post-processor can decide whether to apply to either the FactoryBean or created
	 * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
	 * <p>This callback will also be invoked after a short-circuiting triggered by a
	 * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
	 * in contrast to all other BeanPostProcessor callbacks.
	 * @param bean the new bean instance
	 * @param beanName the name of the bean
	 * @return the bean instance to use, either the original or a wrapped one;
	 * if {@code null}, no subsequent BeanPostProcessors will be invoked
	 * @throws org.springframework.beans.BeansException in case of errors
	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
	 * @see org.springframework.beans.factory.FactoryBean
	 */
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

编写一个MyBeanPostProcessor实现BeanPostProcessor接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * @Author: cuzz
 * @Date: 2018/9/24 14:21
 * @Description: 后置处理器，初始化前后进行处理工作
 */
public class MyBeanPostProcessor implements BeanPostProcessor{
    @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;
    }
}

添加到配置中

1
2
3
4
5
6
7
8
9
10
11
12
13

@Configuration
public class MainConfigOfLifecycle {

    @Bean
    public Cat cat() {
        return new Cat();
    }

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12

--->postProcessBeforeInitialization...org.springframework.context.event.internalEventListenerProcessor==>org.springframework.context.event.EventListenerMethodProcessor@1dc67c2
--->postProcessAfterInitialization...org.springframework.context.event.internalEventListenerProcessor==>org.springframework.context.event.EventListenerMethodProcessor@1dc67c2
--->postProcessBeforeInitialization...org.springframework.context.event.internalEventListenerFactory==>org.springframework.context.event.DefaultEventListenerFactory@2bd765
--->postProcessAfterInitialization...org.springframework.context.event.internalEventListenerFactory==>org.springframework.context.event.DefaultEventListenerFactory@2bd765
cat constructor...
--->postProcessBeforeInitialization...cat==>com.cuzz.bean.Cat@1d3b207
cat...init...
--->postProcessAfterInitialization...cat==>com.cuzz.bean.Cat@1d3b207
容器创建完成...
--->开始关闭容器
cat...destroy...
--->已经关闭容器

在实例创建之前后创建之后会被执行

生命周期BeanPostProcessor原理

通过debug到populateBean，先给属性赋值在执行initializeBean方法

1
2
3
4
5
6

try {
    populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
}

initializeBean方法时，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {


    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 执行before方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
	...
    try {
        // 执行初始化
        invokeInitMethods(beanName, wrappedBean, mbd);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        // 执行after方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

Spring底层对BeanPostProcessor的使用：

Bean赋值、注入其他组件、@Autowired、生命周期注解功能、@Async等等都使用到了BeanPostProcessor这个接口的实现类，很重要

总结

Bean 的初始化顺序

  1. 首先执行 bean 的构造方法
  2. BeanPostProcessor 的 postProcessBeforeInitialization 方法
  3. InitializingBean 的 afterPropertiesSet 方法
  4. @Bean 注解的 initMethod方法
  5. BeanPostProcesso r的 postProcessAfterInitialization 方法
  6. DisposableBean 的 destroy 方法
  7. @Bean注解的 destroyMethod 方法
LeoStudying
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring注解驱动开发
weixin_52055811的博客
01-08 699
Spring注解驱动开发
Spring注解驱动
weixin_48013460的博客
01-06 1324
1.1. Spring基础注解 1.1.1. @Configuration Spring配置Bean有多种形式，一种是XML方式，一种是@Configuration注解的方式，表示是一个配置类（同XML功能相同），作为Bean的载体。 package org.springframework.context.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import ja
spring配置实例化后执行的销毁方法比对
03-28
spring配置对象实例化后执行的方法，两种实现比对，通过DisposableBean接口，并实现destory()方法；或者通过applicationContext.xml配置destory-method属性
Spring应用手册-DisposableBean接口
11-28 5905
戴着假发的程序员出品 抖音ID：戴着假发的程序员 欢迎关注 DisposableBean接口 spring应用手册（第五部分） DisposableBean接口和InitializingBean接口一样，为bean提供了释放资源方法的方式，它只包括destroy方法，凡是继承该接口的类，在bean被销毁之前都会执行该方法。 这里要注意这里的destory和我们配置的destory-met
Spring—DisposableBean
zhangduilei的博客
11-22 2万+
在java的实际开发过程中，我们可能常常需要使用到init method和destroy method，比如初始化一个对象（bean）后立即初始化（加载）一些数据，在销毁一个对象之前进行垃圾回收等等。  周末对这两个方法进行了一点学习和整理，倒也不是专门为了这两个方法，而是在巩固spring相关知识的时候提到了，然后感觉自己并不是很熟悉这个，便好好的了解一下。  根据特意的去了解后，发现实际上
Spring之InitializingBean接口和DisposableBean接口介绍
波波烤鸭的博客
03-03 1万+
Spring中的生命周期核心方法讲解
【bean的生命周期】--- DisposableBean、destroyMethod和@PreDestroy
nrsc
11-25 4190
文章目录 源码地址:https://github.com/nieandsun/spring-study
spring DisposableBean作用，在spring Bean销毁时的钩子 以及@PreDestroy
最新发布
weixin_44131922的博客
04-24 865
在Spring框架中，DisposableBean是一个接口，它定义了一个单一的方法，用于在Spring容器关闭时或一个由Spring管理的Bean不再需要时执行特定的清理操作。DisposableBean接口在Spring框架中用于定义Bean的销毁逻辑，允许开发者在Bean生命周期结束时执行必要的资源释放、清理工作，以保证应用程序的健壮性和系统资源的有效管理。在Spring的XML配置文件中，可以直接为某个元素指定一个destroy-method属性，其值为Bean类中需要在销毁时调用的方法名。
Springboot扩展点系列_DisposableBean
皮球
10-30 296
从单元测试的执行结果来看，Spring容器关闭后，会触发执行DisposableBean#destroy()扩展方法的执行，所以如果我们的业务开发中，如果某些Bean在容器关闭后，需要做一些释放业务资源之类的操作，就能用到这个扩展点了。其实是这样的，你仔细观察会发现，触发Dog.destroy()方法执行并不是主线程，而是叫做SpringContextShutdownHook的线程，这里用到了多线程技术，单元测试执行完了，才触发Dog.destroy()方法执行是多线程异步执行的原因。
DisposableBean源码分析
duzhuang2399的博客
10-15 172
`DisposableBean` 接口允许执行某些资源清理操作，比如我们可以使用这个接口来确保某些资源，比如文件句柄、网络连接、数据库连接等，被正确地释放或清理。
Spring 扩展接口
雨后是冰雹
05-23 2438
Spring 扩展接口1. BeanPostProcessor2. BeanFactoryPostProcessor3. InitialingBean和DisposableBean4. FactoryBean5. BeanDefinitionRegistryPostProcessor6. BeanNameAware、ApplicationContextAware 和 BeanFactoryAware7. 后续再进行添加补充 1. BeanPostProcessor BeanPostProcessor 接口是
Spring注解驱动之InitializingBean和DisposableBean
抽象的螺旋
09-03 560
bean生命周期
【Spring系列】使用InitializingBean和DisposableBean来管理bean的生命周期
陈皮的JavaLib
02-19 2158
文章目录前言一、Bean 的生命周期一、InitializingBean 接口说明二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、Bean 的生命周期 通常意义上讲的bean的名称周期，指的是bean从创建到初始化，经过一系列的流程，最终销毁的过程。只不过，在Spring中，bean的生命周
一起来学习@PostConstruct注解
mikezhu的博客
08-08 938
在实际的开发过程当中，我们经常遇到各种依赖注入的场景，各种注解有时候的确让人犯迷糊，那么今天就来简单的说一下在开发过程中最常用的三个注解，希望对大家有所帮助。@Autowired注解是Spring框架提供的，用于自动装配Bean的依赖关系，可以用于字段、构造函数和方法上。在字段上标注@Autowired注解，Spring会尝试根据类型来查找对应的Bean，并将其注入到该字段中。通过在构造函数上标注@Autowired注解，Spring会自动创建依赖的实例并传递给构造函数，完成依赖注入。
spring中的DisposableBean和InitializingBean，ApplicationContextAware的用法
AlbenXie的博客
07-30 766
在spring容器初始化bean和销毁bean的以前的操作有很多种。 目前我知道的有： 在xml中定义的时候用init-method和destory-method， 还有一种就是定义bean的时候实现DisposableBean和InitializingBean 这两个接口， 打开InitializingBean 的源码： public interface InitializingBean { /** * Invoked by a BeanFactory after it ha
Spring 常用接口之 InitializingBean ,DisposableBean 接口
大灰狼的专栏
06-29 1万+
InitialingBean和DisposableBeanInitialingBean是一个接口，提供了一个唯一的方法afterPropertiesSet()。DisposableBean也是一个接口，提供了一个唯一的方法destory()。这两个接口是一组的，功能类似，因此放在一起：前者顾名思义在Bean属性都设置完毕后调用afterPropertiesSet()方法做一些初始化的工作，后者在B...
@PostConstruct详解
热门推荐
sunayn的博客
06-19 18万+
定义： @PostContruct是spring框架的注解，在方法上加该注解会在项目启动的时候执行该方法，也可以理解为在spring容器初始化的时候执行该方法。 从Java EE5规范开始，Servlet中增加了两个影响Servlet生命周期的注解，@PostConstruct和@PreDestroy，这两个注解被用来修饰一个非静态的void（）方法。 用法： @Post......
Spring创建bean之初始化Bean和注册DisposableBean
qq_40708942的博客
05-23 400
初始化Bean bean配置的时候,有一个init-method的属性,这个属性就是在bean初始化的时候调用指定的方法来进行初始化. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { // 判断是否需要权限 if (System.getSecurityManager() != null) { // 需要权限
死磕源码系列【springboot初始化值InitializingBean、DisposableBean、init-method和@PostConstruct源码解析】
OceanSky的专栏
11-28 909
Spring容器中的Bean是有生命周期的，spring允许在bean的初始化完成之后以及Bean的销毁执行之前执行特定的操作，常用的设定方式有以下三种： 通过实现InitializingBean和DisposableBean接口来定制初始化之后及销毁之前的操作方法； 通过在@Bean注解或元素上的initMethod、destroyMethod属性指定初始化之后及销毁之前调用的操作方法； 在指定的方法上加@PostConstruct、@PreDestroy注解来指定该方法在初始化之前及初始化之后调用
Spring注解驱动开发详解
"Spring注解驱动开发的相关笔记，主要涉及@Configuration、@Bean、@ComponentScan等核心注解的详细解释和使用示例。" 在Spring框架中，注解驱动的开发极大地简化了XML配置，提高了代码的可读性和可维护性。以下是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值