如何为Spring Qualifier实现OR逻辑以注入指定Bean集合？

这个问题确实戳中了Spring默认Qualifier匹配的局限性——默认的AND逻辑有时候满足不了我们的灵活需求，下面我给你一步步解决这个问题：

你的现有场景回顾 #

Bean定义代码 #

@Qualifier1 @Qualifier2 @Bean
public MyBean bean1(){...}
@Qualifier2 @Qualifier3 @Bean
public MyBean bean2(){...}
@Qualifier1 @Qualifier2 @Qualifier3 @Bean
public MyBean bean3(){...}
@Qualifier3 @Bean
public MyBean bean4(){...}
@Qualifier1 @Bean
public MyBean bean5(){...}

注入需求 #

你在注入点同时标注了@Qualifier2和@Qualifier3：

@Qualifier2 @Qualifier3 @Autowired
private List<MyBean> beans;

默认情况下Spring会对多个@Qualifier采用AND逻辑，只会注入同时拥有这两个注解的bean2和bean3，但你需要改成OR逻辑，只要拥有@Qualifier2或@Qualifier3的Bean（也就是bean1、bean2、bean3、bean4）都被注入。

实现OR逻辑的具体方案 #

因为Spring没有直接提供OR逻辑的Qualifier支持，我们需要自定义Autowire候选解析器来修改匹配规则，结合你提到的自定义Qualifier元注解来实现：

步骤1：确认自定义Qualifier元注解 #

首先确保你已经正确创建了各个Qualifier元注解（因为@Qualifier不能重复使用，所以必须用元注解的方式）：

@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Qualifier1 { }

@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Qualifier2 { }

@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Qualifier3 { }

步骤2：自定义Autowire候选解析器 #

创建一个继承自QualifierAnnotationAutowireCandidateResolver的子类，重写checkQualifiers方法，实现OR逻辑的匹配规则：

import org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.core.annotation.AnnotationUtils;

import java.lang.annotation.Annotation;
import java.util.Set;

public class OrQualifierResolver extends QualifierAnnotationAutowireCandidateResolver {

    // 指定需要用OR逻辑匹配的Qualifier注解类型
    private static final Set<Class<? extends Annotation>> OR_QUALIFIERS = Set.of(Qualifier2.class, Qualifier3.class);

    @Override
    protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
        // 先获取注入点上的所有Qualifier注解
        Annotation[] qualifiers = descriptor.getAnnotationsByType(Qualifier.class);
        if (qualifiers.length == 0) {
            return super.checkQualifiers(bdHolder, descriptor);
        }

        // 判断当前Bean是否拥有OR_QUALIFIERS中的任意一个注解
        boolean matchesOrCondition = OR_QUALIFIERS.stream()
                .anyMatch(qualifierType -> AnnotationUtils.findAnnotation(bdHolder.getBeanDefinition().getBeanClass(), qualifierType) != null);

        // 如果满足OR条件，直接返回true；否则沿用默认的AND逻辑
        if (matchesOrCondition) {
            return true;
        }

        // 其他Qualifier组合依然使用默认的AND逻辑匹配
        return super.checkQualifiers(bdHolder, descriptor);
    }
}

步骤3：注册自定义解析器 #

把自定义的解析器注册到Spring容器中，让Spring使用它来处理Qualifier匹配：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;

@Configuration
public class QualifierConfig {

    @Bean
    public AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor() {
        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        // 设置我们自定义的Qualifier解析器
        processor.setAutowireCandidateResolver(new OrQualifierResolver());
        return processor;
    }
}

更灵活的扩展方案（可选） #

如果需要更通用的OR逻辑支持（比如不同注入点可以指定不同的OR组合），可以自定义一个@QualifierOr注解，让注入点明确指定哪些Qualifier用OR逻辑：

自定义@QualifierOr注解

@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface QualifierOr {
    // 允许指定多个需要OR匹配的Qualifier注解类型
    Class<? extends Annotation>[] value();
}

修改解析器支持@QualifierOr

更新OrQualifierResolver的checkQualifiers方法，添加对@QualifierOr的识别：

import org.springframework.core.annotation.AnnotationUtils;
import java.util.Arrays;

// 在原方法中添加这段逻辑
@Override
protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    // 先检查是否有@QualifierOr注解
    QualifierOr qualifierOr = descriptor.getAnnotation(QualifierOr.class);
    if (qualifierOr != null) {
        Class<? extends Annotation>[] orQualifiers = qualifierOr.value();
        // 判断Bean是否拥有任意一个指定的Qualifier
        return Arrays.stream(orQualifiers)
                .anyMatch(qualifierType -> AnnotationUtils.findAnnotation(bdHolder.getBeanDefinition().getBeanClass(), qualifierType) != null);
    }

    // 剩下的逻辑沿用之前的默认处理或自定义AND逻辑
    return super.checkQualifiers(bdHolder, descriptor);
}

使用@QualifierOr注入

此时你的注入点可以写成这样，明确指定OR逻辑的Qualifier组合：

@QualifierOr({Qualifier2.class, Qualifier3.class})
@Autowired
private List<MyBean> beans;

这种方式不需要硬编码指定固定的Qualifier组合，灵活性更高。

内容的提问来源于stack exchange，提问作者gstackoverflow