如何在春季注入基于类型安全限定符的豆类类型映射?

Question

请参阅下面的示例，我正在尝试获取TypedService豆的Map，但我宁愿键是TypeSafeQualifier中指定的Type枚举值，而不是不安全的String"serviceName"。

package org.test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Service;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.util.Map;
import static org.test.Application.Type.ONE;
import static org.test.Application.Type.TWO;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
@SpringBootApplication
public class Application {
@Autowired
Map<String, TypedService> works;
@Autowired
Map<Type, TypedService> fails;
public static void main(String [] args) {
SpringApplication.run(Application.class, args);
}
public enum Type {
ONE,
TWO
}
@Target({TYPE, METHOD, FIELD, CONSTRUCTOR})
@Retention(RUNTIME)
@Qualifier
public @interface TypeSafeQualifier {
Type value();
}
public interface TypedService {
void startSignup();
void activate();
}
@Service
@TypeSafeQualifier(ONE)
public class TypeOneService implements TypedService {
@Override
public void startSignup() {
}
@Override
public void activate() {
}
}
@Service
@TypeSafeQualifier(TWO)
public class TypeTwoService implements TypedService {
@Override
public void startSignup() {
}
@Override
public void activate() {
}
}
}

春季启动版本：springBootVersion=1.5.3.RELEASE

Answer 1

Spring 提供了一种特殊的方法来处理这种类型的注入：AutowireCandidateResolver。

在您的情况下，代码可能是：

package org.test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.util.LinkedHashMap;
import java.util.Map;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
@SpringBootApplication
public class Application {
@Autowired
Map<String, TypedService> works;
@Autowired
Map<Type, TypedService> fails;
@PostConstruct
private void init() {
System.out.println(fails);
}
public static void main(String[] args) {
final SpringApplication application = new SpringApplication(Application.class);
application.addInitializers(context -> {
context.addBeanFactoryPostProcessor(beanFactory -> {
final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;
dlbf.setAutowireCandidateResolver(new MyAutowireCandidateResolver(dlbf));
});
});
application.run(args);
}
@QualifierValue(TypeSafeQualifier.class)
public enum Type {
ONE,
TWO
}
@Target({TYPE, METHOD, FIELD, CONSTRUCTOR})
@Retention(RUNTIME)
@Qualifier
public @interface TypeSafeQualifier {
Type value();
}
public interface TypedService {
void startSignup();
void activate();
}
@Service
@TypeSafeQualifier(Type.ONE)
public class TypeOneService implements TypedService {
@Override
public void startSignup() {
}
@Override
public void activate() {
}
}
@Target({TYPE})
@Retention(RUNTIME)
public @interface QualifierValue {
Class<? extends Annotation> value();
}
@Service
@TypeSafeQualifier(Type.TWO)
public class TypeTwoService implements TypedService {
@Override
public void startSignup() {
}
@Override
public void activate() {
}
}
private static class MyAutowireCandidateResolver extends ContextAnnotationAutowireCandidateResolver {
private final DefaultListableBeanFactory beanFactory;
private MyAutowireCandidateResolver(DefaultListableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public Object getSuggestedValue(DependencyDescriptor descriptor) {
final Object result = super.getSuggestedValue(descriptor);
if (result != null) {
return result;
}
if (descriptor.getDependencyType() != Map.class) {
return null;
}
final ResolvableType dependencyGenericType = descriptor.getResolvableType().asMap();
final ResolvableType[] typeParams = dependencyGenericType.getGenerics();
final QualifierValue qualifierValue = typeParams[0].getRawClass().getAnnotation(QualifierValue.class);
if (qualifierValue == null) {
return null;
}
final String[] candidateBeanNames = beanFactory.getBeanNamesForType(typeParams[1]);
final LinkedHashMap<Object, Object> injectedMap = new LinkedHashMap<>(candidateBeanNames.length);
for (final String candidateBeanName : candidateBeanNames) {
final Annotation annotation = beanFactory.findAnnotationOnBean(candidateBeanName, qualifierValue.value());
if (annotation == null) {
continue;
}
final Map<String, Object> annotationAttributes = AnnotationUtils.getAnnotationAttributes(annotation, false);
final Object value = annotationAttributes.get("value");
if (value == null || value.getClass() != typeParams[0].getRawClass()) {
continue;
}
injectedMap.put(value, beanFactory.getBean(candidateBeanName));
}
return injectedMap;
}
}
}

首先，我们添加 TypeQualifierValue 注释，让 Spring 知道具有给定类型值的限定符。

第二种是在main方法中自定义SpringApplication：我们使用BeanFactoryPostProcessor来设置一个自定义的AutowireCandidate Resolver。

最后一步：我们编写MyAutowireCandidate Resolver扩展ContextAnnotationAutowireCandidate Resolver(委托而不是继承是适用的，它甚至更好一点，因为有一天Spring可以默认迁移到"YetAnotherAutowireCandidate Resolver"(。

这里的关键部分是被覆盖的getSuggestedValue方法：在这里，我们可以考虑依赖项的泛型类型(字段、方法参数(来自定义注入逻辑，并通过应用来自 BeanFactory 的一些类似getBean...的方法和 SpringAnnotationUtils类的一些魔力。