Spring Boot IoC（五）Bean生命周期

五、Bean生命周期简介之前的Ioc学习中，我们只是关心如何正确的将Bean装配到Ioc容器中，而没有关心IoC容器如何装配和销毁bean的过程。有时候我们也需要自定义初始化或者销毁Bean的过程，以满足一些Bean的特殊初始化和销毁的要求。为了解决这些问题，我们有必要了解Spring Ioc初始化和销毁Bean的过程，这边是Bean的生命周期的过程。它大致分为Bean定义，bean初始化，b..

Sadlay

6504人浏览 · 2018-10-22 18:53:27

Sadlay · 2018-10-22 18:53:27 发布

上一篇 Spring Boot IoC（四）依赖注入DI

五、Bean生命周期

简介

之前的Ioc学习中，我们只是关心如何正确的将Bean装配到Ioc容器中，而没有关心IoC容器如何装配和销毁bean的过程。有时候我们也需要自定义初始化或者销毁Bean的过程，以满足一些Bean的特殊初始化和销毁的要求。为了解决这些问题，我们有必要了解Spring Ioc初始化和销毁Bean的过程，这边是Bean的生命周期的过程。它大致分为Bean定义，bean初始化，bean的生存期和bean的销毁4个部分。

延迟依赖注入

spring的bean初始化如下图
在这里插入图片描述

先看前3步：

spring通过我们的配置，如@ComponentScan定义的扫描路径去找到带有@Component的类，这个过程就是一个资源定位的过程。
一旦找到资源，那么它就开始解析，并将定义的信息保存起来，注意，此时还没有初始化bean，也就没有bean的实例，它有的仅仅是bean的定义。
然后就会把bean定义发布到Spring IoC容器中。此时，IoC容器也只有bean的定义，还是没有bean的实例生成。

完成这3步只是一个资源定位并将Bean的定义发布到Ioc容器的过程。还没有Bean实例的成成，更没有依赖注入。在默认情况下，spring会如图所示去完成bean的实例化和依赖注入，这样从Ioc容器中就可以得到一个依赖注入完成的bean。但是，有些bean会受到变化因素的影响，这时候我们到希望是取出bean的时候完成初始化和依赖注入，换句话说就是让那些bean只是将定义发布到ioc容器而不做实例化和依赖注入，当我们取出来的时候才做初始化和依赖注入操作。

@Component中有一个配置像lazyInit，默认为false，不进行延迟初始化。因此在默认的情况下spring会对bean进行实例化和依赖注入对应的属性值。

我们首先定义两个接口和实现类

Shoes接口（需要注入的接口）

package com.lay.ioc.pojo.definiion;

public interface Shoes {
	
	public void put();
}

Person接口

package com.lay.ioc.pojo.definiion;

public interface Person {
	
	public void activity();

	public void setShoes(Shoes shoes);
}

Shoes接口实现类BasketShoes

package com.lay.ioc.pojo;

import org.springframework.stereotype.Component;

import com.lay.ioc.pojo.definiion.Shoes;
@Component
public class BasketShoes implements Shoes{

	@Override
	public void put() {
		System.out.println("穿篮球鞋【"+BasketShoes.class.getSimpleName()+"】去打球");
	}

}

Person实现类Programmer

@Component
public class Programmer implements Person, BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private Shoes shoes = null;
    
    @Override
    public void activity() {
        this.shoes.put();
    }
    
    @Override
    @Autowired
    @Qualifier("basketShoes")
    public void setShoes(Shoes shoes) {
        System.out.println("延迟依赖注入");
        this.shoes = shoes;
    }
}

这里我们在setShoes方法里打印一句话

AppConfig配置类

package com.lay.ioc.config;
/**
 * @ComponentScan 标明会进行扫描
 * @author Lay
 */

@ComponentScan(basePackages= {"com.lay.ioc.*"})
@EnableAutoConfiguration
@Configuration
public class AppConfig {
}

测试类

package com.lay.ioc.config;

public class IoCTest {
    private static Logger log = LoggerFactory.getLogger(IocApplication.class);
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);
        Person person=ctx.getBean(Programmer.class);//在这里打断点进行调试查看
        person.activity();
        ctx.close();
    }
   
}

我们在测试类的getBean方法上打断点，启动调试，会发现我们还并没有获取bean的实例，而日志就已经打印出了我们打印的语句，可见它是在ioc容器初始化时就执行了实例化和依赖注入。

为了改变这个情况，我们在配置类AppConfig加入lazyInit配置

package com.lay.ioc.config;
/**
 * @ComponentScan 标明会进行扫描
 * @author Lay
 */

@ComponentScan(basePackages= {"com.lay.ioc.*"},lazyInit=true)
@EnableAutoConfiguration
@Configuration
public class AppConfig {
}

然后进行测试，就会发现我们输出的语句“延迟依赖注入”并没有出现在控制台日志中。只有运行过断点处才会出现。这就是我我们把它修改为了延迟初始化。spring并不会在发布bean定义后马上为我们完成实例化和依赖注入。

Bean的生命周期

如果仅仅是实例化和依赖注入还是比较简单的，还不能完成进行自定义的要求。为了完成依赖注入的功能，spring在依赖注入之后，还提供了一系列的接口和配置来完成bean的初始化的过程。

图中描述的是整个ioc容器初始化bean的过程。

在这里插入图片描述

注意这些接口都是针对生命而言的。在没有注释的情况下的流程节点都是针对单个Bean而言的，但是BeanProcessor是针对所有Bean而言的。
即使你定义了ApplicationContextAware接口，但是有时候并不会调用，这要根据你的Ioc容器来决定，我们知道，Spring ioc容器最低额要求是实现BeanFactory接口。而不是实现ApplicationContext接口。对于那些没有实现ApplicationContext接口的容器，在生命周期对应的ApplicationContextAware定义的方法也是不会被调用的，只有实现了ApplicationContext接口的容器，才会在生命周期调用ApplicationAware所定义的setApplicationContext方法。

我们对Programmer进行改造模拟Bean的生命周期

Programmer

package com.lay.ioc.pojo;
@Component
public class Programmer implements Person, BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
    //@Autowired
    private Shoes shoes = null;
    
    @Override
    public void activity() {
        this.shoes.put();
    }
    
    @Override
    @Autowired
    @Qualifier("basketShoes")
    public void setShoes(Shoes shoes) {
        System.out.println("延迟依赖注入");
        this.shoes = shoes;
    }
    
    @Override
    public void setBeanName(String name) {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用BeanNameAware的setBeanName()方法");
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用BeanFactoryAware的setBeanFactory()方法");
    }
    

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用ApplicationContextAware的setApplicationContext()方法");
    }


    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用InitializingBean的afterPropertiesSet()方法");
    }
    
    @PostConstruct
    public void init() {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用注解@PostConstruct定义的自定义初始化方法");
    }
    
    @PreDestroy
    public void destroy1() {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用 注解@PreDestroy定义的自定义销毁方法");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("【"+this.getClass().getSimpleName()+"】调用DisposableBean的destroy()方法");
    }

}

这样，这个Bean就实现了生命周期中单个Bean可以实现的所有接口，并且通过注解@PostConstruct定义了初始化方法，通过注解@PreDestroy定义了自定义销毁方法。为了测试Bean的后置处理器，我们创建一个类BeanPostProcessorDemo来实现BeanPostProcessor，方法是针对所有Bean都生效的。

package com.lay.ioc.life;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
@Component
public class BeanPostProcessDemo implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcess调用postProcessBeforeInitialization()方法，参数【"+bean.getClass().getSimpleName()+"】 【"+beanName+"】");
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcess调用postProcessAfterInitialization()方法，参数【"+bean.getClass().getSimpleName()+"】 【"+beanName+"】");
        return bean;
    }
}

注意，这个Bean后置处理器将对所有的Bean生效。

测试

package com.lay.ioc.config;


public class IoCTest {
    private static Logger log = LoggerFactory.getLogger(IocApplication.class);
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);
        Person person=ctx.getBean(Programmer.class);
        //关闭IoC容器
        ctx.close();
    }
}

观察日志

BeanPostProcess调用postProcessBeforeInitialization()方法，参数【BasketShoes】 【basketShoes】
BeanPostProcess调用postProcessAfterInitialization()方法，参数【BasketShoes】 【basketShoes】
18:08:31.354 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Finished creating instance of bean 'basketShoes'
18:08:31.354 [main] DEBUG org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor - Autowiring by type from bean name 'programmer' to bean named 'basketShoes'
延迟依赖注入
【Programmer】调用BeanNameAware的setBeanName()方法
【Programmer】调用BeanFactoryAware的setBeanFactory()方法
【Programmer】调用ApplicationContextAware的setApplicationContext()方法
BeanPostProcess调用postProcessBeforeInitialization()方法，参数【Programmer】 【programmer】
18:08:31.354 [main] DEBUG org.springframework.context.annotation.CommonAnnotationBeanPostProcessor - Invoking init method on bean 'programmer': public void com.lay.ioc.pojo.Programmer.init()
【Programmer】调用注解@PostConstruct定义的自定义初始化方法
18:08:31.354 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Invoking afterPropertiesSet() on bean with name 'programmer'
【Programmer】调用InitializingBean的afterPropertiesSet()方法
BeanPostProcess调用postProcessAfterInitialization()方法，参数【Programmer】 【programmer】
18:08:31.354 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Finished creating instance of bean 'programmer'
18:08:31.355 [main] INFO org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@490d6c15: startup date [Mon Oct 22 18:08:30 CST 2018]; root of context hierarchy
18:08:31.355 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'lifecycleProcessor'
18:08:31.356 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@57855c9a: defining beans org.springframework.boot.autoconfigure.info.ProjectInfoProperties,org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,restTemplateBuilder]; root of factory hierarchy
18:08:31.356 [main] DEBUG org.springframework.context.annotation.CommonAnnotationBeanPostProcessor - Invoking destroy method on bean 'programmer': public void com.lay.ioc.pojo.Programmer.destroy1()
【Programmer】调用 注解@PreDestroy定义的自定义销毁方法
18:08:31.356 [main] DEBUG org.springframework.beans.factory.support.DisposableBeanAdapter - Invoking destroy() on bean with name 'programmer'
【Programmer】调用DisposableBean的destroy()方法

从日志中可以看出，对于Bean后置处理器（BeanPostProcessor）而言，它对所有的Bean都起作用。而其他的接口则是对于单个Bean起作用。有时候Bean的定义可能使用的是第三方的类，此时可以使用注解@Bean来配置自定义初始化和销毁方法，如下

@Bean(initMethod="init",destroyMethod="destroy")

最后补一张Bean生命周期最全的图
在这里插入图片描述

下一篇 Spring Boot IoC（六）使用properties配置文件

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

云原生

所有评论(0)

查看更多评论

Sadlay

@Sadlay

已为社区贡献1条内容