1.简介
2.源码解析
- 2.1 导入配置的三种类型
- 2.2 源码解释
3、测试例子
- 3.1 导入普通类
- 3.2 导入带有@Configuration的配置类
- 3.3 通过ImportSelector 方式导入的类
- 3.4 通过 ImportBeanDefinitionRegistrar 方式导入的类
4. 详细过程解析
- 4.1 getImports 方法
- 4.2 processImports 方法

1.简介

在平时看源码或者很多配置类上面都会出现@Import注解,功能就是和Spring XML 里面的一样. @Import注解是用来导入配置类或者一些需要前置加载的类.

2.源码解析

2.1 导入配置的三种类型

@Import支持三种方式

1.带有@Configuration的配置类(4.2 版本之前只可以导入配置类，4.2版本之后也可以导入普通类)

2.ImportSelector 的实现

3.ImportBeanDefinitionRegistrar 的实现

2.2 源码解释

/**
 * Indicates one or more {@link Configuration @Configuration} classes to import.
 * 
 *功能类似XML 里面的 <import/> ,可以导入 @Configuration配置类，ImportSelector、
 * ImportBeanDefinitionRegistrar 的实现,4.2 版本之后可以导入普通类(类似AnnotationConfigApplicationContext#register
 * )
 * <p>Provides functionality equivalent to the {@code <import/>} element in Spring XML.
 * Allows for importing {@code @Configuration} classes, {@link ImportSelector} and
 * {@link ImportBeanDefinitionRegistrar} implementations, as well as regular component
 * classes (as of 4.2; analogous to {@link AnnotationConfigApplicationContext#register}).
 *
 * 可以在类级别声明或作为元注释声明
 * <p>May be declared at the class level or as a meta-annotation.
 * 如需要引入XML或其他类型的文件，使用@ImportResource注解
 * <p>If XML or other non-{@code @Configuration} bean definition resources need to be
 * imported, use the {@link ImportResource @ImportResource} annotation instead.
 */
 @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	/**
	 * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
	 * or regular component classes to import.
	 */
	Class<?>[] value();

}

3、测试例子

3.1 导入普通类

新建一个TestA

public class TestA {

    public void fun(String str) {
        System.out.println(str);
    }

    public void printName() {
        System.out.println("类名 ：" + Thread.currentThread().getStackTrace()[1].getClassName());
    }
}

新建一个ImportConfig,在类上面加上@Configuration，加上@Configuration是为了能让Spring 扫描到这个类，并且直接通过@Import引入TestA类

@Import({TestA.class})
@Configuration
public class ImportConfig {
}

3.测试结果

TestA 是一个普通的类，现在可以被@Autowired注释然后调用，就直接说明已经被Spring 注入并管理了，普通的类都是需要先实例化

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ApplicationMain.class)
public class ImportAnnotionTest {

    @Autowired
    TestA testA;

    @Test
    public void TestA() {
        testA.printName();
    }
}

打印：

类名 ：com.test.importdemo.TestA

3.2 导入带有@Configuration的配置类

新建TestB

@Configuration
public class TestB {
    public void fun(String str) {
        System.out.println(str);
    }

    public void printName() {
        System.out.println("类名 ：" + Thread.currentThread().getStackTrace()[1].getClassName());
    }
}

在ImportConfig.class里面直接引入TestB

@Import({TestA.class,TestB.class})
@Configuration
public class ImportConfig {
}

3.测试结果

TestB.class 的类上面已经有了@Configuration注解,本身就会配spring扫到并实例，@import引入带有@Configuration的配置文件，是需要先实例这个配置文件再进行相关操作

@Autowired
    TestB testB;


    @Test
    public void TestB(){
        testB.printName();
    }

打印：

ImportAnnotionTest in 8.149 seconds (JVM running for 10.104)
类名 ：com.test.importdemo.TestB
2019-01-31 14:12:05.737  INFO 23760 --- [       Thread-2]

3.3 通过ImportSelector 方式导入的类

新建TestC.class

public class TestC {
    public void fun(String str) {
        System.out.println(str);
    }

    public void printName() {
        System.out.println("类名 ：" + Thread.currentThread().getStackTrace()[1].getClassName());
    }
}

2.新建SelfImportSelector.class 实现ImportSelector 接口,注入TestC.class

//TODO ImportSelector 相关解释

public class SelfImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.test.importdemo.TestC"};
    }
}

3.ImportConfig上面引入SelfImportSelector.class

@Import({TestA.class,TestB.class,SelfImportSelector.class})
@Configuration
public class ImportConfig {
}

4.测试结果

@Autowired
    TestC testC;

    @Test
    public void TestC() {
        testC.printName();
    }

打印：

ImportAnnotionTest in 7.23 seconds (JVM running for 9.065)
类名 ：com.test.importdemo.TestC
2019-01-31 14:23:15.330  INFO 1196 --- [

3.4 通过 ImportBeanDefinitionRegistrar 方式导入的类

1.新建TestD.class

public class TestD {
    public void fun(String str) {
        System.out.println(str);
    }

    public void printName() {
        System.out.println("类名 ：" + Thread.currentThread().getStackTrace()[1].getClassName());
    }
}

2.新建SelfImportBeanDefinitionRegistrar.class,实现接口ImportBeanDefinitionRegistrar,注入TestD.class

public class SelfImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        RootBeanDefinition root = new RootBeanDefinition(TestD.class);
        registry.registerBeanDefinition("testD", root);
    }
}

3.ImportConfig类上加上导入SelfImportBeanDefinitionRegistrar.class

@Import({TestA.class,TestB.class,SelfImportSelector.class,
        SelfImportBeanDefinitionRegistrar.class})
@Configuration
public class ImportConfig {
}

4.测试结果

@Autowired
    TestD testD;


    @Test
    public void TestD() {
        testD.printName();
    }

打印：

ImportAnnotionTest in 7.817 seconds (JVM running for 9.874)
类名 ：com.test.importdemo.TestD
2019-01-31 14:30:05.781  INFO 23476 --- [

通过以上几种方法都是能成功注入Spring.

4. 详细过程解析

这里主要看 ConfigurationClassParser.java 里面的

doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) 这个方法. 具体定位到源码的302 行代码

为啥不从头梳理，这里Spring 启动过程比较复杂，要是从头梳理，涉及的东西比较多，好多人看了就会累了，放弃了，我们就单个点熟悉，最后再进行汇总

@Import注解的作用1.简介2.源码解析3、测试例子4. 详细过程解析

4.1 getImports 方法

在分析这个方法之前，我们先看一下 getImports 方法，这个方法就是获取所有的@import 里面的类

这里是获取 @import 里面的类，大致流程如下：

1. 定义一个 visited 的集合，用作是否已经判断过的标志

2. 这里就是获取sourceClass 上面的所有的 annotation，并挨个判断，如果不是 @import ,那就进一步递归调用对应的 annotation,直到全部结束

3. 加载sourceClass 里面的@Import annotation 里面对应的类名 ,最后返回

private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
		Set<SourceClass> imports = new LinkedHashSet<>();
		Set<SourceClass> visited = new LinkedHashSet<>();
		collectImports(sourceClass, imports, visited);
		return imports;
	}
	// 这里就是获取sourceClass 上面的 所有的 annotation， 如果不是 @import ,那就 进一步递归 调用 对应的 annotation,直到全部结束
	private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
			throws IOException {

		if (visited.add(sourceClass)) {
			for (SourceClass annotation : sourceClass.getAnnotations()) {
				String annName = annotation.getMetadata().getClassName();
				if (!annName.equals(Import.class.getName())) {
					collectImports(annotation, imports, visited);
				}
			}
			imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
		}
	}

4.2 processImports 方法

processImports 这个方法的代码逻辑也很清晰，流程图如下：

@Import注解的作用1.简介2.源码解析3、测试例子4. 详细过程解析

大致的流程如下:

判断 importCandidates 是否为空，为空退出
判断isChainedImportOnStack ，如果为true ,加入 problemReporter 里面的error ，并退出
把当前的 configClass 加入到 ImportStack里面，ImportStack 是继承了 ArrayDeque // TODO 和实现了 ImportRegistry// TODO
对 getImports 里面获取到的需要import 的类进行遍历处理

4.1 如果是 ImportSelector 类型，首先实例一个 ImportSelector 对象，然后对其进行 Aware 扩展(如果实现了 Aware 接口)

4.1.2 进一步判断是否是 DeferredImportSelector 类型，如果是，加入到 deferredImportSelectors 里面，最后处理，这里可以看一下方法parse(Set configCandidates)，里面最后一行才调用,这也就是有的时候，如果想最后注入，就可以定义为deferredImportSelectors 类型

4.1.2 如果不是 DeferredImportSelector 类型，那就调用 selectImports 方法，获取到所有的需要注入的类，这时再次调用 processImports 方法，这里调用processImports 方法，其实是把这些需要注入的类当成普通的 @Configuration 处理
如果是 ImportBeanDefinitionRegistrar 类型，这里也是先实例一个对象，然后加入到 importBeanDefinitionRegistrars 里面，后续会在 ConfigurationClassBeanDefinitionReader 这个类里面的 loadBeanDefinitionsFromRegistrars 方法处理的

6.如果上面两种类型都不是，那就是当初普通的带有@Configuration 的类进行处理了

@Import注解的作用1.简介2.源码解析3、测试例子4. 详细过程解析

@Import注解的作用1.简介2.源码解析3、测试例子4. 详细过程解析

目录

1.简介

2.源码解析

2.1 导入配置的三种类型

2.2 源码解释

3、测试例子

3.1 导入普通类

3.2 导入带有@Configuration的配置类

3.3 通过ImportSelector 方式导入的类

3.4 通过 ImportBeanDefinitionRegistrar 方式导入的类

4. 详细过程解析

4.1 getImports 方法

4.2 processImports 方法

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method