詳解Spring如何解析占位符
在以前的Spring Xml配置中我們可能會有如下配置：
<?xml version='1.0' encoding='UTF-8'?><beans xmlns='http://www.springframework.org/schema/beans' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:context='http://www.springframework.org/schema/context' xsi:schemaLocation='http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd> <context:property-placeholder ignore-unresolvable='true' location='classpath:jdbc.properties'/> <bean ><property name='url' value='${jdbc.url}'/> </bean></beans>
在上面的配置中jdbc這個Bean的url屬性值${jdbc.url}就代表占位符，占位符的真實值就存放在上述配置中的自定義元素的location屬性所代表的配置文件jdbc.properties中,這個配置文件里就一行內容：
jdbc.url=127.0.0.1
那問題就來了，Spring又是在什么階段去解析并且把占位符替換為實際值的呢？
Spring什么時候去解析并占位符從我們就可以知道它是一個自定義xml標簽，那Spring勢必要解析它，我就直接黏貼Spring解析這個自定義元素的入口代碼給各位看官。該代碼就在BeanDefinitionParserDelegate這個類中：
/** * Parse the elements at the root level in the document: * 'import', 'alias', 'bean'. * @param root the DOM root element of the document */ //todo doRegisterBeanDefinitions -> parseBeanDefinitions -> parseDefaultElement 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; //如果屬于beans命名空間 if (delegate.isDefaultNamespace(ele)) {//處理默認標簽parseDefaultElement(ele, delegate); } else {//自定義標簽//用到了parser//todo parser內部 去注冊BeanDefinition 2021-3-15delegate.parseCustomElement(ele); }} }}else { delegate.parseCustomElement(root);} }
主要關注點：delegate.parseCustomElement(ele);
@Nullable public BeanDefinition parseCustomElement(Element ele) {return parseCustomElement(ele, null); } //todo property 子元素 也有可能 解析自定義元素 parsePropertySubElement @Nullable public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {String namespaceUri = getNamespaceURI(ele);if (namespaceUri == null) { return null;}//resolve里有初始化過程//根據命名空間uri獲取 NamespaceHandler//todo 獲取命名空間下的自定義handler 比如 ContextNamespaceHandlerNamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);if (handler == null) { //todo 如果在spring.handlers配置文件 里沒有定義這個命令空間的handler就會 報這個錯 2020-09-14 error('Unable to locate Spring NamespaceHandler for XML schema namespace [' + namespaceUri + ']', ele); return null;}//調用parse方法//這里ParserContext注入registry//readerContext里 reader->XmlBeanDefinitionReader 里包含了 registry//TODO 會初始化一個ParserContext進去return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd)); }
到這里我們又要關注這個NamespaceHandler是怎么獲取到的，從上面代碼可知，Spring會從當前readerContext獲取到NamespaceHandlerResolver后通過其resolve方法并根據傳入的當前namespaceUri就可以獲得當前適合的NamespaceHandler。
/** * Create the {@link XmlReaderContext} to pass over to the document reader. */ public XmlReaderContext createReaderContext(Resource resource) {//把當前reader放進去 ,reader存放了 beanRegistry//beanRegistry 里定義了 registerBeanDefinition 這個重要的方法return new XmlReaderContext(resource, this.problemReporter, this.eventListener,this.sourceExtractor, this, getNamespaceHandlerResolver()); } /** * Lazily create a default NamespaceHandlerResolver, if not set before. * 解析自定義標簽時用到 * @see #createDefaultNamespaceHandlerResolver() */ public NamespaceHandlerResolver getNamespaceHandlerResolver() {if (this.namespaceHandlerResolver == null) { this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();}return this.namespaceHandlerResolver; } /** * Create the default implementation of {@link NamespaceHandlerResolver} used if none is specified. * <p>The default implementation returns an instance of {@link DefaultNamespaceHandlerResolver}. * @see DefaultNamespaceHandlerResolver#DefaultNamespaceHandlerResolver(ClassLoader) */ protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());return new DefaultNamespaceHandlerResolver(cl); } //返回默認的 public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION); }
從上面的代碼中可知Spring使用的是默認的DefaultNamespaceHandlerResolver,它當然也給開發者留了自定義NamespaceHandlerResolver的機會。那我們現在就可以看看DefaultNamespaceHandlerResolver如何根據namespaceUri解析到對應的NamespaceHandler的。
首先獲取到的就是context命名空間，完整路徑為http://www.springframework.org/schema/context。我們從DefaultNamespaceHandlerResolver類中可以看到它是如何解析這個命名空間的。
/** * Locate the {@link NamespaceHandler} for the supplied namespace URI * from the configured mappings. * @param namespaceUri the relevant namespace URI * @return the located {@link NamespaceHandler}, or {@code null} if none found */ @Override @Nullable 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);//todo 命名空間處理器 調用初始化過程 2020-09-04namespaceHandler.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); }} } /** * Load the specified NamespaceHandler mappings lazily. */ private Map<String, Object> getHandlerMappings() {Map<String, Object> handlerMappings = this.handlerMappings;if (handlerMappings == null) { synchronized (this) {handlerMappings = this.handlerMappings;if (handlerMappings == null) { if (logger.isTraceEnabled()) {logger.trace('Loading NamespaceHandler mappings from [' + this.handlerMappingsLocation + ']'); } try {//todo handlerMappings為空 才去 獲取所有屬性映射 2020-09-04//spring-aop spring-beans spring-contextProperties mappings =PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);if (logger.isTraceEnabled()) { logger.trace('Loaded NamespaceHandler mappings: ' + mappings);}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 handlerMappings; }
上面代碼中的handlerMappingsLocation一般就是Spring默認的路徑：
//指定了默認的handler路徑 ，可以傳入指定路徑改變 /** * The location to look for the mapping files. Can be present in multiple JAR files. */ public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = 'META-INF/spring.handlers';
我們就回到spring-context項目工程下的resoures/META-INF文件夾下的spring.handlers文件里定義了如下規則：
http://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandlerhttp://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandlerhttp://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandlerhttp://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandlerhttp://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler
可以看到context自定義命名空間就是對應的ContextNamespaceHandler。我們打開這個類瞧一瞧：
public class ContextNamespaceHandler extends NamespaceHandlerSupport { @Override public void init() {//調用抽象類NamespaceHandlerSupport的注冊解析器方法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()); }}
發現它只定義了一個init方法，顧名思義就是初始化的意思，那想當然的就是它啥時候會執行初始化呢？我們回到DefaultNamespaceHandler的resolve方法，發現它內部有一處namespaceHandler.init();， 這里就執行了對應命名空間處理器的初始化方法。接下來我們又要看看初始化了做了些啥，我們發現它調用了同一個方法registerBeanDefinitionParser也就是注冊
Bean定義解析器,到這里我們先按下暫停鍵，再捋下上面的整體流程：
Spring在解析自定義標簽的時候會根據自定義命名空間去查找合適的NamespaceHandler. 自定義的NamespaceHandler是由NamespaceHandlerResolver去解析得到的。 NamespaceHandlerResolver會根據classLoader.getResources查找所有類路徑下的spring.handlers。 查找到后把文件內容轉換成handlerMappings,然后根據傳入的自定義命名空間匹配到NamespaceHandler 執行NamespaceHandler的init方法注冊BeanDefinitionParser。那這個parser做了點什么強大的功能呢？我們下回分解。
以上就是詳解Spring如何解析占位符的詳細內容，更多關于Spring 解析占位符的資料請關注好吧啦網其它相關文章！
相關文章：
網公網安備