上篇Spring xml解析 源码学习已经细说了spring是如何解析xml文件的，现在就来学习下如何把xml的元素转换为beandefinition甚至于我们需要的bean。
从DefaultBeanDefinitionDocumentReader的parseBeanDefinitions函数开始解析得出具体的bean，重点分析是默认的命名空间。
从root根节点出发，循环遍历其下的所有子节点，针对每个子节点进行判断和处理。
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
// 这里进去的是root元素，一般都会是默认的beans的命名空间
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);
}
}
那么问题来了，delegate.isDefaultNamespace(ele)是如何判断当前元素是否属于默认命名空间的呢？
public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
public boolean isDefaultNamespace(String namespaceUri) {
return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}
public boolean isDefaultNamespace(Node node) {
return isDefaultNamespace(getNamespaceURI(node));
}
在xml中以
image.png
如图圈住的地方，生成了具体解析的上下文XmlReaderContext。
XmlBeanDefinitionReader 文件
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
// 生成具体的XmlReaderContext对象
}
public NamespaceHandlerResolver getNamespaceHandlerResolver() {
if (this.namespaceHandlerResolver == null) {
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
}
return this.namespaceHandlerResolver;
// 生成了具体的namespace处理器
}
protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
return new DefaultNamespaceHandlerResolver(getResourceLoader().getClassLoader());
}
解决了命名空间的问题，开始具体解析了
public BeanDefinition parseCustomElement(Element ele,
BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
// 这里的handlerResolver就是上面所说的命名空间处理器DefaultNamespaceHandlerResolver
// 然后选择出具体的handler解析器去解析
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));
}
上面说的resolve方法的细节在DefaultNamespaceHandlerResolver 类
public NamespaceHandler resolve(String namespaceUri) {
Map handlerMappings = getHandlerMappings();
// 得到最新的命名空间的情况
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
}
else if (handlerOrClassName instanceof NamespaceHandler) {
return (NamespaceHandler) handlerOrClassName;
}
else {
// 初次生成的map都是结构的，需要替换value为NamespaceHandler类
String className = (String) handlerOrClassName;
try {
Class handlerClass = ClassUtils.forName(className, this.classLoader);
// value指明的类实例化
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();
// 这个init函数很重要！！！后面说
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
// 完成了整个对需要的命名空间的解析
}
catch (ClassNotFoundException ex) {
throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
namespaceUri + "] not found", ex);
}
catch (LinkageError err) {
throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
namespaceUri + "]: problem with handler class file or dependent class", err);
}
}
}
// 延迟加载获取具体的命名空间详情信息，生成一个map结构是
private Map getHandlerMappings() {
if (this.handlerMappings == null) {
synchronized (this) {
if (this.handlerMappings == null) {
try {
Properties mappings =
PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
if (logger.isDebugEnabled()) {
logger.debug("Loaded NamespaceHandler mappings: " + mappings);
}
Map handlerMappings = new ConcurrentHashMap(mappings.size());
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
this.handlerMappings = handlerMappings;
}
catch (IOException ex) {
throw new IllegalStateException(
"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
}
}
}
}
return this.handlerMappings;
}
如下图，可以确认初始化获取的map的键值对具体情况
image.png
这是dubbo的命名空间配置
image.png
ContextNamespaceHandler 文件 初始化init注册进去的解析器
public class ContextNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
}
}
同理，也可以看看dubbo的
public class DubboNamespaceHandler extends NamespaceHandlerSupport {
static {
Version.checkDuplicate(DubboNamespaceHandler.class);
// 检查是否重复了
}
public void init() {
registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
// 如代码所示，关键字是application,也就是我们配置的**dubbo:application** 字段
registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
}
}
到这里我们基本清楚了选择的合适的命名空间去解析数据了，可是上文知道一个命名空间处理器handler有多个具体的parse解析器，那就肯定得选择一个具体的解析器去解析。可看抽象类 NamespaceHandlerSupport
NamespaceHandlerSupport 文件
public BeanDefinition parse(Element element, ParserContext parserContext) {
return findParserForElement(element, parserContext).parse(element, parserContext);
// 返回一个解析器之后，进行parse(element, parserContext)
}
// 果然不出我们所料（当然我也是看了源码的），确实存在了findPrase这个方法
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
String localName = parserContext.getDelegate().getLocalName(element);
BeanDefinitionParser parser = this.parsers.get(localName);
// 通过元素的名称，获取到具体的parse，例如上面的PropertyPlaceholderBeanDefinitionParser parse解析器
if (parser == null) {
parserContext.getReaderContext().fatal(
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser;
}
可以看看dubbo的解析器具体工作, DubboBeanDefinitionParser 文件
// 解析element元素的具体属性，返回一个beandefinition
private static BeanDefinition parse(Element element, ParserContext parserContext, Class beanClass, boolean required) {
RootBeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClass(beanClass);
beanDefinition.setLazyInit(false);
String id = element.getAttribute("id");
if ((id == null || id.length() == 0) && required) {
String generatedBeanName = element.getAttribute("name");
if (generatedBeanName == null || generatedBeanName.length() == 0) {
if (ProtocolConfig.class.equals(beanClass)) {
generatedBeanName = "dubbo";
} else {
generatedBeanName = element.getAttribute("interface");
}
......
到这里整个的解析过程就全部完成了，本篇学习了解了生成beandefinition的全过程，还有个问题就是spring本身如何持有这些已经解析好的beandefinition呢？（PS：是存储在一个map容器中）
又得回到我们上面的那幅图中虚线指出的位置，在AbstractXmlApplicationContext中就已经生成了一个XmlBeanDefinitionReader对象了，然后在XmlBeanDefinitionReader中又把自身当做一个参数传递到XmlReaderContext中，而XmlReaderContext又被当做一个参数传递给具体的parse。就这样整个的链路就打通了，层层包装继承
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
// 就这个this！！！！很关键的一步
this.sourceExtractor, this, getNamespaceHandlerResolver());
}
- 在系统默认的命名空间获取的方式
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
// 已经生成的beandefinition
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 最关键的一步！！！存储，getReaderContext() 返回的是XmlReaderContext上下文
// getRegistry() 获取其注册仓库，也就是常说的`DefaultListableBeanFactory`
// 最关键的那个管理bean的工厂
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 这一步就是一直在找的存储到容器中的步骤
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
// bean配置存在别名的情况，也一并考虑
}
}
}
- 在自定义命名空间获取的方式
这个就比较简单了，需要对外提供接口的，持有一个ParserContext类
image.png
就这样通个这个ParserContext类把默认的BeanDefinitionParserDelegate本身以及xmlreadcontext上下文存储了，然后传递给用户自定义的parse进行存储操作。
当然这个BeanDefinitionParserDelegate是不是用就看用户自身了，看了下dubbo是并没有使用
所有的过程都结束了，现在spring容器持有beandefinition类型的所有bean，还有getBean等着我们呢！