给Spring中注册Bean的几种方式

@Retention(RetentionPolicy.RUNTIME)
@Target({})
@interface Filter {

    // 定义过滤类型，包括ANNOTATION、ASSIGNABLE_TYPE、ASPECTJ、REGEX和CUSTOM
    FilterType type() default FilterType.ANNOTATION;

    // 同classes
    @AliasFor("classes")
    Class<?>[] value() default {};

    // 过滤的类型，只有type为ANNOTATION、ASSIGNABLE_TYPE、CUSTOM可以定义类型
    @AliasFor("value")
    Class<?>[] classes() default {};

    // 过滤的表达式，type为ASPECTJ、REGEX可以定义表达式
    String[] pattern() default {};
}

@Configuration
@ComponentScan(basePackages = "com.belonk.componentscan")
public class BasicComponentScanConfig {
    // ……
}

@Configurable
@ComponentScan(basePackages = "com.belonk", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Controller.class)}) (1)
public class RootConfig {
    // ……
}

@Configuration
@ComponentScan(basePackages = "com.belonk", includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,
        value = Controller.class)}, useDefaultFilters = false) (1)
public class SubConfig {
    // ……
}

@FunctionalInterface
public interface TypeFilter {
    // 检查是否符合匹配规则，匹配返回true。
    // 包含两个参数: metadataReader - 当前正在扫描的类元信息, metadataReaderFactory - 可以获取其他类信息的工厂类
    boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException;
}

public class CustomTypeFilter implements TypeFilter {
    /**
     * 判断正被扫描的类是否匹配并加入到spring容器。
     *
     * @param metadataReader        当前正在扫描的类信息
     * @param metadataReaderFactory 可以获取其他类信息的工厂类
     * @return true则匹配，加入Spring容器，false则排除
     */
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        // 被扫描类上的注解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 被扫描的类的类元信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 被扫描的类的资源信息，如类文件路径
        Resource resource = metadataReader.getResource();
        // 通过上边三个信息来定义扫描规则

        // 被扫描的class类名包含user，则会被扫描到
        if (classMetadata.getClassName().contains("user") || classMetadata.getClassName().contains("User")) {
            return true;
        }
        return false;
    }
}

@Configuration
@ComponentScan(basePackages = "com.belonk.componentscan",
        // 定义按照类型过滤规则, 只会扫描实现了MyFilter接口的bean
        includeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, classes = CustomTypeFilter.class)}, useDefaultFilters = false
)
public class CustomFilterConfig {
    // ……
}

@Import(value = {Cat.class, Dog.class}

public interface ImportSelector {

    // 设置需要导入的类名称，importingClassMetadata参数为被导入的类上的注解信息
    String[] selectImports(AnnotationMetadata importingClassMetadata);
}

public class AnimalImportSelector implements ImportSelector {
    /**
     * 导入多个类
     *
     * @param importingClassMetadata 被导入的类上的注解信息
     * @return 导入的类全类名
     */
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 根据importingClassMetadata做一些条件判断，实现具体的业务逻辑
        return new String[]{"com.belonk.imports.bean.Fox", "com.belonk.imports.bean.Tiger"};
    }
}

@Import(value = {AnimalImportSelector.class})

public interface ImportBeanDefinitionRegistrar {

    // 根据注解元数据注册bean定义, 支持自定义beanName生成器
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
            BeanNameGenerator importBeanNameGenerator) {
        registerBeanDefinitions(importingClassMetadata, registry);
    }

    /**
     * 使用BeanDefinitionRegistry来向IOC容器注册或者移除bean。
     *
     * @param importingClassMetadata 当前类的注解信息
     * @param registry               bean注册表
     */
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }
}

public class AnimalImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 主要容器中注册了Fox和Tiger，那就再注册一个Zoo类
        if (registry.containsBeanDefinition("com.belonk.imports.bean.Fox")
                && registry.containsBeanDefinition("com.belonk.imports.bean.Tiger")) {
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Zoo.class);
            registry.registerBeanDefinition("zoo", beanDefinition);
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="forXml" class="com.belonk.imports.bean.ForXml"> (1)
        <property name="tag" value="1.0"/>
    </bean>
</beans>

@ImportResource(locations = {"classpath:beans.xml"})