spring-mvc源码-bean定义加载-非默认标签解析(context:annotation-config)

接上篇：bean定义加载整体流程：https://blog.csdn.net/matt8/article/details/106352083

看下非默认标签的解析过程，以<context:annotation-config/>这个标签为例。

非默认标签的解析，是通过org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseCustomElement(org.w3c.dom.Element)这个方法实现的，这个方法直接调用的自己的parseCustomElement(ele, null)这个方法，源码如下：

	public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
		//获取非默认标签Namespace，这里是http://www.springframework.org/schema/context
		String namespaceUri = getNamespaceURI(ele);
		//获取解析非默认标签的处理器，在每个jar包的META-INF/spring.handlers这个文件里有命名空间和处理器类的对应关系，通过这种方式，我们也可以自定义标签
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//标签解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

这里的处理器拿到的是ContextNamespaceHandler处理器，标签解析调用的是它的父类的方法org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse，源码如下：

public BeanDefinition parse(Element element, ParserContext parserContext) {
		return findParserForElement(element, parserContext).parse(element, parserContext);
	}	

这里会先查找解析器，解析器是在创建处理器对象时初始化进去的，也就是ContextNamespaceHandler处理器的init()方法设置的，这里的findParserForElement()方法会根据名字拿到对应的解析器，名字就是annotation-config，得到的解析器对象是AnnotationConfigBeanDefinitionParser解析器，最终的解析工作是这个解析器完成的。

看下解析的代码，org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser#parse方法：

	@Override
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		Object source = parserContext.extractSource(element);

		//这里将注册获取到所有相关BeanPostProcessors的bean定义
		Set<BeanDefinitionHolder> processorDefinitions =
				AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(), source);

		// Register component for the surrounding <context:annotation-config> element.
		CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
		parserContext.pushContainingComponent(compDefinition);

		// Nest the concrete beans in the surrounding component.
		for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
			parserContext.registerComponent(new BeanComponentDefinition(processorDefinition));
		}

		// Finally register the composite component.
		parserContext.popAndRegisterContainingComponent();

		return null;
	}

主要看下AnnotationConfigUtils.registerAnnotationConfigProcessors()方法，源码如下：

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, 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<BeanDefinitionHolder>(4);

		//注册ConfigurationClassPostProcessor后置处理器，对应 @Configuration
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//注册AutowiredAnnotationBeanPostProcessor后置处理器，对应 @AutoWired
		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));
		}

		//注册RequiredAnnotationBeanPostProcessor后置处理器，对应 @Required
		if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// spring还支持基于JSR-250的注解，注册CommonAnnotationBeanPostProcessor后置处理器，其中包括@PostConstruct，@PreDestroy和@Resource注解
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//JPA中的注解，注册PersistenceAnnotationBeanPostProcessor后置处理器，对应 @PersistenceContext 这里是不支持的
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//注册EventListenerMethodProcessor后置处理器，对应 @EventListener
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

<context:annotation-config/>这个标签的解析就完成了。

这里要注意：<context:annotation-config />仅能够在已经在已经注册过的bean上面起作用，对于没有在spring容器中注册的bean，它并不能执行任何操作。