Spring：没有限定符的自动连线豆

Question

有可能在Spring自动连接没有给定限定符的bean吗？用例将是所有bean的列表，但排除一个：

@Autowired
@NotQualifier("excludedBean")    // <-- can we do something like this?
List<SomeBean> someBeanList;


public class Bean1 implements SomeBean {}

public class Bean2 implements SomeBean {}

@Qualifier("excludedBean")
public class Bean3 implements SomeBean {}

在上面的例子中，someList 应该包含 Bean1 和 Bean2 的实例，但不包含 Bean3。

（备注：我知道相反的效果，即向Bean1和Bean2添加一些限定符，然后使用该限定符自动连接。）

编辑：一些进一步的澄清：

• 所有豆子都在Spring环境中（也被排除在外）。
• 配置需要基于注释，而不是基于 xml。因此，例如关闭自动连线候选不起作用。
• 通常必须保持 Bean 的自动连线功能。换句话说，我想从注入点列表中排除豆子




Answer 1

可能有两种情况：

案例1：Bean3不在Spring环境中；

情况 2 ： Bean3 在 Spring 上下文中，但在某些情况下没有注入 @Autowired，

>

如果需要从上下文中排除带有限定符的bean，请使用

< li >条件。如果matches返回false，则此bean未在应用程序conxtet中注册。结果:

@ Autowired List someBeanList-此处注入了SomeBean的所有Bean实例，并在应用程序上下文中注册。

来自spring api

条件注册组件时必须匹配的单个条件。在bean-definition将要注册之前，会立即检查条件，并且可以根据当时确定的任何标准自由否决注册。

带限定符的自动连线：

2.1如果您想从某些bean/bean和xml配置中的自动连接值中排除带有some限定符的bean，您可以使用autowire-candidate

2.2还可以通过Setter Injection获取所有自动关联的值，并只过滤所需的bean。

//no Autowired. Autowired in method
 private List<ParentBean> someBeen = new ArrayList<>();

 @Autowired
 public void setSomeBeen(List<ParentBean> beens){
     // if you use java 8 use stream api
     for (ParentBean bean:beens) {                 
         Qualifier qualifier = bean.getClass().getAnnotation(Qualifier.class);
         if(qualifier == null ||!qualifier.value().equals("excludedBean")){
             someBeen.add(bean);
         }
     }
 }

2.3 您可以使用自定义自动连线注释BeanPostProcessor:)如果您需要一些真正的定制，请根据您的要求定制@Autowired。

来自spring API AutowiredAnnotationBeanPostProcessor:

注意：默认的AutowiredAnnotationBeanPostProcessor将由“context:annotationconfig”和“context:componentscan”XML标记注册。如果要指定自定义AutowiredAnnotationBeanPostProcessorbean定义，请删除或关闭默认注释配置。

Answer 2

要点它的bean for exclude在上下文中，但没有注入到某些带有exclude条件的情况中。

您可以使用自定义annotaion和BeanPostProcessor排除带有限定符的bean。(我是以简单的bean类型集合为例，但是您可以扩展它)

排除的注释:

@Component
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcludeBeanByQualifierForCollectionAutowired {

    String qualifierToExcludeValue();

    Class<?> aClass();
}

带注射的豆后处理器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;

@Component
public class ExcludeAutowiredBeanPostProcessor implements BeanPostProcessor {

    @Autowired
    private ConfigurableListableBeanFactory configurableBeanFactory;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            ExcludeBeanByQualifierForCollectionAutowired myAutowiredExcludeAnnotation = field.getAnnotation(ExcludeBeanByQualifierForCollectionAutowired.class);
            if (myAutowiredExcludeAnnotation != null) {

                Collection<Object> beanForInjection = new ArrayList<>();

                String[] beanNamesOfType = configurableBeanFactory.getBeanNamesForType(myAutowiredExcludeAnnotation.aClass());
                for (String injectedCandidateBeanName : beanNamesOfType) {

                    Object beanCandidate = configurableBeanFactory.getBean(injectedCandidateBeanName);

                    Qualifier qualifierForBeanCandidate = beanCandidate.getClass().getDeclaredAnnotation(Qualifier.class);

                    if (qualifierForBeanCandidate == null || !qualifierForBeanCandidate.value().equals(myAutowiredExcludeAnnotation.qualifierToExcludeValue())) {
                        beanForInjection.add(beanCandidate);
                    }
                }
                try {
                    field.set(bean, beanForInjection);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

        return bean;
    }


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

例如:

public class ParentBean {}

public class Bean1Included extends ParentBean {}

public class Bean2Included extends ParentBean {}

public class Bean3Included extends ParentBean {}

@Qualifier("excludedBean")
public class BeanExcluded extends ParentBean {}

组态

@Configuration
public class BeanConfiguration {

    @Bean
    public Bean1Included getBean1(){
        return new Bean1Included();
    }

    @Bean
    public Bean2Included getBean2(){
        return new Bean2Included();
    }

    @Bean
    public Bean3Included getBean3(){
        return new Bean3Included();
    }

    @Bean
    public BeanExcluded getExcludedBean(){
        return new BeanExcluded();
    }

    @Bean
    public ExcludeAutowiredBeanPostProcessor excludeAutowiredBeanPostProcessor(){
        return new ExcludeAutowiredBeanPostProcessor();
    }
}

和结果：

@ExtendWith(SpringExtension.class) // assumes Junit 5
@ContextConfiguration(classes = BeanConfiguration.class)
public class ExcludeConditionTest {

    @Autowired
    private ApplicationContext context;
    @Autowired
    private BeanExcluded beanExcluded;
    @ExcludeBeanByQualifierForCollectionAutowired(qualifierToExcludeValue = "excludedBean" , aClass = ParentBean.class)
    private List<ParentBean> beensWithoutExclude;

    @Test
    void should_not_inject_excluded_bean() {
        assertThat(context.getBeansOfType(ParentBean.class).values())
                .hasOnlyElementsOfTypes(Bean1Included.class,
                                        Bean2Included.class,
                                        Bean3Included.class,
                                        BeanExcluded.class);

        assertThat(beansWithoutExclude)
                .hasOnlyElementsOfTypes(Bean1Included.class,
                                        Bean2Included.class,
                                        Bean3Included.class)
                .doesNotHaveAnyElementsOfTypes(BeanExcluded.class);

        assertThat(beanExcluded).isNotNull();
    }
}

Answer 3

您可以使用元注解@条件和@Qualifier引入您自己的注解

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
@Conditional(MyCondition.class)
public @interface ExcludeBean {

然后介绍可以执行条件逻辑的类

public class MyCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return !metadata.equals(ExcludeBean.class);
    }

}

在配置类中

  @Bean
  @ExcludeBean
  public BeanA beanA() {
      return new BeanA();
  }

您还可以通过在特定bean上设置autowire candidate或指定defaultautowirecandidates=“listofcandidatehere”来将bean排除为自动布线的候选对象