国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

  1. Toy模板網首頁
  2. >Toy博客

【Spring】Spring之Bean生命周期源碼解析

2年前作者：Firechou分類：Toy博客閱讀(22)違法舉報

這篇具有很好參考價值的文章主要介紹了【Spring】Spring之Bean生命周期源碼解析。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

概述

  • 什么是bean的生命周期

是指bean在spring中是如何生成，如何銷毀的；
spring創(chuàng)建對象的過程，就是IOC（控制反轉）的過程；

  • JFR

Java Flight Record，java飛行記錄，類似于飛機的黑匣子，是JVM內置的基于事件的JDK監(jiān)控記錄框架，主要用于問題定位和持續(xù)監(jiān)控；

Bean的生成過程

入口代碼：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) applicationContext.getBean("userService");
userService.test();

1 生成BeanDefinition

Spring啟動的時候會進行掃描，掃描定義的包路徑，得到BeanDefinition的Set集合；

掃描類文件流程如下：

  1. 首先，通過ResourcePatternResolver獲得指定包路徑下的所有.class文件（Spring源碼中將此文件包裝成了Resource對象）
  2. 遍歷每個Resource對象
  3. 利用MetadataReaderFactory解析Resource對象得到MetadataReader（在Spring源碼中MetadataReaderFactory具體的實現(xiàn)類為CachingMetadataReaderFactory，MetadataReader的具體實現(xiàn)類為SimpleMetadataReader）
  4. 利用MetadataReader進行excludeFilters和includeFilters，以及條件注解@Conditional的篩選（條件注解并不難理解：某個類上是否存在@Conditional注解，如果存在則調用注解中所指定的類的match方法進行匹配，匹配成功則通過篩選，匹配失敗則pass掉。）
  5. 篩選通過后，基于metadataReader生成ScannedGenericBeanDefinition
  6. 再基于metadataReader判斷是不是對應的類是不是接口或抽象類
  7. 如果篩選通過，那么就表示掃描到了一個Bean，將ScannedGenericBeanDefinition加入結果集

MetadataReader表示類的元數(shù)據讀取器，主要包含了一個AnnotationMetadata，功能有：

  1. 獲取類的名字
  2. 獲取父類的名字
  3. 獲取所實現(xiàn)的所有接口名
  4. 獲取所有內部類的名字
  5. 判斷是不是抽象類
  6. 判斷是不是接口
  7. 判斷是不是一個注解
  8. 獲取擁有某個注解的方法集合
  9. 獲取類上添加的所有注解信息
  10. 獲取類上添加的所有注解類型集合

CachingMetadataReaderFactory解析某個.class文件得到MetadataReader對象是利用的ASM技術，并沒有加載這個類到JVM。最終得到的ScannedGenericBeanDefinition對象，beanClass屬性存儲的是當前類的名字，而不是class對象。（beanClass屬性的類型是Object，它即可以存儲類的名字，也可以存儲class對象）

掃描得到BeanDefinition對象的幾種方法：

  1. 通過直接定義BeanDefinition
  2. 解析spring.xml文件的<bean/>
  3. AppConfig.class類方法上面加@Bean注解得到BeanDefinition對象

2 合并BeanDefinition

Spring中支持父子BeanDefinition，和Java父子類類似，但是完全不是一回事，父子BeanDefinition實際用的比較少。

使用方法如下：

<bean id="parent" class="com.firechou.service.Parent" scope="prototype"/>
<bean id="child" class="com.firechou.service.Child"/>

如上定義，child是單例Bean（默認單例）。

<bean id="parent" class="com.firechou.service.Parent" scope="prototype"/>
<bean id="child" class="com.firechou.service.Child" parent="parent"/>

如上定義，child是原型Bean，繼承與指定的父類parent的scope屬性。

在根據child來生成Bean對象之前，需要進行BeanDefinition的合并，得到完整的child的BeanDefinition。

3 加載類

BeanDefinition合并之后，就可以去創(chuàng)建Bean對象了，而創(chuàng)建Bean就必須實例化對象，而實例化就必須先加載當前BeanDefinition所對應的class，在AbstractAutowireCapableBeanFactory類的createBean()方法中，一開始就會調用：

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

如上代碼是加載類，具體實現(xiàn)如下：

if (mbd.hasBeanClass()) {
    // 如果beanClass屬性的類型是Class，那么就直接返回
	return mbd.getBeanClass();
}
// 根據類名加載
if (System.getSecurityManager() != null) {
	return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
		doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
	}
else {
    // 利用BeanFactory所設置的類加載器來加載類，如果沒有設置，則默認使用ClassUtils.getDefaultClassLoader()所返回的類加載器來加載。
	return doResolveBeanClass(mbd, typesToMatch);
}

public boolean hasBeanClass() {
	return (this.beanClass instanceof Class);
}

獲取加載類的類加載器，方法ClassUtils.getDefaultClassLoader()，流程如下：

  1. 優(yōu)先返回當前線程中的ClassLoader
  2. 線程中類加載器為null的情況下，返回ClassUtils類的類加載器
  3. 如果ClassUtils類的類加載器為空，那么則表示是Bootstrap類加載器加載的ClassUtils類，那么則返回系統(tǒng)類加載器

4 實例化前

BeanDefinition對應的類成功加載后，就可以實例化對象了，但是在Spring中，實例化對象之前，Spring提供了一個擴展點，允許用戶來控制是否在某個或某些Bean實例化之前做一些啟動動作。這個擴展點叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。

如下：

@Component
public class FireBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		// 注意，此時還沒有實例化，所以能拿到的是beanClass
        if ("userService".equals(beanName)) {
			System.out.println("實例化前");
            // 可以返回值，非null時，表示不需要Spring來實例化了，并且后續(xù)的Spring依賴注入也不會進行了，會跳過一些步驟，直接執(zhí)行初始化后這一步
            return new UserService();
		}
		return null;
	}
}

5 實例化

根據BeanDefinition去創(chuàng)建一個對象。

5.1 Supplier創(chuàng)建對象

首先判斷BeanDefinition中是否設置了Supplier，如果設置了則調用Supplier的get()得到對象。

直接使用BeanDefinition對象來設置Supplier，比如：

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new Supplier<Object>() {
	@Override
	public Object get() {
		return new UserService();
	}
});
context.registerBeanDefinition("userService", beanDefinition);

5.2 工廠方法創(chuàng)建對象

如果沒有設置Supplier，則檢查BeanDefinition中是否設置了factoryMethod，也就是工廠方法，有兩種方式可以設置factoryMethod。

方式一：

<bean id="userService" class="com.firechou.service.UserService" factory-method="createUserService" />

對應的UserService類為：

public class UserService {

	public static UserService createUserService() {
		System.out.println("執(zhí)行createUserService()");
		UserService userService = new UserService();
		return userService;
	}

	public void test() {
		System.out.println("test");
	}

}

方式二：

<bean id="commonService" class="com.firechou.service.CommonService"/>
<bean id="userService1" factory-bean="commonService" factory-method="createUserService" />

對應的CommonService的類為：

public class CommonService {
	public UserService createUserService() {
		return new UserService();
	}
}

Spring發(fā)現(xiàn)當前BeanDefinition方法設置了工廠方法后，就會區(qū)分這兩種方式，然后調用工廠方法得到對象；
通過@Bean所定義的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常類似，@Bean所注解的方法就是factoryMethod，AppConfig對象就是factoryBean。如果@Bean所注解的方法是static的，那么對應的就是方式一；

5.3 推斷構造方法

推斷完構造方法后，就會使用構造方法來進行實例化了。

選擇構造方法以及查找入參對象，判斷在對應的類中是否存在使用了@Lookup注解的方法，如果存在則把該方法封裝為LookupOverride對象并添加到BeanDefinition中。
在實例化時，如果判斷出來當前BeanDefinition中沒有LookupOverride，那就直接用構造方法反射得到一個實例對象。如果存在LookupOverride對象，也就是類中存在@Lookup注解的方法，那就會生成一個代理對象。

@Lookup注解就是方法注入，如下：

@Component
public class UserService {

	private OrderService orderService;

	public void test() {
		OrderService orderService = createOrderService();
		System.out.println(orderService);
	}

	@Lookup("orderService")
	public OrderService createOrderService() {
		return null;
	}

}

6 BeanDefinition的后置處理

Bean對象實例化出來之后，接下來就應該給對象的屬性賦值了。在真正給屬性賦值之前，Spring又提供了一個擴展點MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以對此時的BeanDefinition進行加工。

如下：

@Component
public class FireMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		if ("userService".equals(beanName)) {
			beanDefinition.getPropertyValues().add("orderService", new OrderService());
		}
	}
}

在Spring源碼中，AutowiredAnnotationBeanPostProcessor就是一個MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中會去查找注入點，并緩存在AutowiredAnnotationBeanPostProcessor對象的一個Map中（injectionMetadataCache）。

7 實例化后

在處理完BeanDefinition后，Spring又設計了一個擴展點：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()。

如下：

@Component
public class FireInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

		if ("userService".equals(beanName)) {
			UserService userService = (UserService) bean;
			userService.test();
		}

		return true;
	}
}

8 自動注入

這里的自動注入指的是Spring的自動注入。

9 處理屬性

這個步驟中，就會處理@Autowired、@Resource、@Value等注解，也是通過InstantiationAwareBeanPostProcessor.postProcessProperties()擴展點來實現(xiàn)的，比如我們甚至可以實現(xiàn)一個自己的自動注入功能。

如下：

@Component
public class FireInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			for (Field field : bean.getClass().getFields()) {
				if (field.isAnnotationPresent(FireInject.class)) {
					field.setAccessible(true);
					try {
						field.set(bean, "123");
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					}
				}
			}
		}

		return pvs;
	}
}

10 執(zhí)行Aware

完成了屬性賦值之后，Spring會執(zhí)行一些回調，包括：

  1. BeanNameAware：回傳beanName給bean對象。
  2. BeanClassLoaderAware：回傳classLoader給bean對象。
  3. BeanFactoryAware：回傳beanFactory給對象。

11 初始化前

初始化前，也是Spring提供的一個擴展點：BeanPostProcessor.postProcessBeforeInitialization()。
利用初始化前，可以對進行了依賴注入的Bean進行處理。

如下：

@Component
public class FireBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("初始化前");
		}

		return bean;
	}
}

在Spring源碼中：

  1. InitDestroyAnnotationBeanPostProcessor會在初始化前這個步驟中執(zhí)行@PostConstruct的方法，
  2. ApplicationContextAwareProcessor會在初始化前這個步驟中進行其他Aware的回調：
    1. EnvironmentAware：回傳環(huán)境變量
    2. EmbeddedValueResolverAware：回傳占位符解析器
    3. ResourceLoaderAware：回傳資源加載器
    4. ApplicationEventPublisherAware：回傳事件發(fā)布器
    5. MessageSourceAware：回傳國際化資源
    6. ApplicationStartupAware：回傳應用其他監(jiān)聽對象，可忽略
    7. ApplicationContextAware：回傳Spring容器ApplicationContext

12 初始化

  • 查看當前Bean對象是否實現(xiàn)了InitializingBean接口，如果實現(xiàn)了就調用其afterPropertiesSet()方法
  • 執(zhí)行BeanDefinition中指定的初始化方法

13 初始化后

這是Bean創(chuàng)建生命周期中的最后一個步驟，也是Spring提供的一個擴展點：BeanPostProcessor.postProcessAfterInitialization()。
可以在這個步驟中，對Bean最終進行處理，Spring中的AOP就是基于初始化后實現(xiàn)的，初始化后返回的對象才是最終的Bean對象。

如下：

@Component
public class FireBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("初始化后");
		}

		return bean;
	}
}

總結BeanPostProcessor

  1. InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
  2. 實例化
  3. MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
  4. InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
  5. 自動注入
  6. InstantiationAwareBeanPostProcessor.postProcessProperties()
  7. Aware對象
  8. BeanPostProcessor.postProcessBeforeInitialization()
  9. 初始化
  10. BeanPostProcessor.postProcessAfterInitialization()

Bean的銷毀過程

Bean銷毀是發(fā)送在Spring容器關閉過程中的。

如下：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();

// 容器關閉
context.close();

在Bean創(chuàng)建過程中，在最后（初始化之后），有一個步驟會去判斷當前創(chuàng)建的Bean是不是DisposableBean：

  1. 當前Bean是否實現(xiàn)了DisposableBean接口
  2. 或者，當前Bean是否實現(xiàn)了AutoCloseable接口
  3. BeanDefinition中是否指定了destroyMethod
  4. 調用DestructionAwareBeanPostProcessor.requiresDestruction(bean)進行判斷：
    1. ApplicationListenerDetector中直接使得ApplicationListener是DisposableBean
    2. InitDestroyAnnotationBeanPostProcessor中使得擁有@PreDestroy注解了的方法就是DisposableBean
  5. 把符合上述任意一個條件的Bean適配成DisposableBeanAdapter對象，并存入disposableBeans中（一個LinkedHashMap）

在Spring容器關閉過程時：

  1. 首先發(fā)布ContextClosedEvent事件
  2. 調用lifecycleProcessor的onCloese()方法
  3. 銷毀單例Bean
    1. 遍歷disposableBeans
      1. 把每個disposableBean從單例池中移除
      2. 調用disposableBean的destroy()
      3. 如果這個disposableBean還被其他Bean依賴了，那么也得銷毀其他Bean
      4. 如果這個disposableBean還包含了inner beans，將這些Bean從單例池中移除掉
    2. 清空manualSingletonNames，是一個Set，存的是用戶手動注冊的單例Bean的beanName
    3. 清空allBeanNamesByType，是一個Map，key是bean類型，value是該類型所有的beanName數(shù)組
    4. 清空singletonBeanNamesByType，和allBeanNamesByType類似，只不過只存了單例Bean

在定義一個Bean時，如果這個Bean實現(xiàn)了DisposableBean接口，或者實現(xiàn)了AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那么這個Bean都屬于“DisposableBean”，這些Bean在容器關閉時都要調用相應的銷毀方法。文章來源地址http://www.zghlxwxcb.cn/news/detail-614570.html

到了這里，關于【Spring】Spring之Bean生命周期源碼解析的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！

本文來自互聯(lián)網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。如若轉載，請注明出處： 如若內容造成侵權/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經查實，立即刪除！

領支付寶紅包贊助服務器費用

相關文章

  • 【Spring專題】Spring之Bean的生命周期源碼解析——階段一（掃描生成BeanDefinition）

    【Spring專題】Spring之Bean的生命周期源碼解析——階段一（掃描生成BeanDefinition）

    由于Spring源碼分析是一個前后聯(lián)系比較強的過程，而且這邊分析，也是按照代碼順序講解的，所以不了解前置知識的情況下，大概率沒辦法看懂當前的內容。所以，特別推薦看看我前面的文章（自上而下次序）： Spring底層核心原理解析——引導篇【學習難度： ★★☆☆☆ 】

    2024年02月13日
    瀏覽(24)
  • 【Spring專題】Spring之Bean的生命周期源碼解析——階段二（IOC之實例化）

    【Spring專題】Spring之Bean的生命周期源碼解析——階段二（IOC之實例化）

    由于Spring源碼分析是一個前后聯(lián)系比較強的過程，而且這邊分析，也是按照代碼順序講解的，所以不了解前置知識的情況下，大概率沒辦法看懂當前的內容。所以，特別推薦看看我前面的文章（自上而下次序）： Spring底層核心原理解析——引導篇【學習難度： ★★☆☆☆ 】

    2024年02月13日
    瀏覽(37)
  • 【Spring專題】Spring之Bean的生命周期源碼解析——階段二（二）（IOC之屬性填充/依賴注入）

    【Spring專題】Spring之Bean的生命周期源碼解析——階段二（二）（IOC之屬性填充/依賴注入）

    由于Spring源碼分析是一個前后聯(lián)系比較強的過程，而且這邊分析，也是按照代碼順序講解的，所以不了解前置知識的情況下，大概率沒辦法看懂當前的內容。所以，特別推薦看看我前面的文章（自上而下次序）： Spring底層核心原理解析【學習難度： ★★☆☆☆ 】 手寫簡易

    2024年02月12日
    瀏覽(25)

  • Spring源碼：Bean生命周期（五）

    在上一篇文章中，我們深入探討了 Spring 框架中 Bean 的實例化過程，該過程包括從 Bean 定義中加載當前類、尋找所有實現(xiàn)了 InstantiationAwareBeanPostProcessor 接口的類并調用實例化前的方法、進行實例化、調用 applyMergedBeanDefinitionPostProcessors 方法等多個步驟，最終生成了一個真正的

    2024年02月04日
    瀏覽(21)

  • Spring源碼：Bean生命周期（終章）

    本系列前面講解了Spring的bean定義、bean實例化、bean初始化等生命周期。這些步驟使我們能夠了解bean從創(chuàng)建到準備好使用所經歷的過程。但是，除了這些步驟，bean的銷毀也是非常重要的一步。在本系列的最后，我們將深入探討bean的銷毀過程，包括在什么情況下會發(fā)生銷毀、銷

    2024年02月06日
    瀏覽(34)

  • Spring源碼：Bean生命周期（三）

    在之前的文章中，我們已經對 bean 的準備工作進行了講解，包括 bean 定義和 FactoryBean 判斷等。在這個基礎上，我們可以更加深入地理解 getBean 方法的實現(xiàn)邏輯，并在后續(xù)的學習中更好地掌握 createBean 方法的實現(xiàn)細節(jié)。 講解getBean方法之前，我們先來看看他有幾種常見的用法：

    2024年02月02日
    瀏覽(22)
  • Spring源碼：bean的生命周期（一）

    Spring源碼：bean的生命周期（一）

    本節(jié)將正式介紹Spring源碼細節(jié)，將講解Bean生命周期。請注意，雖然我們不希望過于繁瑣地理解Spring源碼，但也不要認為Spring源碼很簡單。在本節(jié)中，我們將主要講解Spring 5.3.10版本的源代碼。如果您看到的代碼與我講解的不同，也沒有關系，因為其中的原理和業(yè)務邏輯基本相

    2024年02月02日
    瀏覽(23)
  • 【Spring源碼】講講Bean的生命周期

    【Spring源碼】講講Bean的生命周期

    面試官：“看過Spring源碼吧，簡單說說Spring中Bean的生命周期” 大神仙：“基本生命周期會經歷實例化 - 屬性賦值 - 初始化 - 銷毀”。 面試官：“......” 如果是普通Bean的生命周期，那么上述的回答是真正確的。確實會經歷“實例化 - 屬性賦值 - 初始化 - 銷毀”四個階段。但

    2023年04月09日
    瀏覽(20)

  • Spring源碼：Bean的生命周期（二）

    讓我們繼續(xù)講解Spring的Bean實例化過程。在上一節(jié)中，我們已經講解了Spring是如何將Bean定義加入到IoC容器中，并使用合并的Bean定義來包裝原始的Bean定義。接下來，我們將繼續(xù)講解Spring的 getBean() 方法，特別是針對 FactoryBean 的解析。 在 getBean() 方法中，Spring還支持對 FactoryBea

    2024年02月02日
    瀏覽(33)
  • 【Spring 】執(zhí)行流程解析：了解Bean的作用域及生命周期

    【Spring 】執(zhí)行流程解析：了解Bean的作用域及生命周期

    ?哈嘍，哈嘍，大家好~ 我是你們的老朋友： 保護小周?? ? 今天給大家?guī)淼氖?Spring 項目的執(zhí)行流程解析? 和 Bean 對象的6 種作用域 以及 生命周期 ， 本文將為大家講解，一起來看看叭~ 本期收錄于博主的專欄 ：JavaEE_保護小周?的博客-CSDN博客 適用于編程初學者，感興趣

    2024年02月16日
    瀏覽(22)

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請作者喝杯咖啡吧~博客贊助

支付寶掃一掃領取紅包，優(yōu)惠每天領

二維碼1

領取紅包

二維碼2

領紅包