我们知道，在 spring 的配置文件解析时，通过 XmlBeanDefinitionReader 来操作，下面来看看对 XML 配置文件解析时，这个类具体是如何操作的。
入口
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
Document doc = doLoadDocument(inputSource, resource);
int count = registerBeanDefinitions(doc, resource);
return count;
}核心逻辑就两行：
第一行，将 xml 转换为 org.w3c.dom.Document，方便后续 registerBeanDefinitions 操作，转换使用 JAXP 中的 DOM 解析来操作。
第二行，从名字可以看出，注册所有 BeanDefinition，这也是接下来的重点。
registerBeanDefinitions
要注册 BeanDefinition，就需要先解析出 BeanDefinition。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}先创建一个 BeanDefinitionDocumentReader，此处为 DefaultBeanDefinitionDocumentReader，接着通过这个类来发起注册调用，在这个之前，调用 createReaderContext 来创建 XmlReaderContext。
XmlReaderContext
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
}public NamespaceHandlerResolver getNamespaceHandlerResolver() {
if (this.namespaceHandlerResolver == null) {
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
}
return this.namespaceHandlerResolver;
}protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
return new DefaultNamespaceHandlerResolver(cl);
}public DefaultNamespaceHandlerResolver() {
this(null, DEFAULT_HANDLER_MAPPINGS_LOCATION);
}逻辑很简单，由于 spring 遵循 SRP(单一职责原则)，所以类会比较多。
这个 DefaultNamespaceHandlerResolver 就是完成自定义标签扩展及解析很重要的一个类。在DEFAULT_HANDLER_MAPPINGS_LOCATION，即 META-INF/spring.handlers 中会存放自定义标签相应的解析器，以 key=value 形式存放，其中 key 为 namespaceUri，value 为对应的解析器的全限定性类名，形式如下：
http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler这里就完成了 XmlReaderContext 的创建，接下来通过 documentReader 发起调用。
DefaultBeanDefinitionDocumentReader
protected void doRegisterBeanDefinitions(Element root) {
this.delegate = createDelegate(getReaderContext(), root, parent);
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);
this.delegate = parent;
}核心逻辑：
- 创建 delegate，BeanDefinitionParserDelegate
- 真正的解析 parseBeanDefinitions
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}根据是否为默认名命空间，将解析分为两个分支
- parseDefaultElement
- parseCustomElement
parseDefaultElement
public boolean isDefaultNamespace(@Nullable String namespaceUri) {
return !StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri);
}默认的名命空间有两个条件
- namespeceUri 不为 null 或 ""
- 为："http://www.springframework.org/schema/beans"
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}默认标签共四个：import、alias、bean、beans。
parseCustomElement
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
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));
}核心逻辑：
先利用 XmlReaderContext 中创建的 DefaultNamespaceHandlerResolver 解析 namespaceUri，获取对应的 NamespaceHandler。
public NamespaceHandler resolve(String namespaceUri) {
Map<String, Object> handlerMappings = getHandlerMappings();
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
}
else if (handlerOrClassName instanceof NamespaceHandler) {
return (NamespaceHandler) handlerOrClassName;
}
else {
String className = (String) handlerOrClassName;
try {
Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
}
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
namespaceHandler.init();
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
}
catch (ClassNotFoundException ex) {
throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
"] for namespace [" + namespaceUri + "]", ex);
}
catch (LinkageError err) {
throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
className + "] for namespace [" + namespaceUri + "]", err);
}
}
}核心逻辑：
调用 getHandlerMappings，加载 handlerMappingsLocation 下配置的 spring.handlers，得到 java.util.Properties，处理成 Map，赋值给 handlerMappings，接着根据 namespaceUri 从 handlerMappings 中去拿，第一次如果能拿到，为一个字符串，即配置的解析器的全限定性类名，加载这个类得到 Class，接着实例化一个 NamespaceHandler 对象，调用 init 方法，这样就完成了自定义解析器的创建。
此处有一个优化，就是类的加载和实例化只执行一次，创建完实例对象后会放入 handlerMappings，将原有的 value 值全限定性类名，替换为具体的实例对象，下一次遇到同样的namespaceUri 时，执行 resolve，直接从 handlerMappings 中查找到 NamespaceHandler 对象就返回了。
得到这个 NamespaceHandler，调用 parse 方法，完成具体对应标签的解析。
示例
以 aop 标签为例，下面来看看对应的 AopNamespaceHandler 及解析方法。先来看看这个标签下的元素名称。
public void init() {
// In 2.0 XSD as well as in 2.5+ XSDs
registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
// Only in 2.0 XSD: moved to context namespace in 2.5+
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}每个标签下，不同的元素名，匹配不同的 Parser，具体定义了几个 Parser，都在此处进行实例化创建，并将这些 BeanDefinitionParser 注册到父类 NamespaceHandlerSupport 的 parsers 中，方便后续使用。
这里有一点注意，就是实际扩展自定义标签，实现自定义标签 NamespaceHandler 时，并不需要直接实现 NamespaceHandler 接口，继承 NamespaceHandlerSupport 即可。
以 "aspectj-autoproxy" 为例。
<aop:aspectj-autoproxy/>解析时，遇到这个标签，调用 parseCustomElement，接着拿到具体的 handler，发起 parse 调用，调入 NamespaceHandlerSupport#parse 中，根据解析出的节点名 aspectj-autoproxy，获取对应的 BeanDefinitionParser，此时为 AspectJAutoProxyBeanDefinitionParser。
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
extendBeanDefinition(element, parserContext);
return null;
}
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
ParserContext parserContext, Element sourceElement) {
BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
parserContext.getRegistry(), parserContext.extractSource(sourceElement));
useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
registerComponentIfNecessary(beanDefinition, parserContext);
}创建 XmlReaderContext 时传入的 sourceExtractor 为 NullSourceExtractor，调用 extractSource 方法后返回 null。
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
}
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}可以看到，注册了一个名称为 AUTO_PROXY_CREATOR_BEAN_NAME 的 BeanDefinition。
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
if (sourceElement != null) {
boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
if (proxyTargetClass) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
if (exposeProxy) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}判断标签中是否存在 proxy-target-class、expose-proxy 两个属性，存在，添加到 BeanDefinition 的 PropertyValues 中。其中 proxy-target-class 对应 ProxyConfig.proxyTargetClass 属性，控制在存在接口时，是否采用 Cglib 作为切面增强。expose-proxy 对应 exposeProxy 属性，控制在执行拦截方法 interceptor 时是否将当前 proxy 暴露出去，即是否执行AopContext.setCurrentProxy(proxy);。
private void extendBeanDefinition(Element element, ParserContext parserContext) {
BeanDefinition beanDef =
parserContext.getRegistry().getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
if (element.hasChildNodes()) {
addIncludePatterns(element, parserContext, beanDef);
}
}
private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
ManagedList<TypedStringValue> includePatterns = new ManagedList<>();
NodeList childNodes = element.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node node = childNodes.item(i);
if (node instanceof Element) {
Element includeElement = (Element) node;
TypedStringValue valueHolder = new TypedStringValue(includeElement.getAttribute("name"));
valueHolder.setSource(parserContext.extractSource(includeElement));
includePatterns.add(valueHolder);
}
}
if (!includePatterns.isEmpty()) {
includePatterns.setSource(parserContext.extractSource(element));
beanDef.getPropertyValues().add("includePatterns", includePatterns);
}
}可以看到 extendBeanDefinition 方法的作用就是解析 <aop:aspectj-autoproxy> 的子标签 <aop:include name=""/>，最后将其作为 includePatterns 添加进 BeanDefinition 的 PropertyValues。
顺便说一句，dubbo 框架中的自定义标签 <dubbo:xxx> 就是自定义标签扩展的一个应用。
2327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
