Shulou(Shulou.com)06/01 Report--

This article introduces the relevant knowledge of "configuration file analysis in Spring source code". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Jar package for lock analysis: spring-beans-3.2.5.RELEASE.jar

The way to read the configuration file is XmlBeanFactory xmlBeanFactory = new XmlBeanFactory (new ClassPathResource ("spring-test.xml")); this is not recommended in spring 4.0. instead: ClassPathXmlApplicationContext content = new ClassPathXmlApplicationContext ("classpath:spring-test.xml"); source code analysis is all the same.

Core of the source code:

1Magi DefaultListableBeanFactory is the default implementation for registering and loading bean, and 2Magi XML parsing

2.1 XmlBeanDefinitionReader is used to read the XML configuration file. When reading the XML configuration file, Spring actually abstracts different resource paths into URL and encapsulates the configuration file into Resource, depending on the construction method.

/ / the path to the configuration file is eventually converted to ClassPathResource, while the ClassPathResource class inherits AbstractFileResolvingResource from AbstractResource to implement the Resource interface public ClassPathResource (String path) {this (path, (ClassLoader) null);} public ClassPathResource (String path, ClassLoader classLoader) {Assert.notNull (path, "Path must not be null"); String pathToUse = StringUtils.cleanPath (path) If (pathToUse.startsWith ("/")) {pathToUse = pathToUse.substring (1);} this.path = pathToUse; this.classLoader = classLoader! = null? ClassLoader: ClassUtils.getDefaultClassLoader ();} / / the process of creating XmlBeanFactory public class XmlBeanFactory extends DefaultListableBeanFactory {private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader (this); public XmlBeanFactory (Resource resource) throws BeansException {this (resource, null) } public XmlBeanFactory (Resource resource, BeanFactory parentBeanFactory) throws BeansException {/ / the super in this place needs to note that the constructor calling ignoreDependencyInterface () in the upward AbstractAutowireCapableBeanFactory is used to ignore the corresponding dependencies, super (parentBeanFactory); this.reader.loadBeanDefinitions (resource);}}

Class summary: mainly initialization. Look at the function of the ignoreDependencyInterface () method: auto-assembly ignores the given dependent interface, for example, when there is an attribute B in A, if the bean,B that gets An is not loaded, then spring will initialize B automatically, but in some cases B will not be initialized. For example: B implements the BeanNameAware interface. Automatic assembly is ignored, and typical applications parse Application context registration dependencies in other ways, similar to BeanFactory injection through BeanNameAware or ApplicationContext injection through ApplicationContextAware.

2.2 specifically look at this.reader.loadBeanDefinitions (resource); the implementation of this method

/ / the upper-level method mainly converts Resource to EncodedResource and does nothing else. It mainly depends on the method public int loadBeanDefinitions (EncodedResource encodedResource) throws BeanDefinitionStoreException {/ / the previous paragraph mainly makes some null judgments to get the value to be passed, Assert.notNull (encodedResource, "EncodedResource must not be null") If (logger.isInfoEnabled ()) {logger.info ("Loading XML bean definitions from" + encodedResource.getResource ());} Set currentResources = this.resourcesCurrentlyBeingLoaded.get (); if (currentResources = = null) {currentResources = new HashSet (4) This.resourcesCurrentlyBeingLoaded.set (currentResources);} if (! currentResources.add (encodedResource)) {throw new BeanDefinitionStoreException ("Detected cyclic loading of" + encodedResource + "- check your import definitions!") } try {InputStream inputStream = encodedResource.getResource () .getInputStream (); try {InputSource inputSource = new InputSource (inputStream) If (encodedResource.getEncoding ()! = null) {inputSource.setEncoding (encodedResource.getEncoding ());} / / mainly depends on this method return doLoadBeanDefinitions (inputSource, encodedResource.getResource ()) } finally {inputStream.close () }} catch (IOException ex) {throw new BeanDefinitionStoreException ("IOException parsing XML document from" + encodedResource.getResource (), ex);} finally {currentResources.remove (encodedResource) If (currentResources.isEmpty ()) {this.resourcesCurrentlyBeingLoaded.remove ();} / / this method is mainly: 1, determine the file type. 2, create Document objects according to different types. 3. Give it to the lower-level method protected int doLoadBeanDefinitions (InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {try {/ / to determine whether the xml file is DTD or XSD, int validationMode = getValidationModeForResource (resource) / / convert the unused Document object Document doc = this.documentLoader.loadDocument (inputSource, getEntityResolver (), this.errorHandler, validationMode, isNamespaceAware ()) according to the obtained file type; / / register the bean definition return registerBeanDefinitions (doc, resource) } / /.... Omit the catch method} / / what this method does: 1, create a BeanDefinitionDocumentReader. 2. Initialize XmlReaderContext. 3. Give it to the subclass to implement public int registerBeanDefinitions (Document doc, Resource resource) throws BeanDefinitionStoreException {/ / instantiate BeanDefinitionDocumentReader BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader () using DefaultBeanDefinitionDocumentReader; documentReader.setEnvironment (this.getEnvironment ()); int countBefore = getRegistry () .getBeanDefinitionCount () / / create the XmlReaderContext object and initialize namespaceHandlerResolver to the default DefaultNamespaceHandlerResolver, and give the implementation to the subclass DefaultBeanDefinitionDocumentReader documentReader.registerBeanDefinitions (doc, createReaderContext (resource)); return getRegistry () .getBeanDefinitionCount ()-countBefore;}

Parsing the XmlBeanDefinitionReader class is mainly done

1, get the XML file verification mode

2. Load the XML file and get the Document object

3, initialize BeanDefinitionDocumentReader, and initialize XmlReaderContext

2.3 look at the BeanDefinitionDocumentReader implementation class DefaultBeanDefinitionDocumentReader, which specifically does those things

/ / assign readerContext to get Document's elementpublic void registerBeanDefinitions (Document doc, XmlReaderContext readerContext) {this.readerContext = readerContext; logger.debug ("Loading bean definitions"); Element root = doc.getDocumentElement (); doRegisterBeanDefinitions (root) } / / still judging each parameter protected void doRegisterBeanDefinitions (Element root) {/ / processing the profile attribute String profileSpec = root.getAttribute (PROFILE_ATTRIBUTE); if (StringUtils.hasText (profileSpec)) {Assert.state (this.environment! = null, "Environment must be set for evaluating profiles") String [] specifiedProfiles = StringUtils.tokenizeToStringArray (profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS); if (! this.environment.acceptsProfiles (specifiedProfiles)) {return }} / / specially handle parsing BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate (this.readerContext, root, parent); / / an empty method is reserved here. Users can handle preProcessXml (root) before parsing according to their needs. / / mainly look at this method parseBeanDefinitions (root, this.delegate); / / postProcessXml (root) of the parsing session; this.delegate = parent } / / whether this method determines whether the default tag is the default tag or the custom tag protected void parseBeanDefinitions (Element root, BeanDefinitionParserDelegate delegate) {/ / default tag 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); } } //解析四种标签，import,alias,bean,beans, private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { //解析import标签 importBeanDefinitionResource(ele); } else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { //解析alias标签 processAliasRegistration(ele); } else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { //bean标签的解析， processBeanDefinition(ele, delegate); } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse 解析beans doRegisterBeanDefinitions(ele); } } 看到这里，终于正式进入标签的解析，其中profile属性的作用可以同时在配置文件中部署两套配置来适用于生产环境和开发环境 总结类上主要做的事情， 1，获取所有标签，判断是默认标签还是自定义标签 2，解析属性，有自定义属性，再解析 3，bean标签的解析 配置文件中经常用到bean，我们主要看这个解析过程，看这个方法做了哪些事情： protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { //委托BeanDefinitionHolder类的parseBeanDefinitionElement方法进行元素解析并返回BeanDefinitionHolder，经过这个方法的处理，BeanDefinitionHolder已经包含了配置中的各个属性，例如：class，id,name,alias之类的属性 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { //当BeanDefinitionHolder返回结果不为空，并且发现默认标签下面有自定义属性，在解析 bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { // Register the final decorated instance. //通过beanName注册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. //发出响应事件，通知相关的监听器，这个bean已经加载完了， getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } }3.1 默认属性的解析 看属性解析parseBeanDefinitionElement() //parseBeanDefinitionElement（） 这个方法主要传递了一个null的BeanDefinition对象，主要调用还在这public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) { //属性id， name解析 String id = ele.getAttribute(ID_ATTRIBUTE); String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); List aliases = new ArrayList(); if (StringUtils.hasLength(nameAttr)) { //将nameAttr以 ,;中的任一或者组合来分割字符，不包含空字符 String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } //将解析到的id作为beanName String beanName = id; if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { //如果id属性为空，但有name属性，将name赋值给beanName beanName = aliases.remove(0); if (logger.isDebugEnabled()) { logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases"); } } if (containingBean == null) { //解析beanName 的值是否有重名 checkNameUniqueness(beanName, aliases, ele); } //创建AbstractBeanDefinition对象并且，将解析到的属性存在对象中 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { try { //如果beanName不存在，按照spring提供的命名规则生成beanName if (containingBean != null) { beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); } else { beanName = this.readerContext.generateBeanName(beanDefinition); // Register an alias for the plain bean class name, if still possible, // if the generator returned the class name plus a suffix. // This is expected for Spring 1.2/2.0 backwards compatibility. String beanClassName = beanDefinition.getBeanClassName(); if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() >

BeanClassName.length () & &! this.readerContext.getRegistry () .isBeanNameInUse (beanClassName)) {aliases.add (beanClassName) }} if (logger.isDebugEnabled ()) {logger.debug ("Neither XML 'id' nor' name' specified -" + "using generated bean name [" + beanName + "]") }} catch (Exception ex) {error (ex.getMessage (), ele); return null }} String [] aliasesArray = StringUtils.toStringArray (aliases); / / encapsulate the acquired bean information into BeanDefinitionHolder return new BeanDefinitionHolder (beanDefinition, beanName, aliasesArray);} return null;}

The above is the whole process of parsing the default tag, mainly doing the following:

1. Provide the id and name attributes of the tag

2, create the AbstractBeanDefinition object and save the property value

3. Check whether beanName exists.

4. Encapsulate the obtained information into BeanDefinitionHolder

Specifically, let's take a look at the creation of the abstract class AbstractBeanDefinition, which inherits the BeanDefinition interface and has three implementation classes, RootBeanDefinition and ChildBeanDefinition,GenericBeanDefinition

RootBeanDefinition is the most commonly used implementation class, which corresponds to general bean element tags

GenericBeanDefinition is a bean file configuration property definition class added since version 2.5

Public AbstractBeanDefinition parseBeanDefinitionElement (Element ele, String beanName, BeanDefinition containingBean) {this.parseState.push (new BeanEntry (beanName)); parsing of String className = null; / / class attribute if (ele.hasAttribute (CLASS_ATTRIBUTE)) {className = ele.getAttribute (CLASS_ATTRIBUTE). Trim () } try {String parent = null; / / parent attribute parsing if (ele.hasAttribute (PARENT_ATTRIBUTE)) {parent = ele.getAttribute (PARENT_ATTRIBUTE) } / / create GenericBeanDefinition and use AbstractBeanDefinition to receive AbstractBeanDefinition bd = createBeanDefinition (className, parent); / / parse parseBeanDefinitionAttributes (ele, beanName, containingBean, bd) of various scope,singleton,abstract attributes; bd.setDescription (DomUtils.getChildElementValueByTagName (ele, DESCRIPTION_ELEMENT)) / / parsing of child element meta tags parseMetaElements (ele, bd); / / parsing parseLookupOverrideSubElements of child element lookup (ele, bd.getMethodOverrides ()); / / child element replaceMethod parsing parseReplacedMethodSubElements (ele, bd.getMethodOverrides ()) / / Child element constructor-arg parseConstructorArgElements (ele, bd); / / Child element property parsePropertyElements (ele, bd); / / Child element quality parseQualifierElements (ele, bd); bd.setResource (this.readerContext.getResource ()) Bd.setSource (extractSource (ele)); return bd;}. Omit catch return null;}

This method parses the attributes of all the tags and child elements of XM, and completes the transformation from XML to GenericBeanDefinition objects. GenericBeanDefinition is only a subclass implementation, and most of the attributes are stored in AbstractBeanDefinition.

3.2 Resolution of custom attributes

The decorateBeanDefinitionIfRequired () method, as stated in XML:

/ / the decorateBeanDefinitionIfRequired method mainly passes null's BeanDefinition object public BeanDefinitionHolder decorateBeanDefinitionIfRequired (Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {BeanDefinitionHolder finalDefinition = definitionHolder; / / Decorate based on custom attributes first. / / traversing all attributes, whether there are attributes NamedNodeMap attributes = ele.getAttributes (); for (int I = 0; I < attributes.getLength (); iTunes +) {Node node = attributes.item (I); finalDefinition = decorateIfRequired (node, finalDefinition, containingBd) } / / Decorate based on custom nested elements. / / traversing child nodes NodeList children = ele.getChildNodes (); for (int I = 0; I < children.getLength (); iTunes +) {Node node = children.item (I); if (node.getNodeType () = = Node.ELEMENT_NODE) {finalDefinition = decorateIfRequired (node, finalDefinition, containingBd) }} return finalDefinition;} / / see the implementation of decorateIfRequired private BeanDefinitionHolder decorateIfRequired (Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) {/ / get the namespace of the custom tag, myBean String namespaceUri = getNamespaceURI (node) in the above example / / handle the non-default tag if (! isDefaultNamespace (namespaceUri)) {/ / find the processor NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver () .resolve (namespaceUri) based on the namespace If (handler! = null) {/ / modify return handler.decorate (node, originalDef, new ParserContext (this.readerContext, this, containingBd)) } else if (namespaceUri! = null & & namespaceUri.startsWith ("http://www.springframework.org/")) {error (" Unable to locate Spring NamespaceHandler for XML schema namespace ["+ namespaceUri +"] ", node)) } else {/ / A custom namespace, not to be handled by Spring-maybe "xml:...". If (logger.isDebugEnabled ()) {logger.debug ("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");} return originalDef;}

First of all, get the namespace of the attribute or tag, and judge that if it is a custom tag for further parsing, this is basically the resolution of the custom tag. The next article will explain.

Here decorateBeanDefinitionIfRequired omits the default tag directly, because the default tag has been parsed

So far, the configuration file has been parsed, BeanDefinition can meet the subsequent requirements, and the only thing left is to register.

BeanDefinitionReaderUtils.registerBeanDefinition (bdHolder, getReaderContext (). GetRegistry ())

And issue a response event to notify the listener

GetReaderContext () .fireComponentRegistered (new BeanComponentDefinition (bdHolder))

4Registration of Bean

There are two kinds of registrations: 1the registrations of the recordable beanName. 2registration of alias alias

Public static void registerBeanDefinition (BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {/ / Register bean definition under primary name. / / register through beanName String beanName = definitionHolder.getBeanName (); registry.registerBeanDefinition (beanName, definitionHolder.getBeanDefinition ()); / / Register aliases for bean name, if any. / / Registration via alias String [] aliases = definitionHolder.getAliases (); if (aliases! = null) {for (String aliase: aliases) {registry.registerAlias (beanName, aliase) Public void registerBeanDefinition (String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {Assert.hasText (beanName, "Bean name must not be empty") for beanName; Assert.notNull (beanDefinition, "BeanDefinition must not be null") If (beanDefinition instanceof AbstractBeanDefinition) {try {/ / pre-registration detection, methodOverrides check for AbstractBeanDefinition ((AbstractBeanDefinition) beanDefinition). Validate () } catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException (beanDefinition.getResourceDescription (), beanName, "Validation of bean definition failed", ex) }} / / where beanDefinitionMap is a global concurrency situation synchronized (this.beanDefinitionMap) {Object oldBeanDefinition = this.beanDefinitionMap.get (beanName) If (oldBeanDefinition! = null) {/ / if it is already registered, but overwriting is not allowed Will throw an exception if (! this.allowBeanDefinitionOverriding) {throw new BeanDefinitionStoreException (beanDefinition.getResourceDescription (), beanName) "Cannot register bean definition [" + beanDefinition + "] for bean'" + beanName + "': There is already [" + oldBeanDefinition + "] bound.") } else {/ / can be overwritten Logging if (this.logger.isInfoEnabled ()) {this.logger.info ("Overriding bean definition for bean'" + beanName + "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]") } else {/ / record beanName this.beanDefinitionNames.add (beanName); this.frozenBeanDefinitionNames = null } / / register BeanDefinition this.beanDefinitionMap.put (beanName, beanDefinition);} / / reset beanName, clear cache resetBeanDefinition (beanName);} protected void resetBeanDefinition (String beanName) {/ / Remove the merged bean definition for the given bean, if already created. ClearMergedBeanDefinition (beanName); / / Remove corresponding bean from singleton cache, if any. Shouldn't usually / / be necessary, rather just meant for overriding a context's default beans / (e.g. The default StaticMessageSource in a StaticApplicationContext). DestroySingleton (beanName); / / Remove any assumptions about by-type mappings. ClearByTypeCache (); / / Reset all bean definitions that have the given bean as parent (recursively). For (String bdName: this.beanDefinitionNames) {if (! beanName.equals (bdName)) {BeanDefinition bd = this.beanDefinitionMap.get (bdName); if (beanName.equals (bd.getParentName () {resetBeanDefinition (bdName) }}

Summarize the above steps:

1. MethodOverrides check of AbstractBeanDefinition

2, the processing of registered beanName

3. Join the map cache

4, refresh the cache

4.2 alias alias registration

Similar to the above beanName, refer to the above

5. Notify the listener

Finally, the listener is notified here that spring has not done anything, and the implementation here is only an extension, so that when developers need to listen to registered BeanDefinition events, they can write processing logic to the listener by registering the listener

This is the end of the content of "configuration file analysis in Spring source code". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.