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

- 在spring框架下做開發時，@Import是常見的註解，可以用來動態建立bean，今天我們先從原始碼分析原理，再用實戰來驗證Import的作用；

### 文章概覽
- 本章由以下幾部分組成：
1. 從Enable字首的註解談起，揭示常見的Enable註解與Import註解的關係；
2. 常見的四種Import註解用法列舉；
3. 分析spring原始碼，揭示Import註解的工作原理；
4. 官方API文件中的疑問解答；
5. 實戰透過Import註解動態建立bean例項；

### 從Enable字首的註解談起
- 有很多註解都以Enable為字首，例如配置非同步呼叫的註解EnableAsync，其原始碼如下 ：

```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {
	Class extends Annotation> annotation() default Annotation.class;
	
	AdviceMode mode() default AdviceMode.PROXY;
	
	int order() default Ordered.LOWEST_PRECEDENCE;
}
```

- 從以上程式碼可見，使非同步呼叫生效的關鍵是**@Import(AsyncConfigurationSelector.class)**，透過此註解spring容器會建立AsyncConfigurationSelector例項並呼叫其selectImports方法，完成非同步呼叫相關的配置；

- 再多看幾個Enable字首的註解的原始碼，例如EnableBatchProcessing、EnableCaching、EnableDiscoveryClient等，也都是透過Import來生效的，這種方式值得我們學習，在業務開發中也能用類似方式來對bean例項做控制；

### 常見的四種Import註解用法列舉
- 在@Import註解的引數中可以填寫類名，例如**@Import(Abc.class)**，根據類Abc的不同型別，spring容器有以下四種處理方式：
- 如果Abc類實現了ImportSelector介面，spring容器就會例項化Abc類，並且呼叫其selectImports方法；
- DeferredImportSelector是ImportSelector的子類，如果Abc類實現了DeferredImportSelector介面，spring容器就會例項化Abc類，並且呼叫其selectImports方法，和ImportSelector的例項不同的是，DeferredImportSelector的例項的selectImports方法呼叫時機晚於ImportSelector的例項，要等到@Configuration註解中相關的業務全部都處理完了才會呼叫（具體邏輯在ConfigurationClassParser.processDeferredImportSelectors方法中），想了解更多DeferredImportSelector和ImportSelector的區別，請參考《ImportSelector與DeferredImportSelector的區別（spring4） 》
- 如果Abc類實現了ImportBeanDefinitionRegistrar介面，spring容器就會例項化Abc類，並且呼叫其registerBeanDefinitions方法；
- 如果Abc沒有實現ImportSelector、DeferredImportSelector、ImportBeanDefinitionRegistrar等其中的任何一個，spring容器就會例項化Abc類，官方說明在[這裡](https://docs.spring.io/spring/docs/4.3.19.RELEASE/spring-framework-reference/htmlsingle/#beans-java-using-import)；

### 分析spring原始碼，揭示Import註解的工作原理
- 接下來透過spring原始碼來了解spring容器是如何處理Import註解的；
- 先看spring容器的初始化程式碼，定位AbstractApplicationContext類的refresh方法，裡面會呼叫invokeBeanFactoryPostProcessors方法，如下圖紅框所示：

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

- 展開invokeBeanFactoryPostProcessors方法，繼續追蹤到了PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors方法，具體操作如下圖紅框所示：

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

- 對於上圖分析的呼叫invokeBeanDefinitionRegistryPostProcessors方法時作為入參傳入的bean，ConfigurationClassPostProcessor類的例項是符合過濾要求的：既實現了BeanDefinitionRegistryPostProcessor介面，又實現了PriorityOrdered介面，因此，在invokeBeanDefinitionRegistryPostProcessors方法中，ConfigurationClassPostProcessor類的postProcessBeanDefinitionRegistry方法被呼叫：

- ConfigurationClassPostProcessor類的postProcessBeanDefinitionRegistry方法中，如下圖紅框所示，processConfigBeanDefinitions方法負責處理@Configuration註解相關的業務：

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

- processConfigBeanDefinitions方法程式碼如下，請注意中文註釋：

```java
		//被確認為配置類的bean定義都放在集合configCandidates中
		Set<beandefinitionholder> configCandidates = new LinkedHashSet<beandefinitionholder>();
		//取所有bean的名稱
		String[] candidateNames = registry.getBeanDefinitionNames();
		//逐個檢查每個bean
		for (String beanName : candidateNames) {
			//取得每個bean的定義物件
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
					ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			//注意:ConfigurationClassUtils.checkConfigurationClassCandidate方法非常值得一看，裡面的透過當前類的註解來判斷是否為配置類
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				//例如有@Configuration註解的類，被判定為配置類，放入集合configCandidates中
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

// 如果一個配置類都沒找到，就直接返回了
		if (configCandidates.isEmpty()) {
			return;
		}

// Detect any custom bean name generation strategy supplied through the enclosing application context
		SingletonBeanRegistry singletonRegistry = null;
		if (registry instanceof SingletonBeanRegistry) {
			singletonRegistry = (SingletonBeanRegistry) registry;
			if (!this.localBeanNameGeneratorSet && singletonRegistry.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
				BeanNameGenerator generator = (BeanNameGenerator) singletonRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
				this.componentScanBeanNameGenerator = generator;
				this.importBeanNameGenerator = generator;
			}
		}

//例項化ConfigurationClassParser物件，用來處理配置類
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

Set<configurationclass> alreadyParsed = new HashSet<configurationclass>(configCandidates.size());
		do {
			//parse方法是處理配置類邏輯的核心程式碼
			parser.parse(configCandidates);
			parser.validate();
```

- 看ConfigurationClassParser類的parse方法：

```java
public void parse(Set<beandefinitionholder> configCandidates) {
		//稍後執行的parse方法中，所有DeferredImportSelector實現類都會被放入集合deferredImportSelectors中
		this.deferredImportSelectors = new LinkedList<deferredimportselectorholder>();

for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					//在這個parse方法中，所有DeferredImportSelector實現類都會被放入集合deferredImportSelectors中，它們的selectImports方法不會被執行，而其他ImportSelector實現類的selectImports都會被執行
					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);
			}
		}
		//此方法內，會將集合deferredImportSelectors中的所有物件取出來執行其selectImports方法
		processDeferredImportSelectors();
	}
```

- 從上述程式碼中可以看出，DeferredImportSelector實現類的selectImports方法會在最後被呼叫，其餘的關鍵邏輯應該在**parse(AnnotationMetadata metadata, String beanName)**這個關鍵方法中，順著這個方法一直追蹤下去，直到doProcessConfigurationClass方法，如下圖紅框所示，所有Import註解的處理，都在processImports方法中：

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

- processImports方法中包含了對ImportSelector實現類和ImportBeanDefinitionRegistrar實現類的處理，以及未實現這些介面的類的處理，我們逐個來分析吧，首先看ImportBeanDefinitionRegistrar實現類的處理，如下圖紅框位置，呼叫configClass.addImportBeanDefinitionRegistrar方法將ImportBeanDefinitionRegistrar實現類存入configClass的成員變數importBeanDefinitionRegistrars中，後面的ConfigurationClassPostProcessor類的processConfigBeanDefinitions方法中，**this.reader.loadBeanDefinitions(configClasses);**會呼叫這些ImportBeanDefinitionRegistrar實現類的registerBeanDefinitions方法：

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

- 再來看processImports方法中對ImportSelector實現類的處理，這裡略有些複雜，因為涉及到對processImports方法的迭代呼叫，請看下圖紅框旁邊的紅字說明：

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

- 如上圖所示，第二步就是在processImports方法中呼叫了processImports方法，再次進入processImports之後，會著ImportSelector實現類返回的bean名稱直接走到第三步的位置，第三步處理的就是沒有實現ImportSelector和ImportBeanDefinitionRegistrar這些介面的普通bean了；

- processImports方法對沒有實現ImportSelector和ImportBeanDefinitionRegistrar這些介面的普通bean的處理是執行processConfigurationClass方法，將這些bean放入了成員變數configurationClasses中，如下圖紅框所示：

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

- processImports方法分析完畢，Import註解匯入的bean都被儲存在ConfigurationClassParser例項中，我們回到ConfigurationClassPostProcessor類的processConfigBeanDefinitions方法，如下圖，**this.reader.loadBeanDefinitions(configClasses);**負責處理processImports方法找出的那些打算透過@Import註解來註冊到spring容器的bean：

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

- 展開this.reader.loadBeanDefinitions(configClasses)方法，在ConfigurationClassBeanDefinitionReader類中，是對每個配置類逐個執行loadBeanDefinitionsForConfigurationClass方法：

```java
public void loadBeanDefinitions(Set<configurationclass> configurationModel) {
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}
```

- 展開方法，真相大白，實現了ImportBeanDefinitionRegistrar介面的例項，會執行其registerBeanDefinitions方法，其餘普通的類，透過loadBeanDefinitionsFromImportedResources方法將其bean定義註冊在spring環境：

```java
private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
			TrackedConditionEvaluator trackedConditionEvaluator) {

if (trackedConditionEvaluator.shouldSkip(configClass)) {
			String beanName = configClass.getBeanName();
			if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
			}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
		}

if (configClass.isImported()) {
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}
		//普通的類，透過loadBeanDefinitionsFromImportedResources方法將其bean定義註冊在spring環境
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
		//實現了ImportBeanDefinitionRegistrar介面的例項，會在loadBeanDefinitionsFromRegistrars方法中執行其registerBeanDefinitions方法
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}
```

- 前面將普通類、ImportBeanDefinitionRegistrar實現類、ImportSelector實現類的分析已經完成，對於DeferredImportSelector實現類的處理在processDeferredImportSelectors方法中，其實和ImportSelector實現類的處理並無區別，只是處理時機比起ImportSelector實現類略晚，這裡就不多說了；

- 至此，透過Import註解註冊bean的四種方式已經全部分析完畢，小結如下：
1. 普通類（即沒有實現ImportBeanDefinitionRegistrar、ImportSelector、DeferredImportSelector等介面的類）會透過ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsFromImportedResources方法將bean定義註冊到spring容器；
2. ImportSelector實現類，其selectImports方法返回的bean的名稱，透過ConfigurationClassParser類的asSourceClass方法轉成SourceClass物件，然後被當作普通類處理；
3. DeferredImportSelector實現類的處理和ImportSelector實現類的處理並無區別，只是處理時機比起ImportSelector實現類略晚；
4. ImportBeanDefinitionRegistrar實現類的registerBeanDefinitions方法會被呼叫，裡面可以註冊業務所需的bean定義；

### 官方API文件中的疑問解答
- 在[官方API文件](https://docs.spring.io/spring/docs/5.0.4.BUILD-SNAPSHOT/javadoc-api/org/springframework/context/annotation/ImportSelector.html)中，對ImportSelector介面的描述如下圖所示，紅框中的一段意思是：** ImportSelector介面的實現類，如果同時也實現了EnvironmentAware、BeanFactoryAware、BeanClassLoaderAware、ResourceLoaderAware這些介面中的一個或幾個，那麼這些介面對應的方法優先執行，然後才會執行ImportSelector介面的selectImports**：

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

上圖紅框中的描述會讓我們不禁疑惑：spring是如何做到的呢？一起來看原始碼吧：

- 再次開啟ConfigurationClassParser類的processImports方法，如下圖兩個紅框所示，對於@Import註解值中的類，只要實現了ImportBeanDefinitionRegistrar、ImportSelector、DeferredImportSelector等介面中的任何一個，都會呼叫invokeAwareMethods方法（如果實現的是ImportSelector或DeferredImportSelector介面，此時還沒有執行selectImports方法）：

- 展開invokeAwareMethods方法，真相大白，這裡面檢查是否實現了EnvironmentAware、BeanFactoryAware、BeanClassLoaderAware、ResourceLoaderAware等介面，如果實現了就呼叫對應的方法；

```java
private void invokeAwareMethods(Object importStrategyBean) {
	if (importStrategyBean instanceof Aware) {
		if (importStrategyBean instanceof EnvironmentAware) {
			((EnvironmentAware) importStrategyBean).setEnvironment(this.environment);
		}
		if (importStrategyBean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) importStrategyBean).setResourceLoader(this.resourceLoader);
		}
		if (importStrategyBean instanceof BeanClassLoaderAware) {
			ClassLoader classLoader = (this.registry instanceof ConfigurableBeanFactory ?
					((ConfigurableBeanFactory) this.registry).getBeanClassLoader() :
					this.resourceLoader.getClassLoader());
			((BeanClassLoaderAware) importStrategyBean).setBeanClassLoader(classLoader);
		}
		if (importStrategyBean instanceof BeanFactoryAware && this.registry instanceof BeanFactory) {
			((BeanFactoryAware) importStrategyBean).setBeanFactory((BeanFactory) this.registry);
		}
	}
}
```

- 至此，原始碼分析工作已經結束，接下來實戰@Import註解的使用；

### 實戰透過Import註解動態建立bean例項
- 到了實戰驗證環節了，本次實戰的內容是建立一個springboot工程，透過@Import註解將bean註冊到spring容器，如果您不想敲程式碼，也可以去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專案中有多個資料夾，本章原始碼在資料夾customizeimport下，如下圖紅框所示：

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

- 下面動手開發：
- 設計：customizeimport工程中，有四個介面(CustomizeService1，CustomizeService2，CustomizeService3，CustomizeService4，每個介面有個對應的實現類（CustomizeServiceImpl1、CustomizeServiceImpl2、CustomizeServiceImpl3、CustomizeServiceImpl4），在配置類透過@Import註解，用不同方式將這些實現類的例項註冊到spring容器中，在一個Controller中驗證這四個例項，例項的註冊到spring容器方式規劃如下表格所示：
| 介面      |   實現類 |   註冊方式|
| :-------- | :----| :----|
| CustomizeService1| CustomizeService1Impl1 | CustomizeService1Impl1.class作為Import註解的值 |
| CustomizeService2| CustomizeService1Impl2 | 作為ImportSelector實現類的selectImports方法的返回值 |
| CustomizeService3| CustomizeService1Impl3 | 作為DeferredImportSelector實現類的selectImports方法的返回值 |
| CustomizeService4| CustomizeService1Impl4 | 在ImportBeanDefinitionRegistrar實現類的registerBeanDefinitions方法中註冊 |

- 建立maven工程customizeimport，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>customizeimport</artifactid>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

<name>customizeimport</name>
    <description>Demo project for Spring Import annotation</description>

<parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>1.5.15.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>
```

- 建立四個介面，除了類名不同，其他的都一樣，如下：

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

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

- 建立介面實現類，除了類名不同，其他的都一樣，如下：

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

import com.bolingcavalry.customizeimport.service.CustomizeService1;
import com.bolingcavalry.customizeimport.util.Utils;

public class CustomizeServiceImpl1 implements CustomizeService1 {

public CustomizeServiceImpl1() {
        Utils.printTrack("construct : " + this.getClass().getSimpleName());
    }

@Override

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

- 建立ImportSelector介面的實現類CustomizeImportSelector，其selectImports方法返回了CustomizeServiceImpl2的完整類名：

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

import com.bolingcavalry.customizeimport.util.Utils;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.annotation.Order;
import org.springframework.core.type.AnnotationMetadata;

public class CustomizeImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        Utils.printTrack("selectImports : " + this.getClass().getSimpleName());
        return new String[]{"com.bolingcavalry.customizeimport.service.impl.CustomizeServiceImpl2"};
    }
}
```

- 建立DeferredImportSelector介面的實現類CustomizeDeferredImportSelector，其selectImports方法返回了CustomizeServiceImpl3的完整類名：

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

import com.bolingcavalry.customizeimport.util.Utils;
import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.core.annotation.Order;
import org.springframework.core.type.AnnotationMetadata;

public class CustomizeDeferredImportSelector implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        Utils.printTrack("selectImports : " + this.getClass().getSimpleName());
        return new String[]{"com.bolingcavalry.customizeimport.service.impl.CustomizeServiceImpl3"};
    }
}
```

- 建立ImportBeanDefinitionRegistrar介面的實現類CustomizeImportBeanDefinitionRegistrar，其registerBeanDefinitions方法中在spring容器註冊了CustomizeServiceImpl4類的定義：

```java
package com.bolingcavalry.customizeimport.registrar;

import com.bolingcavalry.customizeimport.service.impl.CustomizeServiceImpl4;
import com.bolingcavalry.customizeimport.util.Utils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class CustomizeImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

private final static String BEAN_NAME = "customizeService4";

@Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        if (!registry.containsBeanDefinition(BEAN_NAME)) {
            Utils.printTrack("start registerBeanDefinitions");
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClass(CustomizeServiceImpl4.class);
            beanDefinition.setSynthetic(true);
            registry.registerBeanDefinition(BEAN_NAME, beanDefinition);
        }
    }
}
```

- 建立配置類SysConfig，使用了@Import註解：

```java
package com.bolingcavalry.customizeimport;

import com.bolingcavalry.customizeimport.registrar.CustomizeImportBeanDefinitionRegistrar;
import com.bolingcavalry.customizeimport.selector.CustomizeDeferredImportSelector;
import com.bolingcavalry.customizeimport.selector.CustomizeImportSelector;
import com.bolingcavalry.customizeimport.service.impl.CustomizeServiceImpl1;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({CustomizeServiceImpl1.class,
        CustomizeImportSelector.class,
        CustomizeDeferredImportSelector.class,
        CustomizeImportBeanDefinitionRegistrar.class})
public class SysConfig {
}
```

- 建立Controller類HelloController ，用於驗證CustomizeService1等介面的例項是否可用：

```java
package com.bolingcavalry.customizeimport.controller;

import com.bolingcavalry.customizeimport.service.CustomizeService1;
import com.bolingcavalry.customizeimport.service.CustomizeService2;
import com.bolingcavalry.customizeimport.service.CustomizeService3;
import com.bolingcavalry.customizeimport.service.CustomizeService4;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @Autowired(required = false)
    CustomizeService1 customizeServiceImpl1;

@Autowired(required = false)
    CustomizeService2 customizeServiceImpl2;

@Autowired(required = false)
    CustomizeService3 customizeServiceImpl3;

@Autowired(required = false)
    CustomizeService4 customizeServiceImpl4;

@GetMapping("hello")
    public String hello(){
        customizeServiceImpl1.execute();
        customizeServiceImpl2.execute();
        customizeServiceImpl3.execute();
        customizeServiceImpl4.execute();
        return "finish";
    }
}
```

- 最後是啟動類CustomizeimportApplication：

```java
package com.bolingcavalry.customizeimport;

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

@SpringBootApplication
public class CustomizeimportApplication {

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

- 啟動應用，觀察日誌，可見Import的值都生效了，ImportSelector的selectImports被呼叫，ImportBeanDefinitionRegistrar的registerBeanDefinitions被呼叫，然後是CustomizeServiceImpl1 等類的例項被建立，篇幅所限就不在此將所有日誌貼出，請您自行執行和檢查：

```shell
2018-09-10 12:36:33.917  INFO 5884 --- [           main] c.b.customizeimport.util.Utils           : selectImports : CustomizeImportSelector
************************************************************
java.lang.Thread.getStackTrace() 1,556  [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</configurationclass></deferredimportselectorholder></beandefinitionholder></configurationclass></configurationclass></beandefinitionholder></beandefinitionholder>

spring4.1.8擴充套件實戰之八：Import註解

相關文章