Spring - 通过指定环境验证注射候选者的资格

Question

编辑： 也许提出这个问题的更简洁的方法是：Spring 是否为我提供了一种通过提供自己的侦听器/工厂/决策逻辑来解决注入时不明确的候选者的方法？

---

事实上，可以说下面成员字段上的 @Environmental 限定符是不必要的：如果 @Inject-ion 不明确......让我帮忙？事实上， @ResolveWith(EnvironmentalResolver.class) 也可以。

---

当 Spring 尝试注入依赖项（使用注释）时，我知道如果我要拥有多个实现该接口的组件，我需要 @Qualifier 一个 @Inject 点。

我想做的是这样的：

class MyFoo implements Foo {
    @Inject
    @Environmental
    private Bar bar;
}

@Environmental(Environment.Production)
class ProductionBar implements Bar {
}

@Environmental({Environment.Dev, Environment.Test})
class DevAndTestBar implements Bar {
}

我希望我需要创建某种歧义解析器，它看起来（模糊地）像这样：

< code>

class EnvironmentalBeanAmbiguityResolver {

    // set from configuration, read as a system environment variable, etc.
    private Environment currentEnvironment;

    public boolean canResolve(Object beanDefinition) {
        // true if definition has the @Environmental annotation on it
    }

    public Object resolve(Collection<Object> beans) {
        for (Object bean : beans) {
            // return bean if bean @Environmental.values[] contains currentEnvironment
        }
        throw new RuntimeException(...);
    }
}

一个有用的例子是我们有一项联系最终用户的服务。现在我只有一个 AOP 方面，在方法调用“MailSender”之前，检查“生产”环境标志，如果未设置，它将向我们发送电子邮件而不是用户电子邮件。我'我不想将其包装在特定于邮件发送的 AOP 方面，而是能够根据当前环境区分服务，有时这只是“生产”或“非生产”的问题，正如我上面演示的那样，但每个环境的定义都有效 我认为这也

可以在区域中重用...例如@Regional和@Regional(Region.UnitedStates)等等，

如果你愿意的话，我想@Environmental实际上会是一个@Qualifier。直接依赖于您可以的环境（@Environmental(Production) bean 可能直接依赖于 @Environmental(Production) 协作者 - 因此对于较低级别的项目没有歧义 --- 相同@Regional(US) 项目将明确依赖于其他 @Regional(US) 项目，并且将绕过我尚未理解的 BeanAmbiguityResolver）

谢谢。

Answer 1

我想我解决了这个问题！

考虑以下情况：

public interface Ambiguity {
    public boolean isSatisfiedBy(BeanDefinitionHolder holder);
}

@Target({ METHOD, CONSTRUCTOR, FIELD })
@Retention(RUNTIME)
public @interface Ambiguous {
    Class<? extends Ambiguity> value();
}

@Target(TYPE)
@Retention(RUNTIME)
public @interface Environmental {
    public static enum Environment {
        Development, Testing, Production
    };
    Environment[] value() default {};
}

@Named
public class EnvironmentalAmbiguity implements Ambiguity {

    /* This can be set via a property in applicationContext.xml, which Spring
       can use place holder, environment variable, etc. */
    Environment env = Environment.Development;

    @Override
    public boolean isSatisfiedBy(BeanDefinitionHolder holder) {
        BeanDefinition bd = holder.getBeanDefinition();
        RootBeanDefinition rbd = (RootBeanDefinition) bd;

        Class<?> bc = rbd.getBeanClass();

        Environmental env = bc.getAnnotation(Environmental.class);

        return (env == null) ? false : hasCorrectValue(env);
    }

    private boolean hasCorrectValue(Environmental e) {
        for (Environment env : e.value()) {
            if (env.equals(this.env)) {
                return true;
            }
        }
        return false;
    }

}

@Named
public class MySuperDuperBeanFactoryPostProcessor implements
        BeanFactoryPostProcessor, AutowireCandidateResolver {

    private DefaultListableBeanFactory beanFactory;
    private AutowireCandidateResolver defaultResolver;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg)
            throws BeansException {
        if (arg instanceof DefaultListableBeanFactory) {
            beanFactory = (DefaultListableBeanFactory) arg;

            defaultResolver = beanFactory.getAutowireCandidateResolver();
            beanFactory.setAutowireCandidateResolver(this);

            return;
        }

        throw new FatalBeanException(
                "BeanFactory was not a DefaultListableBeanFactory");
    }

    @Override
    public Object getSuggestedValue(DependencyDescriptor descriptor) {
        return defaultResolver.getSuggestedValue(descriptor);
    }

    @Override
    public boolean isAutowireCandidate(BeanDefinitionHolder holder,
            DependencyDescriptor descriptor) {
        Ambiguity ambiguity = getAmbiguity(descriptor);

        if (ambiguity == null) {
            return defaultResolver.isAutowireCandidate(holder, descriptor);
        }
        return ambiguity.isSatisfiedBy(holder);
    }

    private Ambiguity getAmbiguity(DependencyDescriptor descriptor) {
        Ambiguous ambiguous = getAmbiguousAnnotation(descriptor);

        if (ambiguous == null) {
            return null;
        }

        Class<? extends Ambiguity> ambiguityClass = ambiguous.value();
        return beanFactory.getBean(ambiguityClass);
    }

    private Ambiguous getAmbiguousAnnotation(DependencyDescriptor descriptor) {
        Field field = descriptor.getField();

        if (field == null) {
            MethodParameter methodParameter = descriptor.getMethodParameter();

            if (methodParameter == null) {
                return null;
            }
            return methodParameter.getParameterAnnotation(Ambiguous.class);
        }
        return field.getAnnotation(Ambiguous.class);
    }

}

现在，如果我有一个接口 MyInterface 和两个实现它的类 MyFooInterface 和 MyBarInterface，如下所示：

public interface MyInterface {
    public String getMessage();
}

@Named
@Environmental({ Environment.Testing, Environment.Production })
public class MyTestProdInterface implements MyInterface {
    @Override
    public String getMessage() {
        return "I don't always test my code, but when I do, I do it in production!";
    }
}

@Named
@Environmental(Environment.Development)
public class DevelopmentMyInterface implements MyInterface {
    @Override
    public String getMessage() {
        return "Developers, developers, developers, developers!";
    }
}

如果我想 @Inject MyInterface 我会得到与预期相同的多个 bean 定义错误。但我可以添加@Ambigously(EnvironmentalAmbiguity.class)，然后EnvironmentalAmbiguity会告诉它满足哪个bean定义。

另一种方法是使用 List 并遍历它们，看看它们是否满足给定的 bean 定义，这意味着依赖关系不需要 @Ambigously 注释。这可能更“IoC-ish”，但我也认为它可能表现不佳。我还没有测试过。