接口定義
用於推斷一個特定的beanDefinition是否能作爲指定依賴的候選者的策略接口
public interface AutowireCandidateResolver {
// 默認情況下直接根據bd中的定義返回，如果沒有進行特殊配置的話爲true
default boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
return bdHolder.getBeanDefinition().isAutowireCandidate();
}
// 指定的依賴是否是必要的
default boolean isRequired(DependencyDescriptor descriptor) {
return descriptor.isRequired();
}
// QualifierAnnotationAutowireCandidateResolver做了實現，判斷是否有@Qualifier註解
// 一共有兩種註解：
// 1.Spring內置的@Qualifier註解，org.springframework.beans.factory.annotation.Qualifier
// 2.添加了JSR-330相關依賴，javax.inject.Qualifier註解
// 默認情況下返回false
default boolean hasQualifier(DependencyDescriptor descriptor) {
return false;
}
// QualifierAnnotationAutowireCandidateResolver做了實現
// 獲取一個該依賴一個建議的值
@Nullable
default Object getSuggestedValue(DependencyDescriptor descriptor) {
return null;
}
// 對某個依賴我們想要延遲注入，但是在創建Bean的過程中這個依賴又是必須的
// 通過下面這個方法就能爲延遲注入的依賴先生成一個代理注入到bean中
@Nullable
default Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
return null;
}
}
繼承關係
可以看到繼承關係都是單層的，我們就一個一個往下看
SimpleAutowireCandidateResolver
相比於接口沒有什麼區別，實現也就是父接口中的默認實現，一般也不會使用這個類
public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
return bdHolder.getBeanDefinition().isAutowireCandidate();
}
@Override
public boolean isRequired(DependencyDescriptor descriptor) {
return descriptor.isRequired();
}
@Override
@Nullable
public Object getSuggestedValue(DependencyDescriptor descriptor) {
return null;
}
@Override
@Nullable
public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
return null;
}
}
GenericTypeAwareAutowireCandidateResolver
額外增加了對泛型的處理能力
public class GenericTypeAwareAutowireCandidateResolver extends SimpleAutowireCandidateResolver
implements BeanFactoryAware {
@Nullable
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Nullable
protected final BeanFactory getBeanFactory() {
return this.beanFactory;
}
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
if (!super.isAutowireCandidate(bdHolder, descriptor)) {
// 如果bd中已經配置了這個bean不做爲依賴進行注入的話，直接返回false
return false;
}
// 檢查泛型是否匹配
return checkGenericTypeMatch(bdHolder, descriptor);
}
}
QualifierAnnotationAutowireCandidateResolver
增加了對@Qualifier註解以及@Value註解的處理能力
public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {
private final Set<Class<? extends Annotation>> qualifierTypes = new LinkedHashSet<>(2);
// @Value註解
private Class<? extends Annotation> valueAnnotationType = Value.class;
// @Qualifier註解
@SuppressWarnings("unchecked")
public QualifierAnnotationAutowireCandidateResolver() {
this.qualifierTypes.add(Qualifier.class);
try {
this.qualifierTypes.add((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Qualifier",
QualifierAnnotationAutowireCandidateResolver.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
// .......
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
// 類型上已經匹配了
boolean match = super.isAutowireCandidate(bdHolder, descriptor);
if (match) {
// 還需要判斷是否滿足@Qualifier註解的要求
match = checkQualifiers(bdHolder, descriptor.getAnnotations());
if (match) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
Method method = methodParam.getMethod();
if (method == null || void.class == method.getReturnType()) {
match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
}
}
}
}
return match;
}
// .....
// 是否是@Qualifier註解
protected boolean isQualifier(Class<? extends Annotation> annotationType) {
for (Class<? extends Annotation> qualifierType : this.qualifierTypes) {
if (annotationType.equals(qualifierType) || annotationType.isAnnotationPresent(qualifierType)) {
return true;
}
}
return false;
}
@Override
@Nullable
public Object getSuggestedValue(DependencyDescriptor descriptor) {
Object value = findValue(descriptor.getAnnotations());
if (value == null) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
value = findValue(methodParam.getMethodAnnotations());
}
}
return value;
}
// 查找@Value註解
@Nullable
protected Object findValue(Annotation[] annotationsToSearch) {
if (annotationsToSearch.length > 0) {
AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
if (attr != null) {
return extractValue(attr);
}
}
return null;
}
// 獲取@Value註解中的值
protected Object extractValue(AnnotationAttributes attr) {
Object value = attr.get(AnnotationUtils.VALUE);
if (value == null) {
throw new IllegalStateException("Value annotation must have a value attribute");
}
return value;
}
}
ContextAnnotationAutowireCandidateResolver
這個類是最底層的子類，集成了所有的方法，並且額外提供了對依賴進行延遲處理的能力
public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotationAutowireCandidateResolver {
// 如果依賴需要進行延遲處理，那麼構建一個代理對象先注入到bean中，不會直接去創建依賴對象
@Override
@Nullable
public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
}
// 依賴是否需要延遲處理
protected boolean isLazy(DependencyDescriptor descriptor) {
for (Annotation ann : descriptor.getAnnotations()) {
Lazy lazy = AnnotationUtils.getAnnotation(ann, Lazy.class);
if (lazy != null && lazy.value()) {
return true;
}
}
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
Method method = methodParam.getMethod();
if (method == null || void.class == method.getReturnType()) {
Lazy lazy = AnnotationUtils.getAnnotation(methodParam.getAnnotatedElement(), Lazy.class);
if (lazy != null && lazy.value()) {
return true;
}
}
}
return false;
}
// 構建延遲處理的代理對象
protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
// 創建了一個TargetSource
TargetSource ts = new TargetSource() {
@Override
public Class<?> getTargetClass() {
return descriptor.getDependencyType();
}
@Override
public boolean isStatic() {
return false;
}
// target是我們實際想要使用的對象，如果不進行延遲處理，那麼注入到bean中的應該就是這個對象
// 但是因爲要進行延遲注入依賴，所有會向外暴露一個TargetSource，這個TargetSource的目標爲實際想要使用的對象，生成代理時會基於TargetSource進行生成。在運行期間（完成注入後）我們使用這個延遲處理的依賴時實際調用的會是target中的方法。
@Override
public Object getTarget() {
Object target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
if (target == null) {
Class<?> type = getTargetClass();
if (Map.class == type) {
return Collections.emptyMap();
}
else if (List.class == type) {
return Collections.emptyList();
}
else if (Set.class == type || Collection.class == type) {
return Collections.emptySet();
}
throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
"Optional dependency not present for lazy injection point");
}
return target;
}
@Override
public void releaseTarget(Object target) {
}
};
// 使用ProxyFactory，給TargetSource生成一個代理
ProxyFactory pf = new ProxyFactory();
pf.setTargetSource(ts);
Class<?> dependencyType = descriptor.getDependencyType();
// 如果依賴的類型是一個接口，需要讓代理類也實現這個接口
if (dependencyType.isInterface()) {
pf.addInterface(dependencyType);
}
// 生成代理
return pf.getProxy(beanFactory.getBeanClassLoader());
}
}
總結
- SimpleAutowireCandidateResolver：單純的將接口變成了可實例化的類，方法實現跟接口保持一致
- GenericTypeAwareAutowireCandidateResolver： 判斷泛型是否匹配，支持泛型依賴注入（From Spring4.0）
- QualifierAnnotationAutowireCandidateResolver ：處理 @Qualifier 和 @Value 註解
- ContextAnnotationAutowireCandidateResolver ：處理依賴級別的 @Lazy 註解，重寫了getLazyResolutionProxyIfNecessary 方法。