Spring assembling beans in IOC container

1. Spring configuration overview

1.1 overview

The spring container reads bean configuration information from XML configuration, Java annotation and spring annotation to form a bean definition registry;

Instantiate beans according to the bean definition registry;

Put the bean instance into the bean cache pool;

The application uses beans.

1.2. XML based configuration

(1) XML file overview

Xmlns ------ default namespace

Xmlns: XSI ------- standard namespace, which is used to specify the schema file of the custom namespace

Xmlns: XXX = "AAAAA" ------- user defined namespace. XXX is the alias, and the following value AAAA is the full name

XSI: schemalocation ------- specify a specific schema file for each namespace. Format: namespace full name, file address... Separated by spaces

2. Bean basic configuration

2.1 naming of beans

(1) Both ID and name can specify multiple names separated by commas, semicolons or spaces

Users can use getBean ("#car"), getBean ("123"), and getBean ("$car") to get beans.

(2) If the ID and name attributes are not specified, spring automatically takes the fully qualified name of the class as the name of the bean

(3) If there are multiple anonymous beans, i.e. < bean / > without ID and name specified, assume that the fully qualified name of the class is XXX,

Get getBean ("XXX") for the first bean, getBean ("xxx#1") for the second bean, and getBean ("xxx#2") for the third bean.

3. Dependency injection

3.1. Attribute injection

(1) Property injection requires bean to provide a default constructor and setter method for the properties to be injected. Spring first calls the default constructor to instantiate the bean object, and then calls the setter method to inject property values through reflection.

(2) Spring only checks whether there is a corresponding setter method in the bean, and does not require whether there is a corresponding attribute variable in the bean.

(3) JavaBean's special specification for attribute naming: the first two letters of variables are either all uppercase or all lowercase.

3.2 constructor injection

(1) The configuration order of constructor parameters will not affect the configuration results. The spring configuration file adopts a strategy independent of the element label order, which can ensure the certainty of configuration information to a certain extent.

(2) Match in parameters by index

If the input parameter types of the constructor are the same, you need to specify the order index of the parameters, otherwise the corresponding relationship cannot be determined. For example:

Index starts at 0.

(3) Circular dependency problem

If the constructor configuration of two beans depends on each other, a thread deadlock problem will occur,

The solution is to change constructor injection to attribute injection.

3.3 factory injection method

(1) Non static factory method

Since the factory method is not static, you must first create an instance bean of the factory class and use the factory bean to reference it

(2) Static factory method

3.4 detailed explanation of injection parameters

(1) Five special characters in XML

（2）

is to let the XML parser treat the string in the tag as normal text.

(3) Inject null value with < null / > tag

(4) Cascade attribute

spring3. Before 0, the dependent object child must be instantiated first, otherwise an exception will be thrown. Spring3 After 0, there is no need to instantiate in the display, and the spring container will automatically instantiate the dependent object.

(5) Collection merge

It is common for subclasses to merge collection elements of parent classes

(6) Configuring beans of collection type through util namespace

If you want to configure a collection type bean instead of a collection type attribute, you can configure it through the util namespace.

3.5 automatic assembly

(1) The < bean / > element provides an attribute autowire that specifies the auto assembly type

3.6 injection method

If we inject a prototype bean into a bean in singleton mode and hope to return a new bean every time we call, it will not be possible to use the traditional injection method, because the action of injecting a singleton bean into an associated bean occurs only once.

(1) An optional solution is to let the host bean implement the beanfactoryaware interface, so that the host bean can access the reference of the container. In this way, you can modify the get method and use the reference of the container

factory. The getBean ("dependent bean") method can obtain the latest bean every time.

(2) It is a bad idea to couple our code with spring in the above way. We can decouple it by means of method injection.

We only need to define an interface, which defines an abstract method to obtain dependent beans. The spring configuration is as follows:

The dynamic implementation of getcar () of interface bean is provided through the lookup method element tag. The implementation of method injection mainly depends on the dynamic operation bytecode technology of cglib package.

3.7 method replacement

Use bean2 to replace the getcar method of bean1, provided that bean2 implements the methodreplace interface, and the configuration is as follows:

4. Relationship between < bean >

4.1 succession

The configuration of the parent bean can be inherited by subclasses to avoid repeated definitions. The configuration is as follows:

The subclass can override the configuration of the parent class. If the abstract = "true" of the parent class is not specified, the parent bean will be instantiated.

4.2 dependence

The instantiation of some beans depends on other beans. Other beans must be instantiated before the host bean can be instantiated. Spring provides the properties of dependencies on, specifying that dependent beans should be instantiated first, such as:

If there are multiple pre dependent beans, you can create the bean name by comma, space or semicolon.

4.3 bean scope

(1) The spring container instantiates all beans at startup. If you don't want to instantiate in advance, the lazy init = "true" attribute of < bean / > can control delayed instantiation. However, if the bean is referenced by other beans that need to be instantiated in advance, spring will also ignore the setting of delayed instantiation.

(2) Scope related to web application

If users use the request, session and globalsession scopes, they must first make additional configuration in the web container:

In earlier versions of Web containers (before servlet 2.3), you can use HTTP request filter configuration:

In a higher version of the web container, you can use the HTTP request listener to configure:

(3) Scope dependency problem

When injecting web scoped beans into singleton or prototype beans, AOP should be used, for example:

4.4、factorybean

Generally, spring uses the class attribute of < bean / > to specify the implementation class and instantiate the bean through the reflection mechanism. However, in some cases, the process of instantiating beans is complex. If you follow the traditional method, you need to provide a lot of configuration information in < bean >. The flexibility of configuration mode is limited. At this time, a simple scheme may be obtained by coding.

Spring provides an org. Org for this purpose springframework. beans. factory. Factorybean factory class interface. Users can customize the logic of instantiating beans by implementing this interface.

When the implementation class configured by the class attribute of < bean / > is factorybean and its subclasses, the object returned by the GetObject () method of factorybean is not the factorybean and its subclasses themselves.

If you want to get the objects of the factorybean and its subclasses, you can explicitly prefix the beanname with "&", such as getBean ("& car5") when using the getBean (beanname) method.

5. Annotation based configuration

5.1 annotation type

@Component ------ native annotation

Derivative notes:

@Repository: labeling Dao

@Service: label service

@Controller: Dimension controller

5.2. Start the spring container with the annotation configuration information

(1) After spring 2.5, the context namespace was introduced, which provides the ability to define beans by scanning class packages to apply annotations:

The resource pattern attribute is used to specify the class under the specific package to be scanned in the base package

(2) There are more powerful filter sub tags

Of all types, AspectJ has the most powerful filtering power.

5.3. Automatic assembly bean

（1）@Autowired

@Autowired matches by type by default. If there is no matching bean in the container, an exception will be thrown when the spring container is started. Then @ Autowired (required = false) can be used for annotation, and no exception will be thrown.

Using @ Autowired, you can also directly label method input parameters. If a method has multiple input parameters, by default, spring automatically selects beans matching the input parameter type for injection.

Using @ Autowired to label collection variables can inject all beans matching the element type of the collection, which is very powerful.

Using the @ Autowired assembly property, there can be no setter method.

（2）@Qualifiler

If there is more than one matching bean in the container, the name of the bean can be qualified through the @ qualifiler annotation.

(3) Support for annotations

Spring also supports @ resource defined by jsr-250 and @ inject annotation defined by jsr-330

@The resource requires a bean name attribute. If the attribute is empty, the variable name or method name will be automatically used as the bean name.

(4) Key points:

If only @ Autowired is used, we still need to explicitly define the < bean / > node in XML. The spring container disables annotation assembly by default by configuring the < context: annotation config / > element in XML.

However, spring also provides another technique. Using the < context: component scan / > element, the spring container will automatically detect beans without explicitly defining the < bean / > node.

Spring annotates classes through @ component, @ repository, @ service and @ controller annotations to let < context: component scan / > know which classes need to be registered as springbeans.

If a third-party jar package is used and you want to inject the classes in the third-party jar package automatically, even if the classes in the third-party jar package are not annotated with annotations, the filter element < context: include Filter > can replace the annotation based component scanning strategy and let < context: component scan / > automatically register the classes that comply with the expression expression expression.

5.4 scope of action and life process method of bean

（1）@Scope（"xxxx"）

Beans configured through annotations are the same as beans configured through XML. The default scope is singleton.

Spring provides the @ scope annotation, which acts on the class. The parameters of the annotation are the same as the value of the scope attribute of < bean / > in XML.

(2) Comparison of life process methods

Difference: annotation can define multiple methods in a class, and the methods are executed in order

6. Java class based configuration

6.1. Use Java classes to provide bean definition information

(1) Ordinary POJOs can provide bean definition information for the spring container as long as they are annotated with the @ configuration annotation. Each method annotated with @ bean is equivalent to providing the definition information of a bean.

（2）@Bean

The type of bean is determined by the return value type of the method annotated by @ bean

The name of a bean is the same as the method name by default, and can also be explicitly specified through @ bean (name = "XXX")

You can use @ scope at @ bean to mark the scope of use of the bean

（3）@Configuration

Since the @ configuration annotation class itself has been marked with the @ Component annotation, any class marked with @ configurationcan be automatically assembled into other classes using @ Autowired.

6.2. Start the spring container with the configuration information based on Java classes

(1) Spring provides an annotationconfigapplicationcontent class, which can directly start the spring container through the class marked with the @ configuration annotation.

(2) When there are multiple configuration classes

You can register one by one through the register method of annotationconfigapplicationcontent, and then call the refresh method to refresh the container to apply these registered configuration classes.

You can also use the @ import (XXX. Class) annotation to introduce all other configuration classes into one configuration class, so you only need to register one configuration class

(3) Reference the configuration of @ configuration through the XML configuration class

(4) Reference XML configuration information in the configuration class

Use @ importresource ("classpath:...........) at @ configuration To import XML configuration files

6.3 comparison of three configuration modes

summary

The above is all about the detailed explanation of spring assembling beans in IOC container. I hope it will be helpful to you. Interested friends can continue to refer to this website:

Spring 3. Three bean configuration methods in X are explained in detail

On the difference between spring singleton bean and singleton pattern

Detailed explanation of bean life cycle used by spring configuration