11.导入组件

一.@Import：用来导入配置类或者一些需要前置加载的类.

1.1 源码解析
1.1.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();

}

2.用法:@Import({TestA.class,TestB.class}):导入组件

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

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

3.3 通过ImportSelector 方式导入的类

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

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

3.4 通过 ImportBeanDefin

新建SelfImportBeanDefinitionRegistrar.class,实现接口ImportBeanDefinitionRegistrar,注入TestD.classitionRegistrar 方式导入的类

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

ImportConfig类上加上导入SelfImportBeanDefinitionRegistrar.class

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

4. 详细过程解析

这里主要看 ConfigurationClassParser.java 里面的
doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) 这个方法. 具体定位到源码的302 行代码

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 这个方法的代码逻辑也很清晰，流程图如下：

大致的流程如下:

判断 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 的类进行处理了

二、@Conditional

详解

@Conditional是Spring4新提供的注解，它的作用是按照一定的条件进行判断，满足条件给容器注册bean。

参数是Condition类的集合看看Condition接口

matches就像正则的那个类一样…应该是true注入,false不注入

测试

创建一个person类,然后创建个配置类,返回一个linux,一个gates,类.

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Person {

    private String name;

    private int age;

}

配置类记得要扫到

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PersonConfigure {

    @Bean(name = "bill")
    @Conditional({WindowsCondition.class})
    public Person person1() {
        return new Person("Bill Gates", 62);
    }

    @Bean("linus")
    @Conditional({LinuxCondition.class})
    public Person person2() {
        return new Person("Linus", 48);
    }


}

后测试一波,我这是springboot项目,测试比较简单.

import com.alibaba.fastjson.JSON;
import com.ql.servicetest.conditionDemo.Person;
import org.junit.Test;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import java.util.Map;


public class ConditionTest extends BaseTest implements ApplicationContextAware {

    @Test
    public void test1() {
        Map<String, Person> beansOfType = ApplicationContext.getBeansOfType(Person.class);

        String property = ApplicationContext.getEnvironment().getProperty("os.name");
        System.out.println("当前系统为:"+property);

        System.out.println(JSON.toJSONString(beansOfType));

    }

    public ApplicationContext ApplicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.ApplicationContext = applicationContext;
    }
}

我直接继承baseTest测试类,然后实现ApplicationContextAware得到spring容器,简单方便.一开始不加Conditional注解,就是两个都有,创建两个类LinuxCondition,WindowsCondition分别实现Condition接口,作为@Contional注解的值;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class LinuxCondition implements Condition {
 
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
 
        Environment environment = conditionContext.getEnvironment();
 
        String property = environment.getProperty("os.name");
        if (property.contains("Linux")){
            return true;
        }
        return false;
    }
}

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class WindowsCondition implements Condition {
 
    /**
     * @param conditionContext:判断条件能使用的上下文环境
     * @param annotatedTypeMetadata:注解所在位置的注释信息
     * */
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取ioc使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();
        //获取当前环境信息
        Environment environment = conditionContext.getEnvironment();
        //获取bean定义的注册类
        BeanDefinitionRegistry registry = conditionContext.getRegistry();
 
        //获得当前系统名
        String property = environment.getProperty("os.name");
        //包含Windows则说明是windows系统，返回true
        if (property.contains("Windows")){
            return true;
        }
        return false;
    }
}

这两个类其实就是拿到当前运行环境进行判断,然后返回true,false.
分别将 @Conditional注解加上,然后运行: