Spring《二》bean的实例化与生命周期

Posted 2023-03-29 Super algorithm

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring《二》bean的实例化与生命周期相关的知识，希望对你有一定的参考价值。

🍎道阻且长，行则将至。🍓

一、bean实例化🍍

在上一篇Spring快速入门👉🏻中，我们使用IOC容器进行对象的创建，在IOC中的对象也称为bean，那么IOC容器是怎么创建bean的呢。

下面介绍bean的实例化方法：构造方法、静态工厂、实例工厂。

1.构造方法 ***

我们先创建好一个maven项目，在maven配置文件pom中添加spring的依赖，再继续在resources文件夹下new个Spring的配置文件，applicationContext.xml。
准备好我们的接口和类：BookDao和BookDaoImpl：在接口添加一个save方法，到类中实现，输出一个语句示例。因为要使用构造方法，那我们就写一个无参构造器，并且在里面随便输出一个提示语句。
写好类之后，我们继续到Spring配置文件中将类配置到容器：<bean id="bookDao" name="book1" class="Demo1.dao.impl.BookDaoImpl"/>，我们可以发现在左侧出现spring的小标志了，表示配置正常；
完成一个运行的程序，若最后可以打印构造器中的内容表示就是创建对象使用了构造函数。

public class AppForInstanceBook 
    public static void main(String[] args) 
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();

输出：

并且当构造器为私有的时候，仍然可以访问，说明了Spring的底层使用了反射。回顾参考👉🏻java反射机制
但是Spring只是使用无参构造器。

2.静态工厂 *

使用工厂创建对象

我们可以继续在前面的maven中类似地添加接口和类：OrderDao和OrderDaoImpl，然后在创建一个工厂类：

public class OrderDaoFactory 
    public static OrderDao getOrderDao()
        return new OrderDaoImpl();

完成一个运行的程序,使用工厂获取对象：

public class AppForInstanceOrder 
    public static void main(String[] args) 
        //通过静态工厂创建对象
        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();

实例化bean

要使用静态工厂实例化bean只需要在Spring配置文件中添加<bean id="orderDao" name="Order1" class="Demo1.factory.OrderDaoFactory" factory-method="getOrderDao"/>，注意class是指向工厂类，添加的工厂方法属性指向工厂中创建对象的方法；静态工厂实例化配置成功之后再工厂类中也会有提示：
👉
然后在运行方法中从容器获取bean：

ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
OrderDao orderDao =(OrderDao) ctx.getBean("orderDao");
orderDao.save();

3.实例工厂 ***

使用示例工厂创建对象

我们还是可以继续在前面的maven中类似地添加接口和类：UserDao和UserDaoImpl，再同样的创建一个工厂类：OrderDaoFactory，注意和静态工厂的不一样：

//UserDao
package Demo1.dao;
public interface UserDao 
    public void save();

//UserDaoImpl
package Demo1.dao.impl;
import Demo1.dao.UserDao;
public class UserDaoImpl implements UserDao 
    @Override
    public void save() 
        System.out.println("userDao save...");
    

//OrderDaoFactory
package Demo1.factory;
import Demo1.dao.UserDao;
import Demo1.dao.impl.UserDaoImpl;
public class UserDaoFactory 
    public UserDao getUserDao()
        return new UserDaoImpl();

我们可以在运行程序中使用实例工厂获取对象：

public class AppForInstanceUser 
    public static void main(String[] args) 
        //创建实例工厂对象
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //通过实例工厂对象创建对象
        UserDao userDao = userDaoFactory.getUserDao();
        userDao.save();

我们想把这种实例工厂也交给Spring：

实例工厂实例化bean

在配置文件中添加：

<bean id="userFactory" class="Demo1.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

在前面的静态工厂中我们只需要配置工厂类进来，使用静态方法就可以获得对象。而这需要先添加工厂，再添加Dao。
我们也可以修改验证一下为什么要这样，当你试图在工厂bean中加实例方法，直接给你报错：

其实想一想就知道了，这个不是静态方法啊，对象都没有你怎么使用这个方法。
然后在运行程序中添加：

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) ctx.getBean("userDao");
userDao.save();

上面的Spring配置还是太麻烦，改！

FactoryBean

Spring为了简化这种配置方式就提供了FactoryBean来简化开发。

创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法：

public class UserDaoFactoryBean implements FactoryBean<UserDao> 
    @Override
    public UserDao getObject() throws Exception 
        return new UserDaoImpl();
    

    @Override
    public Class<?> getObjectType() 
        return UserDao.class;

就只需要一个FactoryBean的配置：
<bean id="userDao" class="Demo1.factory.UserDaoFactoryBean"/>。

FactoryBean的源代码也不长，我们可以打开看看：

public interface FactoryBean<T> 
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() 
        return true;

他提供了3个方法，我们在创建UserDaoFactoryBean的类的时候重写了两个接口的方法：
getObject()，在方法中进行对象的创建并返回；
getObjectType()，返回的是被创建类的Class对象；
isSingleton()就是设置对象是否为单例，默认true。

二、生命周期🍑

生命周期就是从创建到消亡的完整过程。bean的生命周期自然是指bean对象从创建到销毁的过程。

1.生命周期设置

我们想设置：

bean创建之后，想要添加内容，比如用来初始化需要用到资源
bean销毁之前，想要添加内容，比如用来释放用到的资源
继续在前面的案例中，我们在实例工厂类添加：

public void init()
    System.out.println("init userDaofac...");

public void destory()
    System.out.println("destory userDaofac...");

在bean中追加：init-method="init" destroy-method="destory"。

只有初始化被执行了。问：为什么？
Spring的IOC容器是运行在JVM中，运行main方法后，JVM启动，Spring加载配置文件生成IOC容器，从容器获取bean对象，然后调方法执行。然而main方法执行完后，JVM就退出了，这个时候IOC容器中的bean也就结束了，根本没有调用destroy方法。
所以这个时候我们可以在main方法使用close或使用钩子关闭容器。

2.在main方法使用close

ApplicationContext 中没有提供close方法，我们需要使用ClassPathXmlApplicationContext ：
修改

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
⇨ 
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

就可以使用：ctx.close();了。

3.使用钩子关闭容器

就是在容器未关闭之前，提前设置好回调函数，让JVM可以在退出之前回调此函数来关闭容器。
就是把前面的ctx.close();换为ctx.registerShutdownHook();。

需要修改配置文件还是太麻烦，再改！

前面的方法还是需要在Spring配置文件中添加bean的init-method和destroy-method，Spring对此进行简化，提供了两个接口来完成生命周期的控制，而不用再进行配置：InitializingBean和DisposableBean。
在类里面继承接口并重写：

public class UserDaoFactoryBean implements FactoryBean<UserDao> , InitializingBean, DisposableBean 
    @Override
    public UserDao getObject() throws Exception 
        return new UserDaoImpl();
    
    @Override
    public Class<?> getObjectType() 
        return UserDao.class;
    
//************************
    @Override
    public void destroy() throws Exception 
        System.out.println("destory...");
    
    @Override
    public void afterPropertiesSet() throws Exception 
        System.out.println("ini...");

在运行程序仍然使用ctx.registerShutdownHook();。

回到第一页☝

☕物有本末，事有终始，知所先后。🍭

🍎☝☝☝☝☝我的CSDN☝☝☝☝☝☝🍓

Spring Bean的生命周期

一、引言

　　要想理解Spring框架，那么Spring Bean的生命周期就是必须要了解的一环，关于Spring Bean的生命周期，就是一个Bean在IOC容器中从创建到销毁的过程，下面就开始梳理一下一个Bean的创建过程。

二、生命周期概要流程

　　简单的来说，一个Bean的生命周期分为四个阶段：

　　1、实例化（Instantiation）

　　2、属性设置（populate）

　　3、初始化（Initialization）

　　4、销毁（Destruction）

如下图：

　　具体逻辑位于AbstractAutowireCapableBeanFactory类doCreateBean方法中，代码较多，只放出了重要的部分，如下：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;

        if (instanceWrapper == null) {
            //实例化
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        try {
            //属性赋值
            this.populateBean(beanName, mbd, instanceWrapper);
            //初始化
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            //...
        }

        try {
            //注册销毁回调接口
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            //...
        }
    }

　　上面是的步实例化、属性赋值、初始化都是Spring容器启动时的步骤，销毁是在容器关闭时的操作，容器销毁时会调用容器的close()方法去销毁容器。

三、对生命周期的扩展

　　Spring在创建Bean的时候不仅仅只创建了一个我们设置的Bean，还可以在创建Bean的时候对它进行很多的扩展，总的来说有以下几类：

　　1、BeanPostProcessor接口

　　2、InstantiationAwareBeanPostProcessor接口

　　3、Aware类型的接口

　　4、生命周期类型接口

　　其中1和2是作用于所有Bean的接口，3和4是作用于单个Bean的接口。BeanPostProcessor是初始化时的后置处理器，InstantiationAwareBeanPostProcessor是实例化时的后置处理器，Aware类型的接口如BeanNameAware、BeanFactoryAware等需要Bean自己去实现，生命周期类型接口如InitializingBean、DisposableBean。

　　加上这些扩展，现在上面的图可以变成下面这样了：

　　接下来看详细的源码，刚刚我们提到的实例化、属性赋值、初始化这三个步骤都在doCreateBean方法中，那么在这个方法之前有什么操作吗：

    //createBean方法里面调用了doCreateBean
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        Object beanInstance;
        try {
            //这个里面调用了InstantiationAwareBeanPostProcessor的前置方法postProcessBeforeIns
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        } catch (Throwable var10) {
            //...
        }
        //...
        try {
            //这里调用了doCreateBean
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            //...
        } catch (Throwable var8) {
            //...
        }
    }

    //resolveBeforeInstantiation方法里面调用了这个方法
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        Iterator var3 = this.getBeanPostProcessors().iterator();

        while(var3.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var3.next();
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                //调用了InstantiationAwareBeanPostProcessor的前置方法postProcessBeforeInstantiation
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }

        return null;
    }

　　在调用完InstantiationAwareBeanPostProcessor的前置方法之后接下来进入doCreateBean方法，首先会执行createBeanInstance(beanName, mbd, args)进行实例化，然后进入populateBean(beanName, mbd, instanceWrapper)方法进行属性赋值，看一下这一部分代码还有没有别的操作：

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            //...
        } else {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator var4 = this.getBeanPostProcessors().iterator();

                while(var4.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var4.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        
                        //执行InstantiationAwareBeanPostProcessor的后置方法postProcessAfterInstantiation
                        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            return;
                        }
                    }
                }
            }
            if (hasInstAwareBpps) {
                Iterator var9 = this.getBeanPostProcessors().iterator();
                while(var9.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        
                        //执行执行InstantiationAwareBeanPostProcessor的postProcessProperties
                        PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            
                            ////执行执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues(该方法已废弃，不建议使用)
                            pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        }
                    }
                }
            }

        }
    }

　　通过源码可以看出InstantiationAwareBeanPostProcessor的几个方法分别在实例化的前后完成，然后进行属性赋值，接下来就是实例化initializeBean(beanName, exposedObject, mbd)，我们来看一下：

    //该方法位于AbstractAutowireCapableBeanFactory类中，这段代码很简单，不像其他部分还添加了很多其他操作，这块一看就明白了，就不把BeanPostProcessor、InitializingBean等具体的方法列出来了
    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                //invokeAwareMethods方法执行实现的Aware接口
                this.invokeAwareMethods(beanName, bean);
                return null;
            }, this.getAccessControlContext());
        } else {
            //和上面的一样，执行实现的Aware类型的接口
            this.invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //这个方法里面执行了BeanPostProcessor的postProcessBeforeInitialization方法
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

        try {
            //执行了InitializingBean的afterPropertiesSet方法和自定义的init-method方法
            this.invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
        }

        if (mbd == null || !mbd.isSynthetic()) {
            //这个方法里面执行了BeanPostProcessor的postProcessAfterInitialization方法
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

　　关于Aware类型的接口这里要说一下，可能你会奇怪按照我上面的那个类去找invokeAwareMethods(beanName, bean)方法会是下面这种情况：

    private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

　　为什么只有这三个Aware类型的接口，明明还有其他好几种啊，比如EnvironmentAware、EmbeddedValueResolverAware等，这是什么它们的容器不同，AbstractAutowireCapableBeanFactory使用的容器是BeanFactory，其他几种是ApplicationContext 添加的扩展接口，如：

    //ApplicationContextAwareProcessor中实现的接口如下
    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
        }

        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }

        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
        }

        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
        }

        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
        }

        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
        }

    }

　　到这一步初始化也完成了，至于销毁时在容器关闭时执行容器的close方法，close方法中会执行destroy方法销毁所有的Bean：

    //销毁Bean的方法
    public void destroy() {
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            Iterator var1 = this.beanPostProcessors.iterator();

            while(var1.hasNext()) {
                //其实这里也有个销毁时的处理器，实现了BeanPostProcessor,在执行销毁方法前执行postProcessBeforeDestruction方法
                DestructionAwareBeanPostProcessor processor = (DestructionAwareBeanPostProcessor)var1.next();
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }

        if (this.invokeDisposableBean) {

            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(() -> {
                        //执行DisposableBean的destroy方法
                        ((DisposableBean)this.bean).destroy();
                        return null;
                    }, this.acc);
                } else {
                    //同上，执行DisposableBean的destroy方法
                    ((DisposableBean)this.bean).destroy();
                }
            } catch (Throwable var3) {
                //...
            }
        }

        if (this.destroyMethod != null) {
            //如果存在指定的销毁方法就执行，即destroy-method指定的方法
            this.invokeCustomDestroyMethod(this.destroyMethod);
        } else if (this.destroyMethodName != null) {
            //...
        }

    }

　　到这里我们已经看完了一个Bean从实例化到销毁的所有步骤。

四、总结

　　总的来说Spring Bean的生命周期就是四大步骤，实例化 -> 属性赋值 ->初始化 ->销毁，其他的操作都是对这四个步骤的扩展。

以上是关于Spring《二》bean的实例化与生命周期的主要内容，如果未能解决你的问题，请参考以下文章

Spring Bean的生命周期

Java面试小短文Spring Bean生命周期的执行流程

spring bean的生命周期是怎样的，代码示例

Spring《二》bean的实例化与生命周期

目录

一、bean实例化🍍

1.构造方法 ***

2.静态工厂 *

使用工厂创建对象

实例化bean

3.实例工厂 ***

使用示例工厂创建对象

实例工厂实例化bean

FactoryBean

二、生命周期🍑

1.生命周期设置

2.在main方法使用close

3.使用钩子关闭容器

Spring Bean的生命周期

一、引言

二、生命周期概要流程

三、对生命周期的扩展

四、总结