Bean 生命周期

对于普通的Java对象，当new的时候创建对象，当它没有任何引用的时候被垃圾回收机制回收。而由Spring IoC容器托管的对象，它们的生命周期完全由容器控制。

Bean生命周期流程

1.实例化Bean

实例化Bean对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。

对于ApplicationContext容器，当容器启动结束后，便实例化所有的bean。

容器通过获取BeanDefinition对象中的信息进行实例化。并且这一步仅仅是简单的实例化，并未进行依赖注入。 实例化对象被包装在BeanWrapper对象中，BeanWrapper提供了设置对象属性的接口，从而避免了使用反射机制设置属性。

2.设置对象属性（依赖注入）

实例化后的对象被封装在BeanWrapper对象中，并且此时对象仍然是一个原生的状态，并没有进行依赖注入。 紧接着，Spring根据BeanDefinition中的信息进行依赖注入。 并且通过BeanWrapper提供的设置属性的接口完成依赖注入。

3.注入Aware接口

紧接着，Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给bean。

  • 如果这个Bean实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的是Spring配置文件中Bean的ID
  • 如果这个Bean实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()，传递的是Spring工厂本身（可以用这个方法获取到其他Bean）
  • 如果这个Bean实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文，ApplicationContext是BeanFactory的子接口，有更多的实现方法

4.BeanPostProcessor

当经过上述几个步骤后，bean对象已经被正确构造，但如果你想要对象被使用前再进行一些自定义的处理，就可以通过BeanPostProcessor接口实现。

该接口提供了两个函数：

  • postProcessBeforeInitialzation( Object bean, String beanName )

当前正在初始化的bean对象会被传递进来，我们就可以对这个bean作任何处理。 这个函数会先于InitialzationBean执行，因此称为前置处理。 所有Aware接口的注入就是在这一步完成的。

  • postProcessAfterInitialzation( Object bean, String beanName )

当前正在初始化的bean对象会被传递进来，我们就可以对这个bean作任何处理。 这个函数会在InitialzationBean完成后执行，因此称为后置处理。

5.InitializingBean与init-method

当BeanPostProcessor的前置处理完成后就会进入本阶段。

InitializingBean接口只有一个函数：

  • afterPropertiesSet()

这一阶段也可以在bean正式构造完成前增加我们自定义的逻辑，但它与前置处理不同，由于该函数并不会把当前bean对象传进来，因此在这一步没办法处理对象本身，只能增加一些额外的逻辑。 若要使用它，我们需要让bean实现该接口，并把要增加的逻辑写在该函数中。然后Spring会在前置处理完成后检测当前bean是否实现了该接口，并执行afterPropertiesSet函数。

当然，Spring为了降低对客户代码的侵入性，给bean的配置提供了init-method属性，该属性指定了在这一阶段需要执行的函数名。Spring便会在初始化阶段执行我们设置的函数。init-method本质上仍然使用了InitializingBean接口。

6. DisposableBean和destroy-method

和init-method一样，通过给destroy-method指定函数，就可以在bean销毁前执行指定的逻辑。

代码示例

注解方式

package com.easy.bean;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

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

@Component
@Slf4j
public class AnnotationBean {
    @PostConstruct
    public void start() {
        log.info("AnnotationBean 开始初始化");
    }

    @PreDestroy
    public void destroy() {
        log.info("AnnotationBean 开始销毁");
    }
}

InitializingBean, DisposableBean 接口

package com.easy.bean;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class SpringLifeCycleService implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("SpringLifeCycleService 开始");
    }

    @Override
    public void destroy() throws Exception {
        log.info("SpringLifeCycleService 销毁");
    }
}

自定义初始化和销毁方法

package com.easy.bean;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SpringLifeCycle {
    public void start() {
        log.info("SpringLifeCycle 开始初始化");
    }

    public void destroy() {
        log.info("SpringLifeCycle 开始销毁");
    }
}

配置添加

package com.easy.bean;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LifeCycleConfig {
    @Bean(initMethod = "start", destroyMethod = "destroy")
    public SpringLifeCycle create() {
        SpringLifeCycle springLifeCycle = new SpringLifeCycle();
        return springLifeCycle;
    }
}

或者通过xml配置如下

<bean class="com.easy.bean.SpringLifeCycle" init-method="start" destroy-method="destroy"></bean>

实现 xxxAware 接口

package com.easy.bean;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class SpringLifeCycleAware implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        log.info("SpringLifeCycleAware 开始");
    }
}

这样在 springLifeCycleAware 这个 bean 初始化会就会调用 setApplicationContext 方法，并可以获得 applicationContext 对象。

BeanPostProcessor 增强处理器

实现 BeanPostProcessor 接口，Spring 中所有 bean 在做初始化时都会调用该接口中的两个方法，可以用于对一些特殊的 bean 进行处理

package com.easy.bean;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class SpringLifeCycleProcessor implements BeanPostProcessor {

    /**
     * 预初始化 初始化之前调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("annotationBean".equals(beanName)) {
            log.info("SpringLifeCycleProcessor 开始初始化 beanName={}", beanName);
        }
        return bean;
    }

    /**
     * 后初始化  bean 初始化完成调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("annotationBean".equals(beanName)) {
            log.info("SpringLifeCycleProcessor 初始化结束 beanName={}", beanName);
        }
        return bean;
    }
}

运行示例查看控制台输出

2020-01-09 17:46:37.022  INFO 9544 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2020-01-09 17:46:37.023  INFO 9544 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1642 ms
2020-01-09 17:46:37.081  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleProcessor   : SpringLifeCycleProcessor 开始初始化 beanName=annotationBean
2020-01-09 17:46:37.089  INFO 9544 --- [           main] com.easy.bean.AnnotationBean             : AnnotationBean 开始初始化
2020-01-09 17:46:37.089  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleProcessor   : SpringLifeCycleProcessor 初始化结束 beanName=annotationBean
2020-01-09 17:46:37.090  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleAware       : SpringLifeCycleAware 开始
2020-01-09 17:46:37.091  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleService     : SpringLifeCycleService 开始
2020-01-09 17:46:37.093  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycle            : SpringLifeCycle 开始初始化
2020-01-09 17:46:37.279  INFO 9544 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'

资料

原文地址：https://www.cnblogs.com/tqlin/p/12173065.html

时间： 2024-08-27 17:15:40

Bean 生命周期的相关文章

Spring点滴四：Spring Bean生命周期

Spring Bean 生命周期示意图: 了解Spring的生命周期非常重要,我们可以利用Spring机制来定制Bean的实例化过程. --------------------------------------------------------------------------------------------------------------------------------------------------- spring-service.xml: <?xml version=

bean生命周期

那在spring中bean的生命周期究竟是怎样的呢 1. 容器寻找Bean的定义信息并将其实例化 2. 使用依赖注入,spring按照Bean定义信息配置Bean的所有属性 3. 如果Bean实现了BeanNameAware接口,工厂调用Bean的SetBeanName()方法传递Bean的ID 4. 如果Bean实现了BeanFactoryAware接口,工厂调用setBeanFactory()方法传入工厂自身 5. 如果BeanPostProcessor和Bean关联,那么其postProc

【Spring学习】Bean生命周期

我理解的Bean生命周期包括两个方面: Bean何时创建,何时销毁 Bean从创建到销毁的执行流程 一.Bean创建与销毁 Bean的创建时机主要由几个配置项共同来决定,包括: scope属性,决定是Bean是单例模式(singleton)还是多例模式(prototype),默认为单例singleton: lazy-init属性,只对单例模式有效,决定是否延时加载,默认为false,表示在容器初始化时,就会生成单例: RequestMapping属性,这个注解MVC中才有,当有该属性时,lazy

Spring事务，Bean生命周期

一.事务相关: 1.Spring事务基于Spring AOP切面编程: 2.AOP基于代理模式,得到需要开启事务的代码的代理对象: 3.而没有开启事务的Service方法里调用了开启事务 @Transactional 的方法时,整个代码是不会开启事务的,原理还是代理模式插入事务的依据是最外层的注解: 4.对于上面3,反之,则可以,这是事务的传播机制. 二.Bean生命周期: 2.1生命周期图: 出自:<精通Spring 4.x> 2.2不同级别的接口分类: 1.Bean本身的方法:Bean的构

一步步剖析spring bean生命周期

关于spring bean的生命周期,是深入学习spring的基础,也是难点,本篇文章将采用代码+图文结论的方式来阐述spring bean的生命周期, 本篇文章将阐述清楚下图. 一  项目结构及源码 1.程序目录结构 2.applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/sc

[Spring实战系列]（10）初探Bean生命周期

1. 生命周期流程图 Bean在Spring容器中从创建到销毁经历了若干个阶段,在每一个阶段都可以针对Spring如何管理Bean进行个性化定制. 正如你所见,在Bean 准备就绪之前,Bean 工厂执行了若干启动步骤. Spring 对Bean 进行实例化. Spring 将值和Bean 的引用注入进Bean 对应的属性中. 如果Bean 实现了BeanNameAware接口,Spring 将Bean的ID传递给setBeanName() 接口方法. 如果Bean 实现了BeanFactory

Spring Bean生命周期

1.Bean的建立:BeanFactory容器寻找Bean的定义信息,读取Bean定义文件,并将其实例化,生成各个Bean实例.2.属性注入:使用依赖注入,Spring按照Bean定义信息配置Bean所有属性.3.BeanNameAware的setBeanName():传递Bean的ID.4.BeanFactoryAware的setBeanFactory():工厂调用setBeanFactory()方法传入工厂自身.如果是使用ApplicationContext来生成并管理Bean的话则稍有不同

spring容器对bean生命周期的管理三中方式

spring容器对bean的生命周期管理主要在两个时间点:bean的初始化完成(包括属性值被完全注入),bean的销毁(程序结束,或者引用结束)方式一:使用springXML配置中的init-method="init" destroy-method="destory" 这个两个配置,可以实现两个时间点插入定制的操作.方式二: 使用spring提供的2个接口:InitializingBean,DisposableBean方式三:使用java注解:@PostConstr

从启动日志看Spring IOC的初始化和Bean生命周期

一.Tomcat中启动IoC容器的日志 启动Tomcat等容器时,控制台每次都打印出一些日志. 最近刚好在研究Spring源码,所以换个角度,从启动日志来简单的看看Spring的初始化过程! 以下是Tomcat启动时日志,截取Spring部分. //------------------------------------- //从这里开始Spring的初始化 十一月 10, 2015 8:52:03 上午 org.apache.catalina.core.ApplicationContext l