bean的生命周期

厄尔尼诺的夏天

已于 2022-10-12 15:07:43 修改

阅读量804

点赞数

分类专栏： Spring 文章标签： java spring

于 2022-10-12 10:14:45 首次发布

原文链接：https://blog.csdn.net/weixin_45723046/article/details/124546319

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

bean的生命周期

前置：getBean和new的区别？

Spring是使用反射创建的对象，可指定对象的生命周期；如果是直接new的话就是直接创建一个对象。
Spring实现了对象池，一些对象创建和使用完毕之后不会被销毁，放进对象池（某种集合）以备下次使用，下次再需要这个对象，不new，直接从池里取，节省时间。
使用new关键字创建的对象属于强引用对象，所谓强引用，就是jvm垃圾回收机制永远不会回收这类对象，这时候需要手动移除引用。如果没有移除，这个对象将一直存在，久而久之，会引起内存泄露问题。
使用spring中的IOC就能很好的解决上述问题，使用IOC创建对象的时候，则无需关心由于创建对象的问题而引发的内存泄露问题。
spring之所以不用new对象是因为类的构造方法一旦被修改，new的对象就出错了，如果是用了spring，就不用理会构造方法是否被修改，而拿来用就可以。

bean的作用域：

bean的作用域指的就是spring容器创建bean完成后的生命周期，就是从创建到销毁的整个过程。spring默认的作用域是Singleton。

作用域类型	使用范围	作用域描述
singleton	所用spring应用	默认值，IoC容器只存在单例
prototype	所有spring应用	每当从ioc容器中获取一个bean，则创建一个新的bean
session	spring web 应用	http 会话
application	spring web 应用	web工程生命周期
request	spring web 应用	web 单次请求
globalSession	spring web 应用	在一个全局的httpsession 中，一个bean对应一个实例。

bean生命周期示意图:

Bean 的初始化和销毁；

1、@Bean注解中使用init-method属性和destroy-method属性来指定初始化方法和销毁方法。

初始化和销毁方法的时机：

你有没有想过这样一个问题，初始化方法和销毁方法是在什么时候被调用的啊？

bean对象的初始化方法调用的时机：对象创建完成，如果对象中存在一些属性，并且这些属性也都赋好值之后，那么就会调用bean的初始化方法。对于单实例bean来说，在Spring容器创建完成后，Spring容器会自动调用bean的初始化方法；对于多实例bean来说，在每次获取bean对象的时候，调用bean的初始化方法。
bean对象的销毁方法调用的时机：对于单实例bean来说，在容器关闭的时候，会调用bean的销毁方法；对于多实例bean来说，Spring容器不会管理这个bean，也就不会自动调用这个bean的销毁方法了。不过，小伙伴们可以手动调用多实例bean的销毁方法。

InitializingBean

在这里插入图片描述

多实例bean的生命周期不归Spring容器来管理，这里的DisposableBean接口中的方法是由Spring容器来调用的，所以如果一个多实例bean实现了DisposableBean接口是没有啥意义的，因为相应的方法根本不会被调用，当然了，在XML配置文件中指定了destroy方法，也是没有任何意义的。所以，在多实例bean情况下，Spring是不会自动调用bean的销毁方法的。

Spring中提供了一个InitializingBean接口，该接口为bean提供了属性初始化后的处理方法，它只包括afterPropertiesSet方法，凡是继承该接口的类，在bean的属性初始化后都会执行该方法。

//@Component
public class Cat implements InitializingBean, DisposableBean {

    public Cat(){
        System.out.println("Cat...constructor...构造器");
    }

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

    @Override
    public void afterPropertiesSet() throws Exception {

        System.out.println("Cat...afterPropertiesSet...");
    }
}

InitializingBean源码：

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {

   boolean isInitializingBean = (bean instanceof InitializingBean);
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (logger.isTraceEnabled()) {
         logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
      }
      if (System.getSecurityManager() != null) {
         try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
               ((InitializingBean) bean).afterPropertiesSet();
               return null;
            }, getAccessControlContext());
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         ((InitializingBean) bean).afterPropertiesSet();
      }
   }

   if (mbd != null && bean.getClass() != NullBean.class) {
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}

分析上述代码后，我们可以初步得出如下信息：

1、Spring为bean提供了两种初始化的方式，实现InitializingBean接口（也就是要实现该接口中的afterPropertiesSet方法），或者在配置文件或@Bean注解中通过init-method来指定，两种方式可以同时使用。

2、实现InitializingBean接口是直接调用afterPropertiesSet()方法，与通过反射调用init-method指定的方法相比，效率相对来说要高点。但是init-method方式消除了对Spring的依赖。

3、如果调用afterPropertiesSet方法时出错，那么就不会调用init-method指定的方法了。

小结
也就是说Spring为bean提供了两种初始化的方式，第一种方式是实现InitializingBean接口（也就是要实现该接口中的afterPropertiesSet方法），第二种方式是在配置文件或@Bean注解中通过init-method来指定，这两种方式可以同时使用，同时使用先调用afterPropertiesSet方法，后执行init-method指定的方法。

 * 在Spring容器创建完成时，会自动调用单实例bean的构造方法，对单实例bean进行了实例化操作。
 *  * 多实例的bean在容器关闭的时候是不进行销毁的，也就是说你每次获取时，IOC容器帮你创建出
      对象交还给你，
 * 至于要什么时候销毁这是你自己的事，Spring容器压根就不会再管理这些多实例的bean了。
 *          * 单实例：在容器启动的时候创建对象；
            * 多实例：在每次获取的时候创建对象；
 *  * 初始化：
 *      对象创建好，并赋值好，调用初始化方法；
 *  * 销毁：
 *      单实例：容器关闭的时候；
 *      多实例：容器不会管理Bean，只是负责创建，容器不会调用销毁方法；
 *  * 1、指定初始化和销毁的方法；
 *    2、通过Bean 实现InitializingBean和DisposableBean
 *      InitializingBean(定义初始化逻辑)
 *      DisposableBean（定义销毁逻辑）

2、@PostConstruct和@PreDestroy这俩注解

@PostConstruct：在bean创建完成并且属性赋值完成之后，来执行初始化方法
@PreDestroy：在容器销毁bean之前通知我们进行清理工作

//@Component
public class Dog {


    private Cat cat;

    public Dog(){
        System.out.println("dog...constructor..构造器");
    }
    
    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }
    
    //对象创建赋值之后调用
    @PostConstruct
    public void init(){
        System.out.println("dog...@PostConstruct...");
    }

    //容器移除对象之前
    @PreDestroy
    public void destory(){
        System.out.println("dog...@PreDestroy...");
    }
}

3、通过让bean实现BeanPostProcessor接口

@Component
public class MyBeanPostProcessor implements BeanPostProcessor, Ordered {

    @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;
    }

    @Override
    public int getOrder() {
        return 3;
    }
}

通过以上这四种方式，我们就可以对bean的整个生命周期进行控制：

bean的实例化：调用bean的构造方法，我们可以在bean的无参构造方法中执行相应的逻辑。
bean的初始化：在初始化时，可以通过BeanPostProcessor的postProcessBeforeInitialization()方法和postProcessAfterInitialization()方法进行拦截，执行自定义的逻辑；通过@PostConstruct注解、InitializingBean和init-method来指定bean初始化前后执行的方法，在该方法中咱们可以执行自定义的逻辑。
bean的销毁：可以通过@PreDestroy注解、DisposableBean和destroy-method来指定bean在销毁前执行的方法，在该方法中咱们可以执行自定义的逻辑。

所以，通过上述四种方式，我们可以控制Spring中bean的整个生命周期。

BeanPostProcessor后置处理器作用

后置处理器可用于bean对象初始化前后进行逻辑增强。
Spring提供了BeanPostProcessor接口的很多实现类，例如AutowiredAnnotationBeanPostProcessor用于@Autowired注解的实现，AnnotationAwareAspectJAutoProxyCreator用于Spring AOP的动态代理等等。

除此之外，我们还可以自定义BeanPostProcessor接口的实现类，在其中写入咱们需要的逻辑。下面我会以AnnotationAwareAspectJAutoProxyCreator为例，简单说明一下后置处理器是怎样工作的。

我们都知道spring AOP的实现原理是动态代理，最终放入容器的是代理类的对象，而不是bean本身的对象，那么Spring是什么时候做到这一步的呢？就是在AnnotationAwareAspectJAutoProxyCreator后置处理器的postProcessAfterInitialization方法中，即bean对象初始化完成之后，后置处理器会判断该bean是否注册了切面，若是，则生成代理对象注入到容器中。这一部分的关键代码是在哪儿呢？我们定位到AbstractAutoProxyCreator抽象类中的postProcessAfterInitialization方法处便能看到了，如下所示。

在这里插入图片描述
这里请看：https://liayun.blog.csdn.net/article/details/110442093 这里是源码讲解。我这里直接拿过来结果吧。

在applyBeanPostProcessorsBeforeInitialization()方法中，会遍历所有BeanPostProcessor对象，然后依次执行所有BeanPostProcessor对象的postProcessBeforeInitialization()方法，一旦BeanPostProcessor对象的postProcessBeforeInitialization()方法返回null以后，则后面的BeanPostProcessor对象便不再执行了，而是直接退出for循环。这些都是我们看源码看到的。

看Spring源码，我们还看到了一个细节，在Spring中调用initializeBean()方法之前，还调用了populateBean()方法来为bean的属性赋值，这在上面我也已经说过了。

这里数属性填充工作：那么是怎样工作的那？
就是调用populateBean（）方法

经过上面的一系列的跟踪源码分析，我们可以将关键代码的调用过程使用如下伪代码表述出来。

populateBean(beanName, mbd, instanceWrapper); // 给bean进行属性赋值
initializeBean(beanName, exposedObject, mbd)
{
    applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    invokeInitMethods(beanName, wrappedBean, mbd); // 执行自定义初始化
    applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

也就是说，在Spring中，调用initializeBean()方法之前，调用了populateBean()方法为bean的属性赋值，为bean的属性赋好值之后，再调用initializeBean()方法进行初始化。

在initializeBean()中，调用自定义的初始化方法（即invokeInitMethods()）之前，调用了applyBeanPostProcessorsBeforeInitialization()方法，而在调用自定义的初始化方法之后，又调用了applyBeanPostProcessorsAfterInitialization()方法。至此，整个bean的初始化过程就这样结束了。

概述

如果我们现在自定义的组件中需要用到Spring底层的一些组件，比如ApplicationContext（IOC容器）、底层的BeanFactory等等，那么该怎么办呢？先说说自定义的组件中能不能用Spring底层的一些组件吧？既然都这样说了，那么肯定是能够的。

回到主题，自定义的组件要想使用Spring容器底层的一些组件，比如ApplicationContext（IOC容器）、底层的BeanFactory等等，那么只需要让自定义组件实现XxxAware接口即可。此时，Spring在创建对象的时候，会调用XxxAware接口中定义的方法注入相关的组件。

XxxAware接口概览

其实，我们之前使用过XxxAware接口，例如，我们之前创建的Dog类，就实现了ApplicationContextAware接口，Dog类的源码如下所示。

package com.meimeixia.bean;

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

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * ApplicationContextAwareProcessor这个类的作用是可以帮我们在组件里面注入IOC容器，
 * 怎么注入呢？我们想要IOC容器的话，比如我们这个Dog组件，只需要实现ApplicationContextAware接口就行
 * 
 * @author liayun
 *
 */
@Component
public class Dog implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;

    public Dog() {
        System.out.println("dog constructor...");
    }
    
    // 在对象创建完成并且属性赋值完成之后调用
    @PostConstruct
    public void init() { // 在这儿打个断点调试一下
        System.out.println("dog...@PostConstruct...");
    }
    
    // 在容器销毁（移除）对象之前调用
    @PreDestroy
    public void destory() {
        System.out.println("dog...@PreDestroy...");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { // 在这儿打个断点调试一下
        // TODO Auto-generated method stub
        this.applicationContext = applicationContext;
    }
    
}

从以上Dog类的源码中可以看出，实现ApplicationContextAware接口的话，需要实现setApplicationContext()方法。在IOC容器启动并创建Dog对象时，Spring会调用setApplicationContext()方法，并且会将ApplicationContext对象传入到setApplicationContext()方法中，我们只需要在Dog类中定义一个ApplicationContext类型的成员变量来接收setApplicationContext()方法中的参数，那么便可以在Dog类的其他方法中使用ApplicationContext对象了。

其实，在Spring中，类似于ApplicationContextAware接口的设计有很多，本质上，Spring中形如XxxAware这样的接口都继承了Aware接口，我们来看下Aware接口的源码，如下所示。

在这里插入图片描述

接下来，我们看看都有哪些接口继承了Aware接口，如下所示。

在这里插入图片描述
XxxAware接口案例
接下来，我们就挑选几个常用的XxxAware接口来简单的说明一下。

ApplicationContextAware接口使用的比较多，我们先来说说这个接口，通过ApplicationContextAware接口我们可以获取到IOC容器。

首先，我们创建一个Red类，它得实现ApplicationContextAware接口，并在实现的setApplicationContext()方法中将ApplicationContext输出，如下所示。

package com.meimeixia.bean;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * 以Red类为例来讲解ApplicationContextAware接口、BeanNameAware接口以及EmbeddedValueResolverAware接口
 * @author liayun
 *
 */
public class Red implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("传入的IOC：" + applicationContext);
        this.applicationContext = applicationContext;
    }

}

其实，我们也可以让Red类同时实现几个XxxAware接口，例如，使Red类再实现一个BeanNameAware接口，我们可以通过BeanNameAware接口获取到当前bean在Spring容器中的名称，如下所示。

package com.meimeixia.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * 以Red类为例来讲解ApplicationContextAware接口、BeanNameAware接口以及EmbeddedValueResolverAware接口
 * @author liayun
 *
 */
public class Red implements ApplicationContextAware, BeanNameAware {
    
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("传入的IOC：" + applicationContext);
        this.applicationContext = applicationContext;
    }

    /**
     * 参数name：IOC容器创建当前对象时，为这个对象起的名字
     */
    @Override
    public void setBeanName(String name) {
        System.out.println("当前bean的名字：" + name);
    }

}

当然了，我们可以再让Red类实现一个EmbeddedValueResolverAware接口，我们通过EmbeddedValueResolverAware接口能够获取到String值解析器，如下所示。

package com.meimeixia.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.util.StringValueResolver;

/**
 * 以Red类为例来讲解ApplicationContextAware接口、BeanNameAware接口以及EmbeddedValueResolverAware接口
 * @author liayun
 *
 */
public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {
    
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("传入的IOC：" + applicationContext);
        this.applicationContext = applicationContext;
    }

    /**
     * 参数name：IOC容器创建当前对象时，为这个对象起的名字
     */
    @Override
    public void setBeanName(String name) {
        System.out.println("当前bean的名字：" + name);
    }
    
    /**
     * 参数resolver：IOC容器启动时会自动地将这个String值的解析器传递过来给我们
     */
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        String resolveStringValue = resolver.resolveStringValue("你好，${os.name}，我的年龄是#{20*18}");
        System.out.println("解析的字符串：" + resolveStringValue);
    }

}

IOC容器启动时会自动地将String值的解析器（即StringValueResolver）传递过来给我们用，咱们可以用它来解析一些字符串，解析哪些字符串呢？比如包含#{}这样的字符串。我们可以看一下StringValueResolver类的源码，如下所示。

在这里插入图片描述
接着，我们需要在Red类上标注@Component注解将该类添加到IOC容器中，如下所示。

@Component
public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

最后，运行IOCTest_Autowired类中的test02()方法，输出的结果信息如下所示。

XxxAware原理

XxxAware接口的底层原理是由XxxAwareProcessor实现类实现的，也就是说每一个XxxAware接口都有它自己对应的XxxAwareProcessor实现类。 例如，我们这里以ApplicationContextAware接口为例，ApplicationContextAware接口的底层原理就是由ApplicationContextAwareProcessor类实现的。从ApplicationContextAwareProcessor类的源码可以看出，其实现了BeanPostProcessor接口，本质上是一个后置处理器。

原文链接：bean的生命周期

参考文档：Spring注解驱动开发第23讲

厄尔尼诺的夏天

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
bean的生命周期

如果我们现在自定义的组件中需要用到Spring底层的一些组件，比如ApplicationContext（IOC容器）、底层的BeanFactory等等，那么该怎么办呢？先说说自定义的组件中能不能用Spring底层的一些组件吧？既然都这样说了，那么肯定是能够的。回到主题，自定义的组件要想使用Spring容器底层的一些组件，比如ApplicationContext（IOC容器）、底层的BeanFactory等等，那么只需要让自定义组件实现XxxAware接口即可。
复制链接

扫一扫