• Spring——bean的生命周期

    文章目录

    前言

    上篇文章分享了AOP，本篇文章分享的内容是Bean的生命周期。
    Spring Bean 的生命周期，小伙伴们应该在面试中经常遇到，因为 Spring Bean 的生命周期是除了 IoC、AOP 几个核心概念之外最重要概念

    一、什么是 Spring Bean 的生命周期

    对于普通的 Java 对象，当 new 的时候创建对象，然后该对象就能够使用了。一旦该对象不再被使用，则由 Java 自动进行垃圾回收。

    而 Spring 中的对象是 bean，bean 和普通的 Java 对象没啥大的区别，只不过 Spring 不再自己去 new 对象了，而是由 IoC 容器去帮助我们实例化对象并且管理它。

    简单来说Spring Bean的生命周期就是bean从被初始化到销毁的过程。

    二、Spring Bean 的生命周期

    这里我们说的 Spring Bean 的生命周期主要指的是 singleton bean，对于 prototype 的 bean ，Spring 在创建好交给使用者之后则不会再管理后续的生命周期。后面我们会展示。

    我们知道对于普通的 Java 对象来说，它们的生命周期就是：

    实例化
    该对象不再被使用时通过垃圾回收机制进行回收

    而对于 Spring Bean 的生命周期来说：

    实例化 Instantiation
    属性赋值 Populate
    初始化 Initialization
    销毁 Destruction

    在这里插入图片描述
    看这张图的顺序是从下面开始的。

    1. 通过XML、Java annotation（注解）或Java Configuration（配置类）等方式加载 Spring bean
    2. BeanDefinitionReader（解析bean定义）。在Spring容器启动的过程中，将bean解析成Spring 内部的BeanDefinition结构。既将spring.xml 中的bean标签转为beanDefinition结构。类似XML的解析。

    在这里插入图片描述
    我们进到BeanDefinition中，可以看到有parentName、scope、BeanClassName等的get、set方法。
    我们再到spring的xml文件中去再看
    在这里插入图片描述
    可以看到BeanDefinition中的属性我们都可以在xml中的bean标签的属性找到。
    BeanDefinition这个实体类就相当于xml中的bean标签。

    1. BeanFactoryPostProcessor是Spring容器功能的扩展接口。

    BeanFactoryPostProcessor在spring容器加载完BeanDefinition之后，在bean实例化之前执行的

    对bean元数据（BeanDefinition）进行加工处理，也就是BeanDefinition 属性填充、修改等操作

    这个BeanFactoryPostProcessor就相当于刚刚的Demo1中的init，在实例化之前对元数据进行属性填充、修改等操作

    1. BeanFactory：bean工厂。它按照我们的要求生产我们需要的各种各样的bean。

    例如：foreach(BeanDefinition bean : List){ //根据class属性反射机制实例化对象 //反射赋值设置属性 }

    1. Aware感知接口：在实际开发中，经常需要用到Spring容器本身的功能资源

    例如：BeanNameAware、ApplicationContextAware等等 BeanDefinition 实现了 BeanNameAware、ApplicationContextAware

    Spring是否有自己的属性？
    肯定是有的。
    我们类比初学时搞环境配置。当时的path除了我们要配置的java环境还有Windows自带的环境变量（我的电脑是win系统的）。在配置的过程中我们使用了path这个内置对象。
    对于Spring容器而言，他也有内置对象，但是需要通过实现*aware接口来调用。

    1. BeanPostProcessor：后置处理器。在Bean对象实例化和引入注入完毕后，在显示调用初始化方法的前后添加自定义的逻辑。（类似于AOP的绕环通知）

    前提条件：如果检测到Bean对象实现了BeanPostProcessor后置处理器才会执行 Before和After方法 BeanPostProcessor 1）Before
    2）调用初始化Bean（InitializingBean和init-method，Bean的初始化才算完成） 3）After
    完成了Bean的创建工作

    案例

    package com.zhw.beanLife;

/**
 1. @author louis
 2. @create 2022-08-2022/8/9  0:42
 */
public class Demo1 {
    public static void main(String[] args) {
        Person p = new Person();
        p.setSex("不说");
        System.out.println(p);
    }
}
class Person{
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }

    public Person(){
   		this.init();
        this.name = "zs";
        this.age = 20;
        this.sex = "你猜";
    }
    public static void init(){
	
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    在这里插入图片描述

    三、单例模式、原型模式

    原型模式：

    package com.zhw.beanLife;

/**
 * @author louis
 * @create 2022-08-2022/8/9  1:12
 */
public class Demo2 {
    public static void main(String[] args) {
        Persons p1=new Persons();
        Persons p2=new Persons();
        Persons p3=new Persons();
        Persons p4=new Persons();
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
        System.out.println(p4);
    }
}
class Persons{
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    /*@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }*/

    public Persons(){
        this.init();
        this.name = "zs";
        this.age = 20;
        this.sex = "你猜";
    }
    public static void init(){

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    在这里插入图片描述
    在同一个类中使用同一个类四次，要实例化四次。如果类很多，或者次数很多呢？
    那么要实例化的次数有点多了。既然我们都能想到，那么spring的开发者肯定也能想到，所以单例模式就出来了。
    而且为了节省空间，默认是使用单例模式。既然单例模式存在，原型模式也存在，那么肯定是单例模式是存在弊端的。
    当两个对象使用同一个实现类，会造成变量污染
    这就像是你家有对双胞胎，买玩具的时候两个人 的玩具不一样，哥哥玩过的给弟弟，弟弟说不定会嫌弃呢。
    同一样东西买两件，相当于原型模式。而买两件不一样的玩具就相当于单例模式。

    浅浅的来论证一下

    /*
 * spring	bean的生命週期
 * spring	bean的單例多例
 */
public class Demo3 {
	// 体现单例与多例的区别
	@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");
		
	}

}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    InstanceFactory

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

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

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    ParamAction：

    /**
 * 印证单利和多例的区别
 * @author Administrator
 *
 */
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);
	}
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    单例模式效果图
    在这里插入图片描述
    原型模式效果图：
    在这里插入图片描述

    总结

    单例模式下：javaBean的生命周期：容器生，对象生，容器没，对象没
    多例模式下JavaBean的生命周期，使用时对象生，死亡跟着jvm垃圾回收机制走
    bean的初始化时间点，除了跟bean管理模式（单例/多例）有关，还跟beanFactory的子类有关
    以上就是今天要讲的内容，本文仅仅简单介绍了我对于bean的生命周期的理解。
    如有错误还望指正，谢谢啦。

  • 相关阅读:
    docker引擎学习
    文本分类从入门到精通——各种库的基本解读与使用（一）
    一套完整的软件测试面试流程（面试题），这些题你真的都能答上吗？
    力扣-412.Fizz Buzz
    数学才是顶级码农的核心修养，码农怎样搞好数学？来看看这些网友强推的数学神作！文末评论区进行评论参与送书哟
    （转）c 多张图片生成avi视频
    Kotlin（七）标准库函数
    设计模式学习笔记 - 设计模式七大原则
    C# WebSocket 服务器
    安全基础 --- 过滤情况下实现弹窗展现
  • 原文地址：https://blog.csdn.net/qq_62331938/article/details/126234969