作用

1. 过滤自动配置类 允许开发者根据特定条件过滤掉不需要的自动配置类，从而精确控制应用程序的配置;

2. 解决冲突 当某些自动配置类与应用中其他配置发生冲突时，可以通过自定义过滤器来排除冲突的自动配置类；

3. 提高启动性能 排除不需要的自动配置类可以减少应用程序的启动时间，提高应用的性能。

AutoConfigurationImportFilter接口的实现类会在Spring Boot应用启动时被Spring Boot框架调用。框架会遍历所有的spring.factories文件中定义的AutoConfigurationImportFilter实现类，并调用它们的match方法。在该方法中，开发者可以根据自定义的逻辑来决定是否包含或排除特定的自动配置类。最终，只有符合过滤条件的自动配置类才会被导入到应用程序的Spring上下文中。

使用方法：

1 自定义过滤器

MyAutoConfigurationFilter.java

import org.springframework.boot.autoconfigure.AutoConfigurationImportFilter;
import org.springframework.boot.autoconfigure.AutoConfigurationMetadata;

public class MyAutoConfigurationFilter implements AutoConfigurationImportFilter {

    @Override
    public boolean[] match(String[] autoConfigurationClasses, AutoConfigurationMetadata metadata) {
        boolean[] matches = new boolean[autoConfigurationClasses.length];
        for (int i = 0; i < autoConfigurationClasses.length; i++) {
            String autoConfigurationClass = autoConfigurationClasses[i];
            // 根据自定义的条件判断是否需要排除该自动配置类
            if (autoConfigurationClass.equals("org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration")) {
                matches[i] = false; // 排除 DataSourceAutoConfiguration
            } else {
                matches[i] = true;
            }
        }
        return matches;
    }
}

2 在spring.factories中配置过滤器

在META-INF/spring.factories文件中配置自定义的过滤器。
META-INF/spring.factories

org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=com.example.demo.MyAutoConfigurationFilter

3 应用启动类

MyApplication.java

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

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

TypeExcludeFilter是Spring boot提供的一种机制，用于在测试中排除某些类型的Bean。这在大型应用程序中非常有用，可以防止某些bean在测试中被加载，从而加快测试速度或比年冲突。

使用方法：

1 创建一个自定义的TypeExcludeFilter

MyTypeExcludeFilter.java这个过滤器将制定哪些类型的bean应该被排除。

import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.stereotype.Component;

@Component
public class MyTypeExcludeFilter extends TypeExcludeFilter {

    @Override
    public boolean match(AnnotatedTypeMetadata metadata) {
        // 在这里定义需要排除的bean的逻辑
        String className = metadata.getClassName();
        // 例如，排除所有 MyExcludedService 类型的 bean
        return className.equals("com.example.demo.MyExcludedService");
    }
}

2 创建要排除的服务类

创建一个简单的服务类，该服务类将在测试中被排除。

MyExcludedService.java

package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class MyExcludedService {
    public void doSomething() {
        System.out.println("This service should be excluded in tests.");
    }
}

3 在测试中使用自定义的TypeExcludeFilter

在测试类中，我们需要将自定义的TypeExcludeFilter注册到Spring Boot测试上下文中。

MyApplicationTests.java

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.FilterType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.boot.test.autoconfigure.filter.TypeExcludeFilters;

@SpringBootTest
@ContextConfiguration(classes = MyApplication.class)
@TypeExcludeFilters(MyTypeExcludeFilter.class)
public class MyApplicationTests {

    @Test
    public void contextLoads() {
        // 测试内容
    }
}

4 代码结构

src
├── main
│   └── java
│       └── com
│           └── example
│               └── demo
│                   ├── MyApplication.java
│                   ├── MyExcludedService.java
│                   └── MyTypeExcludeFilter.java
└── test
    └── java
        └── com
            └── example
                └── demo
                    └── MyApplicationTests.java

MyApplication.java

package com.example.demo;

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

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

5 测试

当运行 MyApplicationTests 时，MyExcludedService 将不会被加载到 Spring 上下文中。这可以通过在 MyExcludedService 中添加一些输出语句并观察控制台输出来验证。

使用 TypeExcludeFilter 可以在测试中排除特定类型的 bean，从而简化测试环境，减少不必要的依赖，提高测试的速度和稳定性。通过自定义 TypeExcludeFilter，可以灵活地控制哪些 bean 需要被排除，非常适合复杂的应用场景。

接口定义

public interface ImportSelector {
    String[] selectImports(AnnotationMetadata importingClassMetadata);
}

参数AnnotationMetadata：表示使用了@Import注解的类的元数据，方法返回一个字符串数组，每个字符串对应一个需要导入的配置类的全限定名。

作用过程 当Spring boot启动时，它会扫描到使用了@Import注解的类，ImportSelector会根据传入的元数据决定需要导入的配置类，并将这些类注册到Spring上下文中。

应用场景

1. 当基于条件(如环境变量、JVM系统属性等)动态导入配置类时；
2. 在创建自定义的启动注解（如@EnableSomeFuture）时，通过ImportSelector来导入现骨干的配置类；
3. Spring框架本身在多个地方使用ImportorSelector来简化客户端的配置负担，如@EnableAsync、@EnableScheduling。

示例

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 基于条件选择配置类
        String prop = System.getProperty("myProp");
        if ("someValue".equals(prop)) {
            return new String[]{MyConfig1.class.getName()};
        } else {
            return new String[]{MyConfig2.class.getName()};
        }
    }
}

@Configuration
public class MyConfig1 {
    @Bean
    public AppBean appBean() {
        return new AppBean("from config 1");
    }
}

@Configuration
public class MyConfig2 {
    @Bean
    public AppBean appBean() {
        return new AppBean("from config 2");
    }
}

public class AppBean {
    private String message;
    public AppBean(String message) {
        this.message = message;
    }
    public String getMessage() {
        return message;
    }
}

@Configuration
@Import(MyImportSelector.class)
public class MainConfig {
    // 主配置类
}