Detailed explanation of XML parsing and bean registration of spring decryption

Why start looking at the source code of spring

I've been writing code for nearly a year and a half. I've been using the spring framework since I started working. Although I can use and build the framework, I often don't understand the underlying principles, such as how spring controls transactions, how spring MVC handles requests, and how AOP is implemented This makes people feel very uneasy, so start slowly reading and studying the source code of spring!!!

How to efficiently look at the source code

My answer is to look at the source code with specific questions, otherwise it's very easy to get stuck in the details of the source code, and then faint. Finally, you find what you've been looking at for a long time

introduction

Spring is an open source design level framework, which solves the loose coupling problem between the business logic layer and other layers, and runs the interface oriented programming idea through the whole system application. At the same time, it is also one of the necessary skills in Java work

Since the process of spring source code analysis is recorded, the detailed usage will not be repeated one by one

Core code

usage

decrypt

Defaultlistablebean factory is the default implementation of spring registered and loaded beans. It can be called the ancestor in the whole spring IOC template.

Tracing the defaultlistablebean factory, you can find the following code blocks. What is the purpose of the design?

For example, when there is attribute B in a, when spring obtains attribute a, if it finds that attribute B is not instantiated, it will automatically instantiate attribute B. This is also an important feature provided in spring. In some cases, B will not be initialized, such as the implementation of the beannameaware interface.

It is introduced in spring as follows: the given dependent interface is ignored during automatic assembly, such as resolving the application context registration dependency through other methods, which is similar to the injection of beanfactory through beanfactoryaware or the injection of ApplicationContext through applicationcontextaware.

resource management

The management of file, URL, classpath and other resources is realized through the resource interface. The resource is responsible for reading the configuration file, encapsulating the configuration file as a resource, and then handing it to the xmlbeandefinitionreader for processing.

XML parsing

Xmlbeandefinitionreader is the implementation of reading, parsing and registering spring resource files. We should focus on this class.

Trace reader loadBeanDeFinitions(resource); ， We can see the following core code (excluding comments and throwing exceptions)

The above code first encodes the resource in order to worry about the encoding problem of XML

Carefully observe inputsource inputsource = new inputsource (InputStream), Its package name is org xml. Sax, so we can conclude that spring uses Sax parsing and uses inputsource to decide how to read XML files.

Finally, the prepared data is passed into the real core processing part doloadeandefinitions (inputsource, encoded resource. Getresource()) through parameters

Get document

1.doLoadBeanDeFinitions(inputSource,encodedResource.getResource()); ， Omit several catches and comments

2.doLoadDocument(inputSource,resource);

First, get the validation mode (DTD or XSD) of the XML file through getvalidationmodeforresource. You can set the validation method by yourself. By default, validation is enabled_ Auto automatically obtains the verification mode, reads the XML file through InputStream, and checks whether DOCTYPE words are included. If so, it is DTD, otherwise it returns XSD.

Common XML file validation modes are:

In this documentLoader. An entityresolver parameter is involved in the loaddocument method

What is entityresolver? Official explanation: if the Sax application needs to implement custom processing of external entities, it must implement this interface and register an instance with the Sax driver using the setentityresolver method. In other words, for parsing an XML, Sax will first read the Declaration on the XML document and find the corresponding DTD definition according to the declaration to verify the of the document. The default search rule is (i.e. network download, download the DTD definition through the DTD URI address of the XML declaration) and authenticate. The download process is a long process, Moreover, when the network is unavailable, an error will be reported here because the corresponding DTD is not found.

The function of entityresolver is that the project itself can provide a method of how to find DTD declarations, that is, the program implements the process of finding DTDs, so as to avoid finding corresponding declarations through the network.

3. Entityresolver accepts two parameters:

3.1 define bean XML file, as follows (XSD schema)

Resolve to the following two parameters:

3.2 define bean XML file, as follows (DTD schema)

Resolve to the following two parameters:

3.3 spring uses delegatingentityresolver to resolve entityresolver

We can see that different parsers are used for different patterns

Register bean

After reading the parsing XML verification, continue to track the code to see how spring registers bean information according to the document

When registering beans, first use a beandefinitionparserdelegate class to determine whether it is the default namespace. The implementation is to determine whether the namespace URI is equal to the default URI:

Trace documentreader registerBeanDeFinitions(doc,createReaderContext(resource)); ， The doc is converted from the loaddocument in the previous code block. The main purpose of this method is to extract the root node (beans)

Tracking doregisterbean definitions (root), we will see the following processing flow

First, analyze the profile (the common way to play is that different bean objects initialized by different profiles implement multiple environments)

The following parsing uses the template method pattern, in which both preprocessxml and postprocessxml are empty methods to facilitate the subsequent subclasses to carry out some processing before and after parsing. Just override these two methods.

Parse and register beandefinition. This part of the code is relatively simple

Delegate the parsebeandefinitionelement method of beandefinitionparserdelegate class to perform element parsing, Return the instance bdholder of beandefinitionholder type (including the attributes class, name, ID, alias, etc. of the configuration file). When the returned bdholder is not empty, if the child node of the default label has custom attributes, parse the custom label again. After parsing, delegate beandefinitionreaderutils. Registerbeandefinition(); Register the bdholder and send a registration event to inform the relevant listening bean that the registration has been successful

summary

Through several unknown autumn, winter, spring and summer, everything will go in the direction you want

Well, the above is the whole content of this article. I hope the content of this article has a certain reference value for your study or work. If you have any questions, you can leave a message. Thank you for your support for programming tips.

Say something

Full text code: https://gitee.com/battcn/battcn-spring-source/tree/master/Chapter1 (local download)