Spring的生命周期及Spring Bean单例和多例---超详细教学

一，何为spring生命周期

一个Bean对象从被Spring**容器创建到被销毁的整个过程**。Spring框架对Bean对象的生命周期进行了管理，提供了灵活性和控制权，让开发人员能够在不同的阶段进行自定义操作

1.1生命周期图

1.2.为什么要学习对象的生命周期？

1.2.1 定位和解决问题

 对象的生命周期可以帮助我们**准确定位和解决程序中的问题**。当程序出现 bug 或异常时，了解对象的生命周期可以**帮助我们追踪问题所在**，并在适当的阶段进行调试和修复。

1.2.2 资源管理

对象的生命周期涉及到资源的分配和释放，如内存、数据库连接、文件等。了解对象的生命周期可以帮助我们**更好地管理和优化资源的使用**，避免资源泄漏或过度占用资源的情况发生。

1.2.3 性能优化

了解对象的生命周期可以帮助我们优化程序的性能。通过有效地管理对象的创建和销毁，以及合理利用对象池、缓存等技术，可以减少不必要的资源消耗和提高程序的运行效率。

1.2.4 设计模式和架构

对象的生命周期与设计模式和架构密切相关。学习对象的生命周期可以帮助我们更好地设计和实现面向对象的系统，选择合适的设计模式和架构来管理和组织对象，以实现可维护、可扩展和高效的系统。

1.2.5 对象的状态管理

 对象的生命周期涉及到对象的状态转换和行为变化。了解对象的生命周期可以帮助我们更好地**管理对象的状态**，避免状态混乱或不一致的情况发生，以**确保程序的正确性和可靠性**

1.3 生命周期大致流程

1. Spring启动，查找并加载需要被Spring管理的bean，进行Bean的实例化

2. Bean实例化后将Bean的引入和值注入到Bean的属性中

3. 如果Bean实现了BeanNameAware接口的话，Spring将Bean的id传递给setBeanName()方法
BeanNameAware的作用：让Bean获取自己在BeanFactory配置中的名字。

4. 如果Bean实现了BeanFactoryAware接口的话，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入
BeanFactoryAware的作用：让Bean获取配置他们的BeanFactory的引用。

5. 如果Bean实现了ApplicationContextAware接口的话，Spring将调用Bean的setApplicationContext()方法，将bean所在应用上下文引用传入
为什么使用ApplicationContextAware接口：在spring项目中，类之间的关系是spring容器来管理的，但是一个项目中有些类不受spring容器管理缺需要使用受spring管理的bean，这时候不能通过正常的方式注入bean，这时候spring给我们提供了ApplicationContextAware接口，我们可以编写一个工具类来实现ApplicationContextAware，通过工具类来获取我们需要的bean然后供不在spring容器中的类调用。

6. 如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessBeforeInitialization()方法
postProcessBeforeInitialization()方法：初始化方法之前调用

7. 如果Bean实现了InitializingBean接口，Spring将调用他们的afterPropertiesSet()方法。类似的，如果bean使用init-method声明了初始化方法，该方法也会被调用
afterPropertiesSet()方法：初始化方法。如果使用了init-method声明了初始化方法，则执行顺序为：先执行afterPropertiesSet()方法，再执行init-method声明的方法。

8. 如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessAfterInitialization()方法
postProcessAfterInitialization()方法：初始化方法之后调用

9. 此时，Bean已经准备就绪，可以被应用程序使用了。他们将一直驻留在应用上下文中，直到应用上下文被销毁

10. 如果bean实现了DisposableBean接口，Spring将调用它的destory()接口方法，同样，如果bean使用了destory-method 声明销毁方法，该方法也会被调用
destory()方法：销毁前调用。如果使用了destory-method声明了销毁方法，则执行顺序为：先执行destory()方法，再执行destory-method声明的方法。

二， Spring Bean的单例与多例的作用域

2.1 单例模式（Singleton）：

• 单例是指在整个应用程序上下文中只创建一个实例，并且所有的请求都会返回同一个实例
• 默认情况下，Spring容器中的Bean都是单例的
• 单例模式适用于那些不需要维护状态的Bean，或者对资源消耗较大的Bean进行共享

缺点：使用单例会有变量污染，单例是根据spring上下文初始化；容器生对象生，容器死对象死

2.2 多例模式（Prototype）：

• 多例是指每次请求时都会创建一个新的实例，每个实例都是独立的
• 每次从容器中获取该Bean时，都会创建一个新的实例
• 多例模式适用于那些需要维护状态的Bean，或者对资源消耗较小的Bean进行独立创建

缺点：使用多例及其消耗内存，多例使用时候才会创建，销毁跟着jvm走。

三 单例Bean与多例Bean的配置方式(两种)

3.1 注解方式：

// 使用注解配置单例Bean
@Component
@Scope("singleton")
public class MySingletonBean {
    // ...
}

// 使用注解配置多例Bean
@Component
@Scope("prototype")
public class MyPrototypeBean {
    // ...
}

3.2 XML方式：

<!-- 使用XML配置单例Bean -->
    <bean id="paramAction" class="com.zking.beanlife.ParamAction" scope="singleton">
    <!-- ... -->
</bean>

<!-- 使用XML配置多例Bean -->
  <bean id="paramAction" class="com.zking.beanlife.ParamAction" scope="prototype">
    <!-- ... -->
</bean>

单例案例：

定义一个类，并创建三个方法

package com.zking.beanlife;

public class InstanceFactory {
    public void init() {
        System.out.println("初始化方法");
    }

    public void destroy() {
        System.out.println("销毁方法");
    }

    public void service() {
        System.out.println("业务方法");
    }
}

后端Servlet

package com.zking.beanlife;

import java.util.List;

public class ParamAction {
    private int age;
    private String name;
    private List<String> hobby;
    private int num = 1;
    // private UserBiz userBiz = new UserBizImpl1();

    public ParamAction() {
        super();
    }

    public ParamAction(int age, String name, List<String> hobby) {
        super();
        this.age = age;
        this.name = name;
        this.hobby = hobby;
    }

    public void execute() {
        // userBiz.upload();
        // userBiz = new UserBizImpl2();
        System.out.println("this.num=" + this.num++);
        System.out.println(this.name);
        System.out.println(this.age);
        System.out.println(this.hobby);
    }
}

测试类：

package com.zking.beanlife;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

/*
 * spring    bean的生命週期
 * spring    bean的單例多例
 */
public class Demo2 {
    // 体现单例与多例的区别
    @Test
    public void test1() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
//        InstanceFactory   instanceFactory = (InstanceFactory) applicationContext.getBean("instanceFactory");
        //        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
        ParamAction p1 = (ParamAction) applicationContext.getBean("paramAction");
        ParamAction p2 = (ParamAction) applicationContext.getBean("paramAction");
//         System.out.println(p1==p2);
        p1.execute();
        p2.execute();
        
//        单例时，容器销毁instanceFactory对象也销毁；多例时，容器销毁对象不一定销毁；
        applicationContext.close();
    }

    // 体现单例与多例的初始化的时间点 instanceFactory
    @Test
    public void test2() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
    }

    // BeanFactory会初始化bean对象，但会根据不同的实现子类采取不同的初始化方式
    // 默认情况下bean的初始化，单例模式立马会执行，但是此时XmlBeanFactory作为子类，单例模式下容器创建，bean依赖没有初始化，只有要获取使用bean对象才进行初始化
    @Test
    public void test3() {
        // ClassPathXmlApplicationContext applicationContext = new
        // ClassPathXmlApplicationContext("/spring-context.xml");

        Resource resource = new ClassPathResource("/spring-context.xml");
        BeanFactory beanFactory = new XmlBeanFactory(resource);
//        InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
        
    }

}

spring Config文件的配置

运行结果：

这里的num值分别为1和2，则说明是单例的，单例模式即存在变量污染

多例案例：

运行结果：

** 多例使用时候才会创建，销毁跟着jvm走**