### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- 在使用@Import註解來註冊bean的時候，Import註解的值可以是ImportSelector或者DeferredImportSelector的實現類，spring容器會例項化這個實現類，並執行其selectImports方法，那麼問題來了：**ImportSelector和DeferredImportSelector的區別在哪裡，我們自定義Imort邏輯的時候該選擇哪個呢？**本文透過分析相關的spring原始碼來查詢答案；

### 全文概覽
- 本文由以下幾部分組成：
1. 看官方文件；
2. 分析spring原始碼中對這兩個介面的處理；
3. 實戰驗證；

### 看官方文件
- 先看官方文件看起，我選擇了4.3.9版本線上文件（這是個Release版），地址：https://docs.spring.io/spring/docs/4.3.19.RELEASE/javadoc-api/

- 原文：**
A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional.
Implementations can also extend the Ordered interface or use the Order annotation to indicate a precedence against other DeferredImportSelectors.
**

- 我的理解：
1. DeferredImportSelector是ImportSelector的一個擴充套件；
2. ImportSelector例項的selectImports方法的執行時機，是在@Configguration註解中的其他邏輯被處理**之前**，所謂的其他邏輯，包括對@ImportResource、@Bean這些註解的處理（注意，這裡只是對@Bean修飾的方法的處理，並不是立即呼叫@Bean修飾的方法，這個區別很重要！）；
3. DeferredImportSelector例項的selectImports方法的執行時機，是在@Configguration註解中的其他邏輯被處理**完畢之後**，所謂的其他邏輯，包括對@ImportResource、@Bean這些註解的處理；
4. DeferredImportSelector的實現類可以用Order註解，或者實現Ordered介面來對selectImports的執行順序排序；

### 分析spring原始碼中對這兩個介面的處理
- 接下來看看原始碼：
- 在spring-framework-4.1.8.RELEASE工程中找到類ConfigurationClassParser.java，這裡面有處理配置類的主要邏輯；
- 找到方法parse(Set<beandefinitionholder> configCandidates)：

```java
public void parse(Set<beandefinitionholder> configCandidates) {
		this.deferredImportSelectors = new LinkedList<deferredimportselectorholder>();
		//檢查每個bean的定義
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					//對於每個有註解的類，都執行方法parse(AnnotationMetadata metadata, String beanName)
					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Exception ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}
		
		//最後再處理DeferredImportSelector的實現類
		processDeferredImportSelectors();
	}
```

- 由以上程式碼可以大致看出DeferredImportSelector的實現類被最後放在processDeferredImportSelectors方法中處理，那麼前面的parse(AnnotationMetadata metadata, String beanName)做了些什麼呢？繼續看；

- 展開方法parse(AnnotationMetadata metadata, String beanName)裡面，是執行processConfigurationClass方法;
- 再展開processConfigurationClass方法，看到核心邏輯是呼叫doProcessConfigurationClass方法，展開看看：

```java
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
		//為了聚焦Import相關處理，此處略去部分不相關程式碼，不在這裡展示了
		...
		...
		// 處理@Import註解
		processImports(configClass, sourceClass, getImports(sourceClass), true);

// 處理@ImportResource註解
		if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
			AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
			String[] resources = importResource.getStringArray("value");
			Class extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addImportedResource(resolvedResource, readerClass);
			}
		}

// 處理@Bean註解，注意是處理註解，不是執行@Bean修飾的方法
		Set<methodmetadata> beanMethods = sourceClass.getMetadata().getAnnotatedMethods(Bean.class.getName());
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

// 處理Configuration類的父類，外面在呼叫doProcessConfigurationClass方法的時有迭代處理，確保所有父類的註解都會被處理
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (!superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}

// 再也沒有父類了，返回null表示當前Configuration處理完畢
		return null;
	}
```

- 根據上述程式碼分析，可以梳理出下圖中的邏輯：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220619/1655636940207105353.png)

- 現在需要再看看processImports和processDeferredImportSelectors這兩個方法的具體程式碼；

- 先看processImports方法：

```java
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<sourceclass> importCandidates, boolean checkForCircularImports) throws IOException {

if (importCandidates.isEmpty()) {
			return;
		}

if (checkForCircularImports && this.importStack.contains(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		}
		else {
			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					//如果是ImportSelector介面的實現類，就在此處理
					if (candidate.isAssignable(ImportSelector.class)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class> candidateClass = candidate.loadClass();
						//例項化這些ImportSelector的實現類
						ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
						//如果這實現類還實現了BeanFactoryAware、EnvironmentAware這些介面，就要先執行這些介面中宣告的方法
						invokeAwareMethods(selector);
						//如果這個實現類也實現了DeferredImportSelector介面，就被加入到集合deferredImportSelectors中
						if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
							this.deferredImportSelectors.add(
									new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
						}
						else {
							//注意，這一行是關鍵程式碼！！！執行實現類的selectImports方法
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<sourceclass> importSourceClasses = asSourceClasses(importClassNames);
							processImports(configClass, currentSourceClass, importSourceClasses, false);
						}
					}
					//此處略去的和ImportSelector不相關的邏輯程式碼
					...
					...
					...
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Exception ex) {
				throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" +
						configClass.getMetadata().getClassName() + "]", ex);
			}
			finally {
				this.importStack.pop();
			}
		}
	}
```

- 以上程式碼有兩個關鍵點：
- 第一、當前被處理的類，如果實現了DeferredImportSelector介面，就被加入到集合deferredImportSelectors中；
- 第二、當前被處理的類，如果沒有實現DeferredImportSelector介面，但是實現了ImportSelector介面，就被執行selectImports方法；

- 接下來看看processDeferredImportSelectors方法的原始碼，提前推測應該是處理集合deferredImportSelectors中的所有類，這些類都實現了DeferredImportSelector介面：

```java
private void processDeferredImportSelectors() {
		List<deferredimportselectorholder> deferredImports = this.deferredImportSelectors;
		this.deferredImportSelectors = null;
		//按照Order註解或者Ordered介面進行排序
		Collections.sort(deferredImports, DEFERRED_IMPORT_COMPARATOR);

for (DeferredImportSelectorHolder deferredImport : deferredImports) {
			ConfigurationClass configClass = deferredImport.getConfigurationClass();
			try {
				//此處是關鍵程式碼，執行DeferredImportSelector實現類的selectImports方法
				String[] imports = deferredImport.getImportSelector().selectImports(configClass.getMetadata());
				processImports(configClass, asSourceClass(configClass), asSourceClasses(imports), false);
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Exception ex) {
				throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" +
						configClass.getMetadata().getClassName() + "]", ex);
			}
		}
	}
```

- 至此，原始碼分析完畢了，從程式碼可以很清晰的看出ImportSelector與DeferredImportSelector的區別，就是selectImports方法執行時機有差別，這個差別期間，spring容器對此Configguration類做了些其他的邏輯：包括對@ImportResource、@Bean這些註解的處理（注意，這裡只是對@Bean修飾的方法的處理，並不是立即呼叫@Bean修飾的方法，這個區別很重要！）；

### 實戰驗證
- 接下來到了實戰驗證的環節了，本次實戰的內容是建立一個springboot工程，在裡面自定義三個ImportSelector介面的實現類，如果您不想敲程式碼，也可以去github下載原始碼，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個資料夾，本章原始碼在資料夾customizeimportselector下，如下圖紅框所示：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220619/1655636990957792867.png)

- 開始編碼吧：
- 我們建立三個ImportSelector的實現類來檢查其先後順序，三個Selector類簡介如下表，有兩個是DeferredImportSelector的實現類，一個是ImportSelector的實現類，每個Selector負責向spring容器註冊一種例項，：

| 類名      |   實現介面 |   Order註解|   Import的類|
| :-------- | :----| :----| :----|
| CustomizeImportSelector1| DeferredImportSelector | 102 | CustomizeServiceImpl1 |
| CustomizeImportSelector2| DeferredImportSelector | 101 | CustomizeServiceImpl2 |
| CustomizeImportSelector3| ImportSelector | 無 | CustomizeServiceImpl3 |

- 基於maven建立springboot框架的web工程，pom.xml內容如下：

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>

<groupid>com.bolingcavalry</groupid>
    <artifactid>customizeimportselector</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

<name>customizeimportselector</name>
    <description>Demo project for Spring Boot</description>

<parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>1.5.9.RELEASE</version>
        <relativepath></relativepath> 
    </parent>

<dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

<dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
        </dependency>
    </dependencies>

<build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>
```

- 建立三個介面CustomizeService1、CustomizeService2、CustomizeService3，第一個原始碼如下，另外兩個除了類名，其餘部分一樣：

```java
package com.bolingcavalry.customizeimportselector.service;

public interface CustomizeService1 {
    void execute();
}
```

- 建立三個類，分別實現上面的三個介面，也是除了類名其餘部分一樣：

```java
package com.bolingcavalry.customizeimportselector.service.impl;

import com.bolingcavalry.customizeimportselector.service.CustomizeService1;

public class CustomizeServiceImpl1 implements CustomizeService1 {

public CustomizeServiceImpl1() {
        System.out.println("construct : " + this.getClass().getSimpleName());
    }

@Override

public void execute() {
        System.out.println("execute : " + this.getClass().getSimpleName());
    }
}
```

- 建立CustomizeImportSelector1：

```java
package com.bolingcavalry.customizeimportselector.selector;

import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.annotation.Order;
import org.springframework.core.type.AnnotationMetadata;

@Order(102)
public class CustomizeImportSelector1 implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        System.out.println("selectImports : " + this.getClass().getSimpleName());
        return new String[]{"com.bolingcavalry.customizeimportselector.service.impl.CustomizeServiceImpl1"};
    }
}
```

- 建立CustomizeImportSelector2：

```java
package com.bolingcavalry.customizeimportselector.selector;

import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.core.annotation.Order;
import org.springframework.core.type.AnnotationMetadata;

@Order(101)
public class CustomizeImportSelector2 implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        System.out.println("selectImports : " + this.getClass().getSimpleName());
        return new String[]{"com.bolingcavalry.customizeimportselector.service.impl.CustomizeServiceImpl2"};
    }
}
```

- 建立CustomizeImportSelector3，實現的是ImportSelector介面：

```java
package com.bolingcavalry.customizeimportselector.selector;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.annotation.Order;
import org.springframework.core.type.AnnotationMetadata;

public class CustomizeImportSelector3 implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        System.out.println("selectImports : " + this.getClass().getSimpleName());
        return new String[]{"com.bolingcavalry.customizeimportselector.service.impl.CustomizeServiceImpl3"};
    }
}
```

- 建立配置類，將CustomizeImportSelector1、CustomizeImportSelector2、CustomizeImportSelector3全部用Import註解引入：

```java
package com.bolingcavalry.customizeimportselector;

import com.bolingcavalry.customizeimportselector.selector.CustomizeImportSelector1;
import com.bolingcavalry.customizeimportselector.selector.CustomizeImportSelector2;
import com.bolingcavalry.customizeimportselector.selector.CustomizeImportSelector3;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({CustomizeImportSelector1.class, CustomizeImportSelector2.class, CustomizeImportSelector3.class})
public class SysConfig {
}
```

- 建立啟動類CustomizeimportselectorApplication.java：

```java
package com.bolingcavalry.customizeimportselector;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CustomizeimportselectorApplication {

public static void main(String[] args) {
        SpringApplication.run(CustomizeimportselectorApplication.class, args);
    }
}
```

- 啟動應用，可見輸入資訊如下：

```shell
2018-09-09 15:43:45.790  INFO 15364 --- [           main] c.b.c.CustomizeimportselectorApplication : Starting CustomizeimportselectorApplication on DESKTOP-82CCEBN with PID 15364 (D:\github\blog_demos\customizeimportselector\target\classes started by 12167 in D:\github\blog_demos\customizeimportselector)
2018-09-09 15:43:45.791  INFO 15364 --- [           main] c.b.c.CustomizeimportselectorApplication : No active profile set, falling back to default profiles: default
2018-09-09 15:43:45.825  INFO 15364 --- [           main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@641147d0: startup date [Sun Sep 09 15:43:45 GMT+08:00 2018]; root of context hierarchy
selectImports : CustomizeImportSelector3
selectImports : CustomizeImportSelector2
selectImports : CustomizeImportSelector1
2018-09-09 15:43:46.425  INFO 15364 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
2018-09-09 15:43:46.430  INFO 15364 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2018-09-09 15:43:46.431  INFO 15364 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.23
2018-09-09 15:43:46.493  INFO 15364 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2018-09-09 15:43:46.493  INFO 15364 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 670 ms
2018-09-09 15:43:46.569  INFO 15364 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Mapping servlet: 'dispatcherServlet' to [/]
2018-09-09 15:43:46.572  INFO 15364 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
2018-09-09 15:43:46.572  INFO 15364 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2018-09-09 15:43:46.572  INFO 15364 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2018-09-09 15:43:46.572  INFO 15364 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
construct : CustomizeServiceImpl1
construct : CustomizeServiceImpl2
construct : CustomizeServiceImpl3
```

- 從上述資訊可以看出：
- 首先、三個selector實現類的selectImports方法執行順序符合預期：先執行ImportSelector實現類的，再執行DeferredImportSelector實現類的，並且DeferredImportSelector實現類的執行順序會按照Order的設定**從小到大**執行；
- 其次、CustomizeServiceImpl1、CustomizeServiceImpl2、CustomizeServiceImpl3的例項化順序並未受到影響；

- 至此，ImportSelector與DeferredImportSelector的區別已經分析和驗證完畢，隨著對Configuration初始化處理邏輯的深入瞭解，我們可以定製出更靈活強大的配置邏輯，以符合業務需求；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</deferredimportselectorholder></sourceclass></sourceclass></methodmetadata></deferredimportselectorholder></beandefinitionholder></beandefinitionholder>

ImportSelector與DeferredImportSelector的區別（spring4）

相關文章