?關于Autowired這是spring內(nèi)部的自帶的依賴注入的標簽碎绎，可以用在構造函數(shù)、字段栖榨、setter方法或者配置方法上纵柿。作用是將我們需要注入的對象由Spring自動注入到目標對象中。Autowired標簽的解析邏輯主要在AutowiredAnnotationBeanPostProcessor類中鸯绿，而除了Autowired標簽還有Value標簽以及JSR-330規(guī)范的Inject標簽的解析也在這個里面跋破。下面進行分析。
1.AutowiredAnnotationBeanPostProcessor何時實例化的
1.傳統(tǒng)的spring用xml的配置方式下的實例化
?這里要先說明一下瓶蝴，如果是傳統(tǒng)的Spring的web.xml+spring.xml配置的形式來管理Bean的話毒返，AutowiredAnnotationBeanPostProcessor是不會被實例化的。因為這個時候系統(tǒng)默認初始化的web上下文子類是XmlWebApplicationContext舷手，關于為什么是這個類可以看Spring如何在Tomcat啟動的時候啟動的這篇文章拧簸，這里繼續(xù)往下
在XmlWebApplicationContext類中調(diào)用實現(xiàn)的loadBeanDefinitions方法的邏輯中并不會涉及到AnnotatedBeanDefinitionReader類（后面會講到），而在AnnotatedBeanDefinitionReader中又與注冊AutowiredAnnotationBeanPostProcessor類相關的步驟男窟。
?如果就用xml配置bean卻不允許用注解注入肯定是不行的盆赤，所以我們一般會在spring的xml文件中加入這一的標簽
<context:annotation-config/>
或者
<context:component-scan>
?這里說明一下component-scan中有一個annotation-config屬性這個屬性默認是true表示開啟注解配置。上面兩個標簽對呀的解析處理類不同蝎宇，這里關于spring的xml文件解析就不再講解了弟劲，可以參考前面的Spring源碼解析——容器的基礎XmlBeanFactory
等文章進行了解，這里直接介紹這兩個標簽的處理類
1. 處理<context:annotation-config/>的AnnotationConfigBeanDefinitionParser
?AnnotationConfigBeanDefinitionParser類是用來處理<context:annotation-config/>標簽的姥芥，這個類中主要就是注冊處理注解注入相關的類
public BeanDefinition parse(Element element, ParserContext parserContext) {
Object source = parserContext.extractSource(element);
// 獲取所有的注解注入相關的beanpostprocessor的bean定義
Set<BeanDefinitionHolder> processorDefinitions =
AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(), source);
//注冊一個CompositeComponentDefinition，將xml的配置信息保存進去
CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
parserContext.pushContainingComponent(compDefinition);
// 將上面獲取的Bean保存到解析的上下文對象中
for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
parserContext.registerComponent(new BeanComponentDefinition(processorDefinition));
}
//最后將保存的bean注冊到復合組件汇鞭。
parserContext.popAndRegisterContainingComponent();
return null;
}
其中關鍵的步驟是AnnotationConfigUtils類的registerAnnotationConfigProcessors方法凉唐，這里后面一起說庸追。
2. 處理<context:component-scan/>的ComponentScanBeanDefinitionParser
?ComponentScanBeanDefinitionParser的邏輯還是比較多的，因為繼承了BeanDefinitionParser所以直接看對應的parse方法台囱，關于BeanDefinitionParser可以看看前面的Spring源碼解析——自定義標簽的使用了解淡溯。這里看代碼
public BeanDefinition parse(Element element, ParserContext parserContext) {
......
//注冊組件
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
&msp;代碼中省略的部分前面代碼省略，主要就是獲取<context:component-scan/>的base-package屬性然后掃描并獲取候選Bean并保存到BeanDefinitionHolder集合的對象中簿训。這里主要看registerComponents方法咱娶。
protected void registerComponents(
XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {
//獲取<context:component-scan/>標簽的源信息
Object source = readerContext.extractSource(element);
//將上面的源信息保存包以<context:component-scan/>標簽的tag為名稱的CompositeComponentDefinition對象中
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
//將前面獲取到的候選Bean以此丟到compositeDef中
for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
}
boolean annotationConfig = true;
if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
annotationConfig = Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
}
//如果component-scan標簽中包含annotation-config屬性并且值為true，則調(diào)用AnnotationConfigUtils的registerAnnotationConfigProcessors將注解配置相關的postprocessor保存到compositeDef中
if (annotationConfig) {
Set<BeanDefinitionHolder> processorDefinitions =
AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
}
}
readerContext.fireComponentRegistered(compositeDef);
}
?在這里我們關注的重點是registerComponents方法中的annotation-config屬性的判斷以及AnnotationConfigUtils的調(diào)用
3.AnnotationConfigUtils的registerAnnotationConfigProcessors方法
?上面兩個標簽都用有同一個步驟調(diào)用AnnotationConfigUtils的registerAnnotationConfigProcessors的方法强品。這個方法也是與AutowiredAnnotationBeanPostProcessor有關系的這個直接進去
public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
//如果registry中沒有包含AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME這個beanName,則創(chuàng)建一個beanName為AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME的Bean并注冊然后放到BeanDefinitionHolder的集合中
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
.......
}
?上面步驟的主要邏輯就是創(chuàng)建一個名稱為AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME類型為AutowiredAnnotationBeanPostProcessor的Bean然后包裝之后返回膘侮。這個AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME表示的是"org.springframework.context.annotation.internalConfigurationAnnotationProcessor"這個字符串。接下來就要解析這個字符串跟AutowiredAnnotationBeanPostProcessor的關系了的榛。
4.上下文刷新refresh時候創(chuàng)建AutowiredAnnotationBeanPostProcessor
?無論是老的xml形式配置的spring還是springboot容器的刷新都會調(diào)用到對應的AbstractApplicationContext類的refresh方法琼了。關于這個方法前面有簡單的介紹Spring源碼解析——refresh方法這里就對這個方法中的registerBeanPostProcessors步驟進行分析。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//實例化并注冊所有BeanPostProcessor bean夫晌，
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
到這里其實大家應該有一點聯(lián)系了雕薪。前面我們把beanName注冊到了BeanDefinitionHolder這里就是實例化了。進入到上面的PostProcessorRegistrationDelegate類的registerBeanPostProcessors方法晓淀。這里省略部分無關的代碼
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//獲取beanFactory中所有的BeanPostProcessor類型的beanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
......
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
......
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
/**
* 找到MergedBeanDefinitionPostProcessor并注冊進去這里注冊的
* @see AutowiredAnnotationBeanPostProcessor
*/
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
......
}
?可以看到這里會先獲取到所有的類型是BeanPostProcessor的BeanName而前面我們就注冊了AutowiredAnnotationBeanPostProcessor這個類所袁，所以在這里的時候AutowiredAnnotationBeanPostProcessor會被通過調(diào)用getBean的方式進行實力跟初始化。
2.springboot中AutowiredAnnotationBeanPostProcessor的初始化
?前面分析了傳統(tǒng)的spring應用的初始化凶掰，接下來就是springboot中的了纲熏。這里快速的講解一下，后續(xù)會寫文章分析锄俄。springboot的啟動類的SpringApplication的run方法中有一步是createApplicationContext這個方法會根據(jù)應用上下文分析應用類型創(chuàng)建不同的Web應用或者非Web應用
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch(this.webApplicationType) {
case SERVLET:
contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
break;
case REACTIVE:
contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
break;
default:
contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
}
} catch (ClassNotFoundException var3) {
throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
}
}
return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
?其中默認的是SERVLET應用局劲，因此會創(chuàng)建一個AnnotationConfigServletWebServerApplicationContext類型的上下文。接下來看這個類的構造方法
public AnnotationConfigServletWebServerApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
?這里創(chuàng)建兩個對象一個是對于注解注入的支持的AnnotatedBeanDefinitionReader跟配置文件注入支持的ClassPathBeanDefinitionScanner奶赠。這里要進入的是AnnotatedBeanDefinitionReader類鱼填。
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
?到這里應該就知道了springboot應用中如何初始化AutowiredAnnotationBeanPostProcessor的了。這里調(diào)用了前面說的registerAnnotationConfigProcessors毅戈，然后在springboot最后進行容器刷新的時候進行實例跟初始化苹丸。
2.AutowiredAnnotationBeanPostProcessor解析autowire標簽
?前面分析了AutowiredAnnotationBeanPostProcessor的實例化跟初始化，接下來就是分析對應的解析的過程了苇经。
1.何時調(diào)用解析方法
?在AutowiredAnnotationBeanPostProcessor中解析方法的邏輯就在實現(xiàn)的postProcessPropertyValues方法中∽咐恚現(xiàn)在主要看這個方法在什么時候被調(diào)用的，這里可以參考一下前面的Spring源碼----Spring的Bean生命周期流程圖及代碼解釋
文章就知道在Bean初始化之前的屬性填充中調(diào)用的扇单。這里截取部分代碼
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
//容器刷新上下文的之前的準備工作中會設置
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//調(diào)用位置
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
}
2.解析步驟
現(xiàn)在分析解析Autowired以及其他標簽的步驟
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//尋找當前bean中需要自動注入的注入數(shù)據(jù)源
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;
}
1.尋找需要注入的數(shù)據(jù)源
?現(xiàn)在分析如何查找對應的需要注入的數(shù)據(jù)源
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// 獲取bean的beanName作為緩存的key如果不存在beanName就用類目
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// 從需要注入的緩存中查找是否存在已經(jīng)解析過的需要注入的數(shù)據(jù)源商模，
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
//如果數(shù)據(jù)源不存在或者數(shù)據(jù)源對應的目標class不是當前bean的beanclass則需要刷新
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
//查找并創(chuàng)建需要注入的數(shù)據(jù)源，然后保存到緩存中取
metadata = buildAutowiringMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
?這里需要先說一下injectionMetadataCache這個緩存最開始是在什么時候保存信息的，因為AutowiredAnnotationBeanPostProcessor也實現(xiàn)了MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法施流，而這個方法的調(diào)用在Bean的實例化之后屬性填充之前這個在前面Spring源碼----Spring的Bean生命周期流程圖及代碼解釋中也有提到响疚。而在次方法中又會調(diào)用上面這段代碼。所以injectionMetadataCache就是在這個時候先填充一次的瞪醋。
2.尋找需要注入的數(shù)據(jù)源
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
//檢查對應的bean的class對象是否包含Autowired忿晕，Value或者Inject注解
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<>();
//查找貼有Autowired，Value或者Inject注解的字段银受，并保存到currElements中
ReflectionUtils.doWithLocalFields(targetClass, field -> {
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);
currElements.add(new AutowiredFieldElement(field, required));
}
});
//查找貼有Autowired，Value或者Inject注解的方法宾巍，并保存到currElements中
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
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);
//獲取方法中需要的參數(shù)
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
//合并所有的currElements
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
//將源數(shù)據(jù)集合保存到InjectionMetadata中
return InjectionMetadata.forElements(elements, clazz);
}
?這里就簡單的說明一下咕幻，主要的步驟就是遍歷bean的class對象，獲取其中的field跟method然后檢查是否有autowiredAnnotationTypes集合中表示需要注入的標簽的蜀漆，如果有的話就保存到InjectionMetadata的內(nèi)部InjectedElement對象中谅河，最后統(tǒng)一保存在InjectionMetadata中并返回。
3.注入屬性到源數(shù)據(jù)
?注入的過程也很簡單确丢，就是便利前面的InjectionMetadata中的InjectedElement然后進行反射注入绷耍，這里就把代碼貼一下
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
//獲取當前InjectionMetadata中的checkedElements
Collection<InjectedElement> checkedElements = this.checkedElements;
//轉換成可以迭代的elementsToIterate
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
//迭代elementsToIterate進行注入
for (InjectedElement element : elementsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Processing injected element of bean '" + beanName + "': " + element);
}
element.inject(target, beanName, pvs);
}
}
}
protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
throws Throwable {
if (this.isField) {
Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));
}
else {
if (checkPropertySkipping(pvs)) {
return;
}
try {
Method method = (Method) this.member;
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
?到這里整個Autowired，Value鲜侥，Inject標簽都處理完了褂始。我們也可以自定義注入標簽，只需要獲取到AutowiredAnnotationBeanPostProcessor對象然后調(diào)用setAutowiredAnnotationType方法來放置自己定義的標簽就可以了描函。
