🥳🥳Welcome Huihui's Code World ! !🥳🥳

接下来看看由辉辉所写的关于Spring的相关操作吧

目录

🥳🥳Welcome Huihui's Code World ! !🥳🥳

一.Spring Bean是单例模式还是多例模式

 二.论证Bean是单例模式

代码论证单例模式的结果

简单JavaBean

spring-context.xml-toc" style="margin-left:80px;">spring-context.xml

测试类

结果

多例模式的对比结果

spring-context.xml-toc" style="margin-left:80px;">spring-context.xml

结果

三.使用单例模式的好处 

四. Spring Bean完整的生命周期 附流程图详细讲解

---

通过上两篇的讲解，相信大家已经对Spring十分了解了！！总的来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架，我们只需要记住这一句话，便可以再脑海中会议起关于IOC和AOP的各个知识点啦！！在讲解Bean的生命周期之前，不妨先来讨论一个至关重要的问题：Bean到底是单例模式还是多例模式？

一.Spring Bean是单例模式还是多例模式

• Bean 是一个 Java 框架，用于简化 Spring 应用程序中的 Bean 生命周期管理。
• 在 Bean 中，Bean 实例被设计为单例模式，即在整个应用程序中，只有一个 Bean 实例被创建和共享。这种设计可以确保在应用程序中只有一个 Bean 实例被创建，从而避免了多实例之间的竞争和冲突。
• 单例模式的设计可以带来很多好处
  • 1. 避免创建多个实例，从而减少了内存占用和资源消耗
  • 2. 确保在整个应用程序中只有一个 Bean 实例被创建，从而避免了多实例之间的竞争和冲突
  • 3. 可以方便地控制 Bean 的生命周期，例如在应用程序启动时创建 Bean 实例，在应用程序关闭时销毁 Bean 实例

通过上文的讲述，我们已经知道了Bean是单例模式，可是我们怎么去论证它说的是正确的呢？

 二.论证Bean是单例模式

• 单例模式和区别
  • 单例模式是一种常用的设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。单例模式可以避免创建多个对象，提高代码的可维护性和可读性。在单例模式中，只有一个类被实例化，其他任何尝试实例化的代码都会返回同一个对象。
  • 多例模式则是一种不推荐的设计模式，它允许创建多个对象，这会导致代码的可维护性和可读性降低。在多例模式中，可以有多个类被实例化，并且这些实例之间没有任何关联。这种设计模式通常被滥用，会导致代码的可维护性变差

上面说了这么多，其实无非就是一句话：单例模式中确保一个类只有一个实例，而多例模式允许创建多个对象 如此而来，我们想要论证Bean究竟是不是单例模式就很好论证了，只需要证明在Bean中一个类只有一个实例就可以了，那么话不多说，我们直接上代码！！

代码论证单例模式的结果

简单JavaBean

java">package com.wh.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);
	}
}

spring-context.xml" style="background-color:transparent;">spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="paramAction" class="com.wh.beanlife.ParamAction">
        <constructor-arg name="name" value="昆昆"></constructor-arg>
        <constructor-arg name="age" value="25"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>RAP</value>
            </list>
        </constructor-arg>
    </bean>

    <bean id="instanceFactory" class="com.wh.beanlife.InstanceFactory"
          init-method="init" destroy-method="destroy"></bean>

</beans>

测试类

java">package com.wh.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");
//		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-context.xml就能够看出区别了，在其中添加scope="prototype"就ok了

spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="paramAction" class="com.wh.beanlife.ParamAction" scope="prototype">
        <constructor-arg name="name" value="昆昆"></constructor-arg>
        <constructor-arg name="age" value="25"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>RAP</value>
            </list>
        </constructor-arg>
    </bean>

    <bean id="instanceFactory" class="com.wh.beanlife.InstanceFactory"
          init-method="init" destroy-method="destroy"></bean>

</beans>

结果

三.使用单例模式的好处 

1. 避免全局变量：全局变量可能导致命名冲突和不可预测的行为。使用单例模式可以避免全局变量，使得代码更加可维护和可测试
2. 资源共享：如果多个类都使用了相同的资源，如数据库连接、日志记录等，使用单例模式可以避免创建多个实例，从而减少资源消耗
3. 线程安全：单例模式保证了多线程环境下的线程安全，避免了多个实例同时访问共享资源的情况
4. 方便管理：单例模式使得多个类可以共享一个实例，从而方便了管理和维护。例如，多个类都可以使用同一个日志记录器或配置管理器，从而减少了代码的耦合性

不妨讲个小例子，让大家更加明白使用单例模式的好处！

话说有一个家庭生了一对双胞胎崽崽，两个小男孩渐渐长大，他们一家一起去逛商场，两个小男孩都说很喜欢一款玩具小汽车，妈妈这时候犯难了，两个小孩都喜欢，可是他们一向都是三分钟热度，妈妈就觉得没必要买两个一样的玩具小汽车，就只买了一台。两个兄弟商量一人上午玩，一人下午玩。这样商量好之后，他们都觉得很不错。可到了真正玩了这个小汽车之后，下午玩这个小汽车的崽崽不开心了，就跑去跟妈妈说，“妈妈，我不想要下午玩这个小汽车，因为哥哥总是把小汽车搞得脏兮兮的😭😭”妈妈没办法，只好又买了一个小汽车给小崽崽，这样之后，两个崽崽都非常的满意的玩起了各自的小汽车！！

在上文的这个故事中，只买一个小汽车就对应着单例模式：确保一个类只有一个实例

而买了两个小汽车则对应着多例模式：允许创建多个对象

如此而来就能够理解它们两者的区别了吧，单例模式容易污染对象，就像文中大崽崽使用玩具车的时候将玩具车弄脏了，以至于小崽崽没有好的体验，但是单例模式可以节约内存，就想只买一个小汽车可以节约钱一样；多例模式不容易污染对象，文中买了两个小汽车就是这样的，两个崽崽都有各自的小汽车，不会出现各自都有不好的体验，但多例模式会比较占用内存，就像买两个小汽车需要多花钱一样

四. Spring Bean完整的生命周期 附流程图详细讲解

 

启动spring,就是创建beanFactory(bean工厂), 一般用的是beanFactory的子类applicationcontext, applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。  通过applicationcontext加载配置文件,或者利用注解的方式扫描将bean 的配置信息加载到spring容器里面

将加载的配置信息封装成BeanDefinition对象：加载之后,spring容器会将这些配置信息(java bean的信息),封装成BeanDefinition对象，BeanDefinition对象其实就是普通java对象之上再封装一层, 赋予一些spring框架需要用到的属性,比如是否单例,是否懒加载等等

BeanFactory：然后将这些BeanDefinition对象以key为beanName,值为BeanDefinition对象的形式存入到一个map里面,将这个map传入到spring beanfactory去进行springBean的实例化

BeanFactoryPostProcessor：传入到pring beanfactory之后,利用BeanFactoryPostProcessor接口这个扩展点去对BeanDefinition对象进行一些属性修改

Bean实例化：开始循环BeanDefinition对象进行springBean的实例化,springBean的实例化也就是执行bean的构造方法(单例的Bean放入单例池中,但是此刻还未初始化),在执行实例化的前后,可以通过InstantiationAwareBeanPostProcessor扩展点 (作用于所有bean)进行一些修改

Bean属性注入：spring bean实例化之后,就开始注入属性,首先注入自定义的属性,比如标注@autowrite的这些属性,再调用各种Aware接口扩展方法,注入属性(spring特有的属性),比如BeanNameAware.setBeanName,设置Bean的ID或者Name

初始化bean,对各项属性赋初始化值：初始化前后执行BeanPostProcessor(作用于所有bean)扩展点方法,对bean进行修改

      初始化前后除了BeanPostProcessor扩展点还有其他的扩展点,执行顺序如下:

        (1). 初始化前                       postProcessBeforeInitialization()
        (2). 执行构造方法之后                执行 @PostConstruct 的方法
        (3). 所有属性赋初始化值之后           afterPropertiesSet()
        (4). 初始化时                         配置文件中指定的 init-method 方法
        (5). 初始化后                       postProcessAfterInitialization()

        先执行BeanPostProcessor扩展点的前置方法postProcessBeforeInitialization(),
        再执行bean本身的构造方法
        再执行@PostConstruct标注的方法
        所有属性赋值完成之后执行afterPropertiesSet()
        然后执行 配置文件或注解中指定的 init-method 方法
        最后执行BeanPostProcessor扩展点的后置方法postProcessAfterInitialization()

Bean初始化完成：此时已完成bean的初始化,在程序中就可以通过spring容器拿到这些初始化好的bean

Bean随之而销毁： 随着容器销毁,springbean也会销毁,销毁前后也有一系列的扩展点。销毁bean之前,执行@PreDestroy 的方法销毁时,执行配置文件或注解中指定的 destroy-method 方法

结束： 以上就是spring bean的整个生命周期，下面再来个总结！！

          ①根据配置文件或注解信息,生成BeanDefinition,
          ②循环BeanDefinition去实例化

          ③注入属性

          ④初始化

          ⑤销毁,

          在这②③④⑤这几个阶段执行前后,spring框架提供了一系列的扩展点

关于Spring Bean声明周期的讲解，借鉴http://t.csdn.cn/TifUQ了，大家也可以去看看这位大佬写的博文，超赞！

最后再附上一张图（结合上面的文字解释观看会更加爽！！）

好啦，今天的分享就到这了，希望能够帮到你呢！😊😊