• Spring之bean的生命周期

    目录

    一、Bean的初始化过程

     Spring Bean的生命周期

    二、单例模式与多例模式

    单例模式优点

    单例模式弊端

    单例模式与多例模式的区别

    一、Bean的初始化过程

    Spring Bean的生命周期：

    1、通过三种方式（配置文件、注解、配类） 将bean标签转为BeanDefinitionReader对象

    2、通过BeanFactoryPostProcessor可以在初始化之前修改属性值

    3、BeanFactory进行bean实例化，说白了就是生产javabean

    4、Aware感知接口，能够在拿到Spring上下文中内部的资源对象

    5、BeanPostProcessor后置处理器，相当于环绕通知

    二、单例模式与多例模式

    单例模式优点：

            假设一个类被使用了100次，而这个项目共有1w个类，那么Spring上下文要创建100w个对象，而单例模式可以让Spring上下文创建的对象只有1w个，因此单例模式可以节省空间

     单例模式弊端：

    会污染变量

    那为什么Spring框架的作者要提供原型/多例模式Javabean管理模式进行选择?

    单例模式与多例模式的区别：

    spring-context.xml

    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 	xmlns:aop="http://www.springframework.org/schema/aop"
    5. 	xmlns:context="http://www.springframework.org/schema/context"
    6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    7. 		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    8. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    9.  
    10.  
    11. 	<bean class="com.zsx.biz.impl.UserBizImpl" id="userbiz" scope="singleton">bean>
    12. 	
    13. 	<bean class="com.zsx.web.UserAction" id="userAction">
    14. 		 <property name="userbiz" ref="userbiz">property>
    15. 		<property name="name" value="zsx">property>
    16. 		<property name="age" value="18">property>
    17. 		<property name="hobby">
    18. 			<list>
    19. 				<value>唱value>
    20. 				<value>跳value>
    21. 				<value>原神value>
    22. 			list>
    23. 		property>
    24. 	bean>
    25. 	<bean class="com.zsx.web.OrderAction" id="orderAction">
    26. 		<property name="userbiz" ref="userbiz">property>
    27. 		<constructor-arg name="name" value="zsx">constructor-arg>
    28. 		<constructor-arg name="age" value="18">constructor-arg>
    29. 		<constructor-arg name="hobby">
    30. 			<list>
    31. 				<value>唱value>
    32. 				<value>跳value>
    33. 				<value>原神value>
    34. 			list>
    35. 		constructor-arg>
    36. 	bean>
    37. 	
    38. 	
    39. 	
    40. 	
    41. 	<bean class="com.zsx.aop.biz.impl.BookBizImpl" id="bookBiz">bean>
    42. 	
    43. 	<bean class="com.zsx.aop.advice.MyAdvice" id="myBefore">bean>
    44. 	
    45. 	<bean class="com.zsx.aop.advice.MyAfterAdvice" id="myAfter">bean>
    46. 	
    47. 	<bean class="com.zsx.aop.advice.MyInterAdvice" id="myInter">bean> 
    48. 	
    49. 	<bean class="com.zsx.aop.advice.MyThrowsAdvice" id="myThorw">bean>
    50. 	
    51. 	<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myAfter2">
    52. 		<property name="advice" ref="myAfter">property>
    53. 		<property name="pattern" value=".*buy">property>	
    54. 	bean>
    55. 	
    56. 	
    57. 	<bean class="org.springframework.aop.framework.ProxyFactoryBean"  id="bookProxy">
    58. 		
    59. 		<property name="target" ref="bookBiz">property>
    60. 		
    61. 		<property name="proxyInterfaces">
    62. 			<list>
    63. 				<value>com.zsx.aop.biz.BookBizvalue>
    64. 			list>
    65. 		property>
    66. 		
    67. 		<property name="interceptorNames">
    68. 			<list>
    69. 				<value>myBeforevalue>
    70. 				 
    71. 				<value>myIntervalue> 
    72. 			 	<value>myThorwvalue> 
    73. 			 	<value>myAfter2value>
    74. 			list>
    75. 		property>
    76. 	bean>
    77. 	
    78. 	
    79. 	<bean id="paramAction" class="com.zsx.beanLife.ParamAction">
    80. 		<constructor-arg name="name" value="三丰">constructor-arg>
    81. 		<constructor-arg name="age" value="21">constructor-arg>
    82. 		<constructor-arg name="hobby">
    83. 			<list>
    84. 				<value>抽烟value>
    85. 				<value>烫头value>
    86. 				<value>大保健value>
    87. 			list>
    88. 		constructor-arg>
    89. 	bean>
    90.  
    91. 	<bean id="instanceFactory" class="com.zsx.beanLife.InstanceFactory"
    92. 		scope="singleton" init-method="init" destroy-method="destroy">bean>
    93. 	
    94. 	
    95. 	
    96. 	
    97. beans>

    InstanceFactory

    1. package com.zsx.beanLife;
    2.  
    3. /**
    4.  * 为了印证BeanPostProcessor 初始化javabean
    5.  * @author Administrator
    6.  *
    7.  */
    8. public class InstanceFactory {
    9. 	public void init() {
    10. 		System.out.println("初始化方法");
    11. 	}
    12.  
    13. 	public void destroy() {
    14. 		System.out.println("销毁方法");
    15. 	}
    16.  
    17. 	public void service() {
    18. 		System.out.println("业务方法");
    19. 	}
    20. }

     

    ParamAction

    1. package com.zsx.beanLife;
    2.  
    3. import java.util.List;
    4.  
    5.  
    6. /**
    7.  * 印证单例、多例的区别
    8.  * @author Administrator
    9.  *
    10.  */
    11. public class ParamAction {
    12. 	private int age;
    13. 	private String name;
    14. 	private List hobby;
    15. 	private int num = 1;
    16. 	// private UserBiz userBiz = new UserBizImpl1();
    17.  
    18. 	public ParamAction() {
    19. 		super();
    20. 	}
    21.  
    22. 	public ParamAction(int age, String name, List hobby) {
    23. 		super();
    24. 		this.age = age;
    25. 		this.name = name;
    26. 		this.hobby = hobby;
    27. 	}
    28.  
    29. 	public void execute() {
    30. 		// userBiz.upload();
    31. 		// userBiz = new UserBizImpl2();
    32. 		System.out.println("this.num=" + this.num++);
    33. 		System.out.println(this.name);
    34. 		System.out.println(this.age);
    35. 		System.out.println(this.hobby);
    36. 	}
    37. }

    Demo2

    1. package com.zsx.beanLife;
    2.  
    3. import org.junit.Test;
    4. import org.springframework.beans.factory.BeanFactory;
    5. import org.springframework.beans.factory.xml.XmlBeanFactory;
    6. import org.springframework.context.ApplicationContext;
    7. import org.springframework.context.support.ClassPathXmlApplicationContext;
    8. import org.springframework.core.io.ClassPathResource;
    9. import org.springframework.core.io.Resource;
    10.  
    11. /*
    12.  * spring	bean的生命週期
    13.  * spring	bean的單例多例
    14.  */
    15. public class Demo2 {
    16. 	// 体现单例与多例的区别
    17. 	@Test
    18. 	public void test1() {
    19. 		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
    20. //		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
    21. 		//ParamAction p1 = (ParamAction) applicationContext.getBean("paramAction");
    22. 		//ParamAction p2 = (ParamAction) applicationContext.getBean("paramAction");
    23. 		
    24. 		InstanceFactory p1 = (InstanceFactory) applicationContext.getBean("instanceFactory");
    25. 		InstanceFactory p2 = (InstanceFactory) applicationContext.getBean("instanceFactory");
    26. 		// System.out.println(p1==p2);
    27. //		p1.execute();
    28. //		p2.execute();
    29. 		
    30. //		单例时，容器销毁instanceFactory对象也销毁；多例时，容器销毁对象不一定销毁；
    31. 		applicationContext.close();
    32. 	}
    33.  
    34. 	// 体现单例与多例的初始化的时间点 instanceFactory
    35. 	@Test
    36. 	public void test2() {
    37. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
    38. 	}
    39.  
    40. 	// BeanFactory会初始化bean对象，但会根据不同的实现子类采取不同的初始化方式
    41. 	// 默认情况下bean的初始化，单例模式立马会执行，但是此时XmlBeanFactory作为子类，单例模式下容器创建，bean依赖没有初始化，只有要获取使用bean对象才进行初始化
    42. 	@Test
    43. 	public void test3() {
    44. 		// ClassPathXmlApplicationContext applicationContext = new
    45. 		// ClassPathXmlApplicationContext("/spring-context.xml");
    46.  
    47. 		Resource resource = new ClassPathResource("/spring-context.xml");
    48. 		BeanFactory beanFactory = new XmlBeanFactory(resource);
    49. 		//InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
    50. 		
    51. 	}
    52.  
    53. }

     Debug运行Demo2中的text1（这是单例模式下的）

      Debug运行Demo2中的text3  这是多例模式下的） 没启用最后一行代码，初始化都不会出来

     放出Demo2中的text3中的最后一行代码  然后再运行

    1. @Test
    2. 	public void test3() {
    3. 		// ClassPathXmlApplicationContext applicationContext = new
    4. 		// ClassPathXmlApplicationContext("/spring-context.xml");
    5.  
    6. 		Resource resource = new ClassPathResource("/spring-context.xml");
    7. 		BeanFactory beanFactory = new XmlBeanFactory(resource);
    8. 		InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
    9. 		
    10. 	}

    放出后会初始化方法，但最终不会摧毁方法

     

     

    单例模式下javabean的生命周期

                    容器生对象生，  容器死对象死

    多例模式下javabean的生命周期

                    使用时对象生，死亡跟着jvm垃圾回收机制走

    bean的初始化时间点，除了跟bean管理模式（单例/多例）有关，还跟BeanFactory的子类有关

  • 相关阅读:
    如何在 Rocky Linux 上安装 Apache Kafka？
    MATLAB中uiresume函数用法
    TouchGFX界面开发 | 按钮控件应用示例
    华为OD机试 - 计算面积 - 逻辑分析（Java 2023 B卷 100分）
    springcloudgateway 默认转发不生效
    petalinux下修改系统空间笔记
    vue 手势解锁功能
    【scikit-learn基础】--『监督学习』之 空间聚类
    opencv之 drawContours() 函数说明应用
    java常见类的方法和使用
  • 原文地址：https://blog.csdn.net/weixin_61523879/article/details/126232956