欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

一文詳解Spring?中的順序問題

 更新時間：2023年05月04日 15:19:06   作者：Fire?Fish  
本文主要介紹了Spring?中的順序問題，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

Spring 中的順序問題并不是不重要，比如多個 BeanFactoryPostProcessor如何知道先執(zhí)行哪一個；為什么自定義的 Bean 可以覆蓋默認(rèn)的自動裝配的 Bean；AOP 攔截器鏈中攔截器的順序是如何確定的等等問題。

相信看完這篇文檔你應(yīng)該能夠?qū)?Spring 的順序問題有一些理解！

結(jié)論：總體上是無序的，但局部是有順序的

1、有特殊接口或注解，就用它的順序

特殊接口或注解就是：PriorityOrdered 接口、Ordered 接口、@Priority 注解、@Order 注解

2、沒有，就用 beanDefinitionNames 順序

那么什么決定了 beanDefinitionNames 的順序呢？？？在下文中有說明

下面會列舉一些 Spring 中的一些常見的順序代碼來分析

舉例 1：Spring 注冊非懶加載的的 Bean

// DefaultListableBeanFactory.class
public void preInstantiateSingletons() throws BeansException {
    // <1> 收集beanDefinitionNames集合
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    for (String beanName : beanNames) {
        // <2> 依次注冊 Bean
        getBean(beanName);
    }
}
  • <1> 處，收集 BeanDefinition 集合
  • <2> 處，實例化的順序總體上是跟注冊的順序一致，但是實例化過程中處理屬性依賴、構(gòu)造器參數(shù)依賴等等依賴時，會先對依賴的 Bean 進(jìn)行實例化！

舉例 2：Spring 處理 BeanFactoryPostProcessor 接口

// PostProcessorRegistrationDelegate.class
public static void invokeBeanFactoryPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    // <1> 收集BeanDefinitionRegistryPostProcessor集合
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    for (String ppName : postProcessorNames) {
        // <2> 優(yōu)先處理 PriorityOrdered 接口
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            processedBeans.add(ppName);
        }
    }
    // <3> 再處理 Ordered 接口的
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
        }
    }
    // <4> 最后處理不是這 2 個接口的
}
  • <1> 處，收集 BeanDefinitionRegistryPostProcessor 集合，但是是根據(jù)注冊的順序(即 beanDefinitionNames )收集的
  • <2> 處，優(yōu)先處理 PriorityOrdered 接口
  • <3> 處，再處理 Ordered 接口的
  • <4> 處，最后處理不是這 2 個接口的 舉例 3：AnnotationAwareOrderComparator 注解排序比較

作用：該比較器的作用是對標(biāo)注了注解的內(nèi)容進(jìn)行排序，@Priority 優(yōu)先 @Order，同注解要看 value 大小

在 Spring 中幾乎所有需要用到比較的地方都會使用該注解比較器，如：

在實例化 ApplicationContextInitializer 接口時，代碼及注釋如下：

// 代碼位置：AbstractContextLoader.class
private void invokeApplicationContextInitializers(ConfigurableApplicationContext context,
                                                  MergedContextConfiguration mergedConfig) {
	... ...略
    // <1> 對 initializerInstances 排序
    AnnotationAwareOrderComparator.sort(initializerInstances);
    for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : initializerInstances) {
        // <2> 比較后挨個實例化
        initializer.initialize(context);
    }
}

loadFactories 方法從配置中加載和實例化指定類型的類，代碼及注釋如下：

// 代碼位置：SpringFactoriesLoader.class
// 功能：加載配置中的 factoryClass 類型的定義
public static <T> List<T> loadFactories(Class<T> factoryClass, @Nullable ClassLoader classLoader) {
    // <1> 加載factoryClass 類型的列表
    List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
    List<T> result = new ArrayList<>(factoryNames.size());
    for (String factoryName : factoryNames) {
        // <2> 逐個實例化
        result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
    }
    // <3> 排序
    AnnotationAwareOrderComparator.sort(result);
    return result;
}

AOP 進(jìn)行排序時，代碼及注釋如下：

// 代碼位置：AbstractAdvisorAutoProxyCreator.class
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // <1> 查找候選的 Advisor
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // <2> 適配當(dāng)前 beanClass 的 Advisor
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        // <3> 對 Advisor 排序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

什么決定了 beanDefinitionNames 的順序

需要了解的背景知識

1、Spring 的啟動流程、Spring Boot 的啟動流程

2、Spring Boot 自動裝配原理

3、BeanFactoryPostProcessor 后置處理器是如何工作的，特別的重點掌握 ConfigurationClassPostProcessor

注冊過程簡單分析過程

因為 beanDefinitionNames 屬性只能通過如下代碼添加（有且僅有這一處 add 方法）

// 代碼位置：DefaultListableBeanFactory.class
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    throws BeanDefinitionStoreException {
    // 注冊
    this.beanDefinitionNames.add(beanName);
}

所以該屬性的順序主要與 this.registry.registerBeanDefinition 方法的調(diào)用相關(guān)

ConfigurationClassPostProcessor 簡單分析

調(diào)用容器registry來注冊 BeanDefinition 的代碼省略如下：

// 代碼位置：ConfigurationClassPostProcessor.class
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    do {
        // <1> 解析 candidates
        parser.parse(candidates);
        // <2> 獲取【有序的】配置類集合
        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        // <3> 處理配置類
        this.reader.loadBeanDefinitions(configClasses);
    }
    while (!candidates.isEmpty());
}
  • <1> 處，最開始一般 candidates 只有一個類就是 @SpringApplication 注解標(biāo)注的類；然后在 parse 方法內(nèi)部經(jīng)歷了各種各種遞歸調(diào)用處理完所有的配置類
  • <2> 處，獲取 parse 階段解析好的所有配置類
  • <3> 處，處理【有序的配置類】的注冊，注冊到 beanDefinitionNames 屬性中

基于以上的簡單分析給出如下結(jié)論

注冊順序的結(jié)論

以以下代碼舉例來說明 beanDefinitionNames 的注冊順序

@SpringBootApplication
@EnableCaching
@EnableTransactionManagement
@MapperScan(basePackages = "cn.iocoder.springboot.lab21.cache.mapper")
public class Application {
	public static void main(String[] args) {
        // 先處理 run 方法中傳入的"配置類"，即 Application 類
		SpringApplication.run(Application.class);
	}
}

Application 優(yōu)先級最高

因為一般只有唯一一個 candidates 類，即啟動類 Application，它是配置類 Configuration 注冊的入口

其次是 Application 類所在的包

處理各種 ImportSelector 導(dǎo)入的類

先處理 @EnableCaching 注解、再處理 @EnableTransactionManagement 注解、再處理 @MapperScan 注解

最后是自動裝配的類

備注：

1、排序在前面的 Configuration 類會先被注冊

2、Configuration 的順序是可能控制的，如可通過 @AutoConfigureBefore、@AutoConfigureAfter、@AutoConfigureOrder等方式

解釋一些順序相關(guān)的問題

因為有了上面的結(jié)論，我們就可以嘗試解決一些順序相關(guān)的問題

問題 1：我們自定義的 Bean 存在時，不會加載默認(rèn)的 Bean，只有我們自定義 Bean 不存在時才會加載默認(rèn)的 Bean

答案：按照上面的注冊順序，先掃描我們自定義的包，所以我們自定義的 Bean 先被注冊；而在自動裝配時可能使用了@ConditionalOnBean等條件注解，從而導(dǎo)致條件不滿足，就不再注冊默認(rèn)的 Bean

問題 2：注冊的順序影響大嗎

答案：

1、有很大影響，除了標(biāo)注或?qū)崿F(xiàn)特殊注解或接口的類沒有影響外，其他類都會受到一定的影響

2、很難全面把握 Spring Boot 自動裝配的順序，這也是導(dǎo)致 Spring Boot 比較晦澀難懂的一方面

留下一個疑問供各位看官答疑

問題 ：如下@EnableCaching注解、@EnableTransactionManagement的先后順序?qū)?2 種攔截器的順序有影響？？？

方式 1：

@SpringBootApplication
@EnableTransactionManagement
@EnableCaching
@MapperScan(basePackages = "cn.iocoder.springboot.lab21.cache.mapper")
public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class);
	}
}

image-20230429043546519

方式 2：

@SpringBootApplication
@EnableCaching
@EnableTransactionManagement
@MapperScan(basePackages = "cn.iocoder.springboot.lab21.cache.mapper")
public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class);
	}
}

image-20230429043748409

答案：從截圖的結(jié)果上來看是有影響的，為啥呢

說明：

1、因為@EnableCaching和@@EnableTransactionManagement都是通過 ImportSelector 機(jī)制，上面的注解會先被處理；所以方式 1 的事務(wù)會被先注冊，緩存會被后注冊

2、其次雖然在 AOP 會被 Advisor 進(jìn)行排序

// 代碼位置：AbstractAdvisorAutoProxyCreator.class
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // <1> 查找候選的 Advisor
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // <2> 適配當(dāng)前 beanClass 的 Advisor
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        // <3> 對 Advisor 排序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

但是事務(wù)的BeanFactoryTransactionAttributeSourceAdvisor 和緩存的BeanFactoryCacheOperationSourceAdvisor均沒有順序接口或注解，所以排序失效，注冊的順序就是 Advisor 的順序

到此這篇關(guān)于一文詳解Spring 中的順序問題的文章就介紹到這了,更多相關(guān)Spring 順序內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

最新評論