云顶娱乐手机官网-云顶娱乐网址

热门关键词: 云顶娱乐手机官网,云顶娱乐网址

Bean的毕生(Bean的生命周期)

2019-09-23 作者:编辑程序   |   浏览(140)

2.3 Aware

spring DI最大的亮点是所有bean对spring容器的存在是没有意识的(即可替换容器,此时bean间耦合度很低),但实际开发中很有可能要用到spring本身的功能资源,这时候bean需要意识到spring容器的存在,才能调用spring所提供的资源。spring Aware中的接口可以让我们可获取spring的资源。

谈谈我对Spring Bean 生命周期的理解,springbean

前言

Spring的ioc容器功能非常强大,负责Spring的Bean的创建和管理等功能。而Spring 的bean是整个Spring应用中很重要的一部分,了解Spring Bean的生命周期对我们了解整个spring框架会有很大的帮助。

BeanFactory和ApplicationContext是Spring两种很重要的容器,前者提供了最基本的依赖注入的支持,而后者在继承前者的基础进行了功能的拓展,例如增加了事件传播,资源访问和国际化的消息访问等功能。本文主要介绍了ApplicationContext和BeanFactory两种容器的Bean的生命周期。

首先看下生命周期图:

图片 1 

再谈生命周期之前有一点需要先明确:

Spring 只帮我们管理单例模式 Bean 的 完整 生命周期,对于 prototype 的 bean ,Spring 在创建好交给使用者之后则不会再管理后续的生命周期。

注解方式

在 bean 初始化时会经历几个阶段,首先可以使用注解 @PostConstruct , @PreDestroy 来在 bean 的创建和销毁阶段进行调用:

@Component
public class AnnotationBean {
  private final static Logger LOGGER = LoggerFactory.getLogger(AnnotationBean.class);
  @PostConstruct
  public void start(){
    LOGGER.info("AnnotationBean start");
  }
  @PreDestroy
  public void destroy(){
    LOGGER.info("AnnotationBean destroy");
  }
}

InitializingBean, DisposableBean 接口

还可以实现 InitializingBean,DisposableBean 这两个接口,也是在初始化以及销毁阶段调用:

@Service
public class SpringLifeCycleService implements InitializingBean,DisposableBean{
  private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleService.class);
  @Override
  public void afterPropertiesSet() throws Exception {
    LOGGER.info("SpringLifeCycleService start");
  }
  @Override
  public void destroy() throws Exception {
    LOGGER.info("SpringLifeCycleService destroy");
  }
}

自定义初始化和销毁方法

也可以自定义方法用于在初始化、销毁阶段调用:

@Configuration
public class LifeCycleConfig {
  @Bean(initMethod = "start", destroyMethod = "destroy")
  public SpringLifeCycle create(){
    SpringLifeCycle springLifeCycle = new SpringLifeCycle() ;
    return springLifeCycle ;
  }
}
public class SpringLifeCycle{
  private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycle.class);
  public void start(){
    LOGGER.info("SpringLifeCycle start");
  }
  public void destroy(){
    LOGGER.info("SpringLifeCycle destroy");
  }
}

以上是在 SpringBoot 中可以这样配置,如果是原始的基于 XML 也是可以使用:

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

来达到同样的效果。

实现 *Aware 接口

*Aware 接口可以用于在初始化 bean 时获得 Spring 中的一些对象,如获取 Spring 上下文 等。

@Component
public class SpringLifeCycleAware implements ApplicationContextAware {
  private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleAware.class);
  private ApplicationContext applicationContext ;
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext ;
    LOGGER.info("SpringLifeCycleAware start");
  }
}

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

BeanPostProcessor 增强处理器

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

@Component
public class SpringLifeCycleProcessor implements BeanPostProcessor {
  private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleProcessor.class);
  /**
   * 预初始化 初始化之前调用
   * @param bean
   * @param beanName
   * @return
   * @throws BeansException
   */
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if ("annotationBean".equals(beanName)){
      LOGGER.info("SpringLifeCycleProcessor start 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)){
      LOGGER.info("SpringLifeCycleProcessor end beanName={}",beanName);
    }
    return bean;
  }
}

执行之后观察结果:

018-03-21 00:40:24.856 [restartedMain] INFO c.c.s.p.SpringLifeCycleProcessor - SpringLifeCycleProcessor start beanName=annotationBean
2018-03-21 00:40:24.860 [restartedMain] INFO c.c.spring.annotation.AnnotationBean - AnnotationBean start
2018-03-21 00:40:24.861 [restartedMain] INFO c.c.s.p.SpringLifeCycleProcessor - SpringLifeCycleProcessor end beanName=annotationBean
2018-03-21 00:40:24.864 [restartedMain] INFO c.c.s.aware.SpringLifeCycleAware - SpringLifeCycleAware start
2018-03-21 00:40:24.867 [restartedMain] INFO c.c.s.service.SpringLifeCycleService - SpringLifeCycleService start
2018-03-21 00:40:24.887 [restartedMain] INFO c.c.spring.SpringLifeCycle - SpringLifeCycle start
2018-03-21 00:40:25.062 [restartedMain] INFO o.s.b.d.a.OptionalLiveReloadServer - LiveReload server is running on port 35729
2018-03-21 00:40:25.122 [restartedMain] INFO o.s.j.e.a.AnnotationMBeanExporter - Registering beans for JMX exposure on startup
2018-03-21 00:40:25.140 [restartedMain] INFO com.crossoverjie.Application - Started Application in 2.309 seconds (JVM running for 3.681)
2018-03-21 00:40:25.143 [restartedMain] INFO com.crossoverjie.Application - start ok!
2018-03-21 00:40:25.153 [Thread-8] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.spring[email protected]3913adad: startup date [Wed Mar 21 00:40:23 CST 2018]; root of context hierarchy
2018-03-21 00:40:25.155 [Thread-8] INFO o.s.j.e.a.AnnotationMBeanExporter - Unregistering JMX-exposed beans on shutdown
2018-03-21 00:40:25.156 [Thread-8] INFO c.c.spring.SpringLifeCycle - SpringLifeCycle destroy
2018-03-21 00:40:25.156 [Thread-8] INFO c.c.s.service.SpringLifeCycleService - SpringLifeCycleService destroy
2018-03-21 00:40:25.156 [Thread-8] INFO c.c.spring.annotation.AnnotationBean - AnnotationBean destroy

直到 Spring 上下文销毁时则会调用自定义的销毁方法以及实现了 DisposableBean 的 destroy() 方法。

总结

以上所述是小编给大家介绍的Spring Bean 生命周期,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对帮客之家网站的支持!

Bean 生命周期的理解,springbean 前言 Spring的ioc容器功能非常强大,负责Spring的Bean的创建和管理等功能。而Spring 的bean是整个...

3. Bean创建对象过程

  1. 创建对象实例

    Object o = new Object();

  2. 依赖注入

    o.setXxx

  3. spring bean扩展方法

    init-method, BeanPostProcessor, xxxAware等

  4. Bean实例化的三种方式 详情


  • 构造器实例化
    spring容器通过bean对应的默认的构造函数来实例化bean。

  • 静态工厂方式实例化
    首先创建一个静态工厂类,在类中定义一个静态方法创建实例。

  • 实例工厂方式实例化
    该种方式的工厂类中,不再使用静态方法创建Bean实例,而是采用直接创建Bean实例的方式。同时在配置文件中,需要实例化的Bean也不是通过class属性直接指向其实例化的类,而是通过factory-bean属性配置一个实例工厂,然后使用factory-method属性确定使用工厂中哪个方法。

2.5 Bean的自定义初始化和销毁方法

如果要在bean初始化后销毁前需要执行特定的操作:

  • 使用注解,在指定的方法前加@PostConstruct / @PreDestory注解来指定该方法在初始化之后还是销毁之前调用;
  • 在xml配置bean时指定init-method / destroy-method属性指定初始化后/销毁之前调用的操作方法;
  • 实现InitializingBean / DisposableBean接口来定制初始化之后/销毁之前的操作方法
    InitializingBean:运行afterPropertiesSet()在所有bean属性被设置后
    DisposableBean:运行destory()在spring容器释放该bean之后

他们的执行顺序如下:
Bean在实例化时:Constructor → @PostConstruct → InitializingBean → init-method
Bean在销毁的过程中:@PreDestroy → DisposableBean → destroy-method

1. 什么是Bean?

Bean是spring中组成应用程序的主体由spring IoC容器所管理的对象(IoC容器初始化、装配及管理的对象)。如果把spring比作一座大型工厂,那么bean就是该工厂的产品。

题外话:bean这个单词翻译成中文有很多意思,豆子、嘴峰、毫无价值的东西...而事实上它是spring的核心,价值非凡。这个命名可能来自于开发者的一点恶趣味。如果留心,生活处处是惊喜,你可以在编程中获得不少乐趣。比如:Git翻译过来有“饭桶、无用的人”的意思,redis的端口6379来自于MERZ(长期以来被开发者antirez及其朋友当作愚蠢的代名词)...

Bean的毕生(Bean的生命周期)。5. Bean实例生命周期的执行过程

  1. 初始化spring容器(其实是第0步,bean生命周期不包括,但却是bean所必须的,也许可以看作产房?);
  2. spring对bean实例化,默认是单例;
  3. 检查Aware相关接口并设置相关依赖:
    1. 如果实现了BeanNameAware接口,spring将bean的id传给setBeanName()方法;
    2. 如果实现了BeanFactoryAware接口,spring调用setBeanFactory()方法,将BeanFactory实例传进来;
    3. 如果实现了ApplicationContextAware接口,spring调用setApplicationContext()会被调用,将应用上下文的应用传入到Bean中
  4. BeanPostProcessor前置处理,调用postProcessBeforeInitialization()
  5. 初始化相关:如果实现了InitializingBean接口,spring调用afterPropertiesSet();类似地,如果实现了init-method属性声明了初始化方法,该方法也会被调用;亦或是@PostConstruct注解
  6. BeanPostProcessor后置处理,调用postProcessorAfterInitialization()
  7. 注册必要的Destruction相关回调接口
  8. 此时bean已经准备就绪,可被程序使用了,将一直驻留在应用上下文中,直到该应用上下文被销毁
  9. 销毁相关: 如果实现了DisposableBean接口,spring调用destory();类似地,还有自定义销毁方法destory-method和注解@PreDestroy

2.2 应用上下文ApplicationContexts

应用上下文是spring容器抽象的一种实现,一种容器对象。

  • 其抽象接口ApplicationContext的本质:一个维护Bean定义以及对象之间协作关系的高级接口。

    比起BeanFactory,它能提供更多企业级的服务,例如解析配置文本信息等等,这也是应用上下文实例对象最常见的应用场景。有了上下文对象,我们就能向容器注册需要Spring管理的对象了。对于上下文抽象接口,Spring也为我们提供了多种类型的容器实现,供我们在不同的应用场景选择。详情请看:Spring基础篇——Spring容器和应用上下文理解

2.4 后置处理器BeanPostProcessor

此接口允许自定义修改新bean的一个实例,让我们可以在spring容器完成bean实例化、配置以及其他初始化方法前后添加一些自己的逻辑处理。含有两个方法,接口声明如下:

public interface BeanPostProcessor {    //bean初始化方法调用前被调用    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;    //bean初始化方法调用后被调用    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;}

2.1 spring容器

  • 容器是spring框架实现的核心,负责了对象整个生命周期的管理。
  • 容器是核心,而容器不唯一(spring容器 ∈ IoC容器)。并不是说只有Spring的容器才叫IOC容器,基于IOC容器的框架还有很多,并不是Spring特有的。框架本身就提供了很多个容器的实现。大概分为两种类型:一种是不常用的BeanFactory,这是最简单的容器,只能提供基本的DI功能;还有一种就是继承了BeanFactory后派生而来的应用上下文。

2. 在了解Bean的一生前,你需要了解一些东西

本文由云顶娱乐手机官网发布于编辑程序,转载请注明出处:Bean的毕生(Bean的生命周期)

关键词: