Spring @Autowired 注解原理
1.@Autowired 使用
@ComponentScan("org.example.bean")
public class AnnoContextDemo {
@Autowired
private User user;
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnnoContextDemo.class);
User user1 = context.getBean(AnnoContextDemo.class).user;
System.out.println("user1 = " + user1);
}
}
被掃描的組件配置類
@Configuration
public class BeanConfig {
@Bean
public User user(){
return new User(21,"張三");
}
}
輸出結(jié)果
user1 = User{age=21, name='張三'}
2.依賴自動注入原理
定位@Autowired所在包 org.springframework.beans.factory.annotation.Autowired
找到同包下 AutowiredAnnotationBeanPostProcessor
AutowiredAnnotationBeanPostProcessor 的類繼承圖如下
AutowiredAnnotationBeanPostProcessor實現(xiàn)了InstantiationAwareBeanPostProcessor與
MergedBeanDefinitionPostProcessor兩個BeanPostProcessor后置處理器接口
-
MergedBeanDefinitionPostProcessor 此接口主要有兩個方法 抽象方法 postProcessMergedBeanDefinition 默認方法 resetBeanDefinition
-
InstantiationAwareBeanPostProcessor 此接口 抽象方法 postProcessBeforeInstantiation ，postProcessAfterInstantiation ，默認方法 postProcessProperties ，默認過時方法 postProcessPropertyValues
想搞清楚@Autowried注入原理，先得知道這些接口對應(yīng)方法執(zhí)行的先后順序 跟蹤ApplicationContext.refresh方法，調(diào)用鏈路如下
ApplicationContext.refresh() -> AbstractApplicationContext.finishBeanFactoryInitialization() -> ConfigurableListableBeanFactory.preInstantiateSingletons() - > AbstractBeanFactory.getBean() -> AbstractBeanFactory.doGetBean() -> AbstractBeanFactory.getSingleton() -> AbstractBeanFactory.createBean()
實例化前
-> resolveBeforeInstantiation() 執(zhí)行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()前置方法 如果返回不為null，將執(zhí)行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()后置方法。
創(chuàng)建bean實例階段
-> doCreateBean() -> createBeanInstance 反射創(chuàng)建bean實例
-> applyMergedBeanDefinitionPostProcessors() 執(zhí)行 MergedBeanDefinitionPostProcessor.MergedBeanDefinitionPostProcessor方法 合并bean定義信息
屬性注入階段
-> populateBean() -> 執(zhí)行 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 后置處理方法 -> 執(zhí)行InstantiationAwareBeanPostProcessor.postProcessProperties -> InstantiationAwareBeanPostProcessor.postProcessPropertyValues -> applyPropertyValues 執(zhí)行屬性注入
初始化階段
-> initializeBean() -> BeanPostProcessor.postProcessBeforeInitialization() 執(zhí)行前置方法 -> invokeInitMethods() 反射調(diào)用初始化方法 -> BeanPostProcessor.postProcessAfterInitialization 執(zhí)行后置方法
收尾注冊bean
->registerDisposableBeanIfNecessary() 注冊bean
通過上面追蹤refresh()方法我們可知，spring容器將先調(diào)用 AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition方法，然后執(zhí)行 postProcessProperties 方法
3. postProcessMergedBeanDefinition 查找需要自動注入的字段或方法
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}
進入findAutowiringMetadata方法
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
//查找類的字段，方法，是否有需要自動注入對象的元素，封裝InjectionMetadata
metadata = buildAutowiringMetadata(clazz);
//放入緩存中，供后面調(diào)用取出
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
進入 buildAutowiringMetadata 方法
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
//判斷當前類是否有使用autowiredAnnotationTypes容器中的注解
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
//反射遍歷類中所有字段
ReflectionUtils.doWithLocalFields(targetClass, field -> {
//字段上是否有標注自動裝配相關(guān)的注解
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
//封裝InjectionMetadata
currElements.add(new AutowiredFieldElement(field, required));
}
});
//反射遍歷類中所有方法
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
//方法上是否有標注自動裝配相關(guān)的注解
MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
//封裝InjectionMetadata
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return InjectionMetadata.forElements(elements, clazz);
}
this.autowiredAnnotationTypes 為set集合，容器內(nèi)為需要自動注入的注解類
private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>(4);
public AutowiredAnnotationBeanPostProcessor() {
## 1.@Autowired
this.autowiredAnnotationTypes.add(Autowired.class);
## 2.@Value
this.autowiredAnnotationTypes.add(Value.class);
try {
## 3.@javax.inject.Inject JSR-330規(guī)范中定義的一個注解
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
4.postProcessProperties 需要自動注入的元素從容器中獲取bean后注入
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//首先從緩存中取出需要自動注入的元素（包括字段，方法）
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//進行注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
進入 metadata.inject() 方法
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
//遍歷需要注入的元素
for (InjectedElement element : elementsToIterate) {
//不同類型調(diào)用各自inject方法
element.inject(target, beanName, pvs);
}
}
}
字段處理邏輯
通過 resolveFieldValue 方法，找到需要依賴的bean（單個或集合），通過 Filed.set方法注入
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
try {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
catch (NoSuchBeanDefinitionException ex) {
// Unexpected removal of target bean for cached argument -> re-resolve
value = resolveFieldValue(field, bean, beanName);
}
}
else {
//查找依賴的bean
value = resolveFieldValue(field, bean, beanName);
}
if (value != null) {
ReflectionUtils.makeAccessible(field);
//反射設(shè)置值
field.set(bean, value);
}
}
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
Class<?> type = descriptor.getDependencyType();
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
//字段非集合類型時bean時查找方法
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
if (matchingBeans.size() > 1) {
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
if (result instanceof NullBean) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
result = null;
}
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
return result;
}
finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
findAutowireCandidates（） 會調(diào)用 BeanFactoryUtils.beanNamesForTypeIncludingAncestors文章來源：http://www.zghlxwxcb.cn/news/detail-579069.html
底層通過類似雙親委派模型，找出所有的bean文章來源地址http://www.zghlxwxcb.cn/news/detail-579069.html
public static String[] beanNamesForTypeIncludingAncestors(
ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
Assert.notNull(lbf, "ListableBeanFactory must not be null");
String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
if (lbf instanceof HierarchicalBeanFactory) {
HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
String[] parentResult = beanNamesForTypeIncludingAncestors(
(ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
result = mergeNamesWithParent(result, parentResult, hbf);
}
}
return result;
}
到了這里，關(guān)于Spring @Autowired 注解原理的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
