十六、@Configration和@Bean注解

1、@Configuration注解

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigBean.class);

2、@Bean注解

@Bean
public User user1() {
	return new User();
}

十七、@ComponentScan、@ComponentScans注解

1、@ComponentScan

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};
    
    @AliasFor("value")
    String[] basePackages() default {};
    
    Class<?>[] basePackageClasses() default {};
    
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
    
    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
    
    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
    
    String resourcePattern() default "**/*.class";
    
    boolean useDefaultFilters() default true;
    
    Filter[] includeFilters() default {};
    
    Filter[] excludeFilters() default {};
    
    boolean lazyInit() default false;
}

@ComponentScan工作的过程：

2、@Component、@Repository、@Service、@Controller

3、includeFilters的使用

Filter[] includeFilters() default {};

是一个 Filter 类型的数组，多个Filter之间为或者关系，即满足任意一个就可以了，看一下 Filter 的代码：

@Retention(RetentionPolicy.RUNTIME)
@Target({})
@interface Filter {
    FilterType type() default FilterType.ANNOTATION;
    
    @AliasFor("classes")
    Class<?>[] value() default {};
    
    @AliasFor("value")
    Class<?>[] classes() default {};
    
    String[] pattern() default {};
}

type

value

classes

pattern

案例：扫描包含某个注解的类

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component //@1
public @interface MyBean {
    @AliasFor(annotation = Component.class) //@2
	String value() default ""; //@3
}

@MyBean
public class Service1 {
}

使用@CompontentScan标注

@ComponentScan(
    useDefaultFilters = false, //不启用默认过滤器
    includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes =MyBean.class)})
public class ScanBean3 {
}

案例：扫描包含指定类型的类

public interface IService {
}

@CompontentScan标注的类

@ComponentScan(
	useDefaultFilters = false, //不启用默认过滤器
	includeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes= IService.class)}
)
public class ScanBean4 {
}

4、自定义Filter

@FunctionalInterface
public interface TypeFilter {
	boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException;
}

MetadataReader接口

public interface MetadataReader {
    /**
    * 返回类文件的资源引用
    */
    Resource getResource();
    /**
    * 返回一个ClassMetadata对象，可以通过这个读想获取类的一些元数据信息，如类的class对象、
    是否是接口、是否有注解、是否是抽象类、父类名称、接口名称、内部包含的之类列表等等，可以去看一下源
    码
    */
    ClassMetadata getClassMetadata();
    /**
    * 获取类上所有的注解信息
    */
    AnnotationMetadata getAnnotationMetadata();
}

MetadataReaderFactory接口

public interface MetadataReaderFactory {
    /**
    * 返回给定类名的MetadataReader对象
    */
    MetadataReader getMetadataReader(String className) throws IOException;
    /**
    * 返回指定资源的MetadataReader对象
    */
    MetadataReader getMetadataReader(Resource resource) throws IOException;
}

我们来个自定义的Filter，判断被扫描的类如果是 IService 接口类型的，就让其注册到容器中。

public class MyFilter implements TypeFilter {
    /**
    * @param metadataReader
    * @param metadataReaderFactory
    * @return
    * @throws IOException
    */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
    	Class curClass = null;
        try {
        //当前被扫描的类
        curClass = Class.forName(metadataReader.getClassMetadata().getClassName());
        } catch (ClassNotFoundException e) {
        	e.printStackTrace();
        }
        
        //判断curClass是否是IService类型
        boolean result = IService.class.isAssignableFrom(curClass);
        return result;
    }
}

@CompontentScan标注的类

@ComponentScan(
    useDefaultFilters = false, //不启用默认过滤器
    includeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, classes =MyFilter.class)}
)
public class ScanBean5 {
}

5、excludeFilters

十八、@Import批量注册bean

1、@Import出现的背景

问题1

问题2

2、@Import使用

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    /**
    * {@link Configuration @Configuration}, {@link ImportSelector},
    * {@link ImportBeanDefinitionRegistrar}, or regular component classes to
    import.
    */
    Class<?>[] value();
}

使用步骤

@Import的value常见的有5种用法

ImportBeanDefinitionRegistrar接口

public interface ImportBeanDefinitionRegistrar {
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
    	registerBeanDefinitions(importingClassMetadata, registry);
    }
    
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }
}

BeanDefinitionRegistry接口：bean定义注册器

public interface BeanDefinitionRegistry extends AliasRegistry {
    /**
    * 注册一个新的bean定义
    * beanName：bean的名称
    * beanDefinition：bean定义信息
    */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;
    /**
    * 通过bean名称移除已注册的bean
    * beanName：bean名称
    */
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    /**
    * 通过名称获取bean的定义信息
    * beanName：bean名称
    */
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    /**
    * 查看beanName是否注册过
    */
    boolean containsBeanDefinition(String beanName);
    /**
    * 获取已经定义（注册）的bean名称列表
    */
    String[] getBeanDefinitionNames();
    /**
    * 返回注册器中已注册的bean数量
    */
    int getBeanDefinitionCount();
    /**
    * 确定给定的bean名称或者别名是否已在此注册表中使用
    * beanName：可以是bean名称或者bean的别名
    */
    boolean isBeanNameInUse(String beanName);
}

BeanNameGenerator接口：bean名称生成器

public interface BeanNameGenerator {
	String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry);
}

value为ImportBeanDefinitionRegistrar接口类型用法（4个步骤）

public class Service1 {
}

public class Service2 {
    private Service1 service1;
    
    public Service1 getService1() {
    	return service1;
    }
    
    public void setService1(Service1 service1) {
    	this.service1 = service1;
    }
}

来个类实现ImportBeanDefinitionRegistrar接口，然后在里面实现上面2个类的注册，如下：

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //定义一个bean：Service1
        BeanDefinition service1BeanDinition = BeanDefinitionBuilder.genericBeanDefinition(Service1.class).getBeanDefinition();
        //注册bean
        registry.registerBeanDefinition("service1", service1BeanDinition);
        //定义一个bean：Service2，通过addPropertyReference注入service1
        BeanDefinition service2BeanDinition = BeanDefinitionBuilder.genericBeanDefinition(Service2.class).addPropertyReference("service1", "service1").getBeanDefinition();
        //注册bean
        registry.registerBeanDefinition("service2", service2BeanDinition);
        }
}

value为ImportSelector接口类型

public interface ImportSelector {
    /**
    * 返回需要导入的类名的数组，可以是任何普通类，配置类（@Configuration、@Bean、@CompontentScan等标注的类）
    * @importingClassMetadata：用来获取被@Import标注的类上面所有的注解信息
    */
    String[] selectImports(AnnotationMetadata importingClassMetadata);
}

public class Service1 {
}

@Configuration标注的配置类：Module1Config

@Configuration
public class Module1Config {
    @Bean
    public String name() {
    	return "公众号：路人甲java";
    }
    @Bean
    public String address() {
    	return "上海市";
    }
}

下面自定义一个ImportSelector，然后返回上面2个类的名称

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{
       		Service1.class.getName(),
        	Module1Config.class.getName()
    	};
    }
}

来个@Import标注的类，导入MyImportSelector

/**
* 通过@Import导入MyImportSelector接口实现类
*/
@Import({MyImportSelector.class})
public class MainConfig5 {
}

测试

@Test
public void test5() {
    //1.通过AnnotationConfigApplicationContext创建spring容器，参数为@Import标注的类
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig5.class);
    //2.输出容器中定义的所有bean信息
    for (String beanName : context.getBeanDefinitionNames()) {
        System.out.println(String.format("%s->%s", beanName, context.getBean(beanName)));
    }
}

部分输出如下：

com.javacode2018.lesson001.demo24.test5.Service1-
>com.javacode2018.lesson001.demo24.test5.Service1@45b4c3a9
name->公众号：路人甲java
address->上海市

DeferredImportSelector接口

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @interface Order {
	int value() default Ordered.LOWEST_PRECEDENCE;
}

3、总结

十九，@Conditional通过条件来控制bean的注册

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
	Class<? extends Condition>[] value();
}

1、Condition接口

@FunctionalInterface
public interface Condition {
    /**
    * 判断条件是否匹配
    * context:条件判断上下文
    */
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

public interface ConditionContext {
    /**
    * 返回bean定义注册器，可以通过注册器获取bean定义的各种配置信息
    */
    BeanDefinitionRegistry getRegistry();
    /**
    * 返回ConfigurableListableBeanFactory类型的bean工厂，相当于一个ioc容器对象
    */
    @Nullable
    ConfigurableListableBeanFactory getBeanFactory();
    /**
    * 返回当前spring容器的环境配置信息对象
    */
    Environment getEnvironment();
    /**
    * 返回资源加载器
    */
    ResourceLoader getResourceLoader();
    /**
    * 返回类加载器
    */
    @Nullable
    ClassLoader getClassLoader();
}

3、比较关键性的问题：Condition条件判断在什么时候执行？

什么是配置类

Spring对配置类处理过程

4、ConfigurationCondition接口

public interface ConfigurationCondition extends Condition {
    /**
    * 条件判断的阶段，是在解析配置类的时候过滤还是在创建bean的时候过滤
    */
    ConfigurationPhase getConfigurationPhase();
    /**
    * 表示阶段的枚举：2个值
    */
    enum ConfigurationPhase {
        /**
        * 配置类解析阶段，如果条件为false，配置类将不会被解析
        */
        PARSE_CONFIGURATION,
        /**
        * bean注册阶段，如果为false，bean将不会被注册
        */
        REGISTER_BEAN
    }
}

5、@Conditional使用的3步骤

6、案例

bean不存在的时候才注册

public class OnMissingBeanCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取bean工厂
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //从容器中获取IService类型bean
        Map<String, IService> serviceMap = beanFactory.getBeansOfType(IService.class);
        //判断serviceMap是否为空
        return serviceMap.isEmpty();
    }
}

根据环境选择配置类

@Conditional(EnvCondition.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnvConditional {
    //环境(测试环境、开发环境、生产环境)
    enum Env {
    TEST, DEV, PROD
    }
    //环境
    Env value() default Env.DEV;
}

@Configuration
@EnvConditional(EnvConditional.Env.TEST)
public class TestBeanConfig {
    @Bean
    public String name() {
    	return "我是测试环境!";
    }
}

开发环境配置类

@Configuration
@EnvConditional(EnvConditional.Env.DEV)
public class DevBeanConfig {
    @Bean
    public String name() {
    	return "我是开发环境!";
    }
}

生产环境配置类

@Configuration
@EnvConditional(EnvConditional.Env.PROD)
public class ProdBeanConfig {
    @Bean
    public String name() {
    	return "我是生产环境!";
    }
}

public class EnvCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //当前需要使用的环境
        EnvConditional.Env curEnv = EnvConditional.Env.DEV; // 可以修改这个改变环境
        //获取使用条件的类上的EnvCondition注解中对应的环境
        EnvConditional.Env env = (EnvConditional.Env)
        metadata.getAllAnnotationAttributes(EnvConditional.class.getName()).get("value")
        .get(0);
        return env.equals(curEnv);
    }
}

Condition指定优先级

总结

参考：路人甲-Spring系列