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

This article mainly introduces how Spring uses @ Autowired annotations to achieve automatic assembly, which has a certain reference value. Interested friends can refer to it. I hope you will learn a lot after reading this article.

Spring supports annotation configuration introducing annotations dependency enabling annotations using @ Autowired annotations for automatic assembly 1, IOC container configuration 2, and entity classes using @ Autowired annotations to inject attributes package indi.stitch.pojo;import org.springframework.beans.factory.annotation.Autowired;public class People {@ Autowired private Cat cat; @ Autowired private Dog dog; public Cat getCat () {return cat } public Dog getDog () {return dog;} @ Override public String toString () {return "People {" + "cat=" + cat + ", dog=" + dog +'}';}}

Cat entity class

Package indi.stitch.pojo;public class Cat {public void shout () {System.out.println ("miao~");}}

Dog entity class

Package indi.stitch.pojo;public class Dog {public void shout () {System.out.println ("wang~");}}

After using the @ Autowired annotation to support automatic injection, you can omit the setter method of the entity class

3. Test results

The same effect can be achieved using the @ Resource annotation in the Java class library. The difference between @ Autowired and @ Resource annotations is

@ Autowired annotation is implemented in byType mode by default, and @ Resource annotation is implemented in byName mode by default.

@ Autowired Annotation when multiple bean of the same type are configured in the IOC container, you need to cooperate with @ Qualifier to find a unique bean

@ Autowired@Qualifier ("cat") private Cat cat

@ Resource annotation can configure name and type attributes for bean injection

@ Resource (name = "dog", type = Dog.class) private Dog dog

When the @ Resources attribute uses the name attribute alone, it will not look for bean,@Autowired annotations in the byType manner. You can use the required attribute to determine whether the injected attribute is allowed to be empty.

@ Autowired (required = false) @ Qualifier ("cat") private Cat cat;@Autowired annotations usage and injection rules

As a Spring developer, the @ Autowired annotation must be very familiar. As the name implies, Spring will automatically assemble the elements we mark as @ Autowired. Instead of guessing, take a look at its definition:

@ Target ({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE}) @ Retention (RetentionPolicy.RUNTIME) @ Documentedpublic @ interface Autowired {boolean required () default true;}

It is obvious that this annotation can be applied to constructors, variable fields, methods, annotation types, and method parameters. The document describes as follows: a constructor, variable field, setter method, config method is marked as automatically assembled by the Spring DI tool. In other words, when Spring creates a bean, the constructor, variable field, method and method parameters marked with @ Autowired annotation in the bean are automatically injected into the bean, that we need already in the Spring IOC container without the need for us to do it manually, and the injected bean is a single instance, that is, it relies on the third bean in both bean Then the third bean injected into the two bean will be the same bean (pointing to the same address in JVM).

In the @ Autowired annotation, there is a required attribute, which defaults to true. If it is true, it means to look up the corresponding bean in Spring IOC. If it cannot be found, an error will be reported. If it is false, it means to find the corresponding bean in Spring IOC. If it cannot be found, it will be ignored and no longer injected.

Injection rule of @ Autowired annotation: the injection is performed by type by default. If two or more bean of the same type exist in the IOC container, it is injected according to the name of the bean. If no bean with the specified name is specified, an error will be reported.

You can use @ Qualifier ("wheel") to use the bean of the specified id, or you can add @ Primary annotation and a bean first when injecting bean. The rules are as follows:

If the specified @ Qualifier ("wheel") is added, it will be added according to the specified bean id (with the highest priority). If it cannot be found, an error will be reported directly. If you add the @ Primary annotation instead of @ Qualifier, first add the bean annotated with the @ Primary annotation. If the @ Qualifier annotation and the @ Primary annotation exist immediately, the error cannot be directly reported according to the bean id injection specified by @ Qualifier.

Many java developers know the @ Autowired annotation, but not many of them really use it well (anyway, I didn't know about it before learning Spring systematically), so let's take a look at the usage of @ Autowired:

1. Use on the variable field

I believe you all know that Spring will help us inject the bean we want. Take a look at the following example:

Package it.cast.circularDependency; @ Componentpublic class Wheel {} @ Componentpublic class Car {@ Autowired private Wheel wheel2; public Wheel getWheel () {return wheel2;} public void setWheel (Wheel wheel2) {this.wheel2 = wheel2;} @ ComponentScan ({"it.cast.circularDependency"}) public class AutowiredConfig {}

The test below shows that the printed result shows that the Wheel class is available, indicating that the @ Autowired annotation is injected according to the type when there is only one type of bean in the IOC container.

@ Test public void AutowiredConfigTest () {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext (AutowiredConfig.class); Car bean = context.getBean (Car.class); System.out.println (bean.getWheel ());} / / print result: / / it.cast.circularDependency.Wheel@3eb25e1a

Let's take a look at what happens when there are two bean of type Wheel in the IOC container, transform the Wheel class, add an attribute identifying the bean of which Wheel is injected into the Car class, and add a name of bean,bean in the AutowiredConfig configuration class that defaults to the method name, that is, wheel1.

@ Componentpublic class Wheel {private int num = 2; / / the numm value of bean injected by packet scanning is 2 public int getNum () {return num;} public void setNum (int num) {this.num = num;}} @ Componentpublic class Car {@ Autowired private Wheel wheel3 / / change variable name to bean of type Wheel in wheel3,IOC container. Only wheel and wheel1 public Wheel getWheel () {return wheel3;} public void setWheel (Wheel wheel3) {this.wheel3 = wheel3;}} @ Configuration@ComponentScan ({"it.cast.circularDependency"}) public class AutowiredConfig {@ Bean public Wheel wheel1 () {Wheel wheel = new Wheel () / / the Num value is 0 wheel.setNum (0) when bean is injected into the configuration class; return wheel;}}

At this time, there are two bean of type Wheel in Spring IOC. When Car injects bean of type Wheel, it will look for the variable name wheel3, that is, it will find the bean of type Wheel and name wheel3. Obviously, it cannot be found, so it will report an error.

Exception encountered during context initialization-cancelling refresh attempt:

Org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'car':

Unsatisfied dependency expressed through field 'wheel3'

Nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type 'it.cast.circularDependency.Wheel' available:

Expected single matching bean but found 2: wheel,wheel1

Org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'car': Unsatisfied dependency expressed through field' wheel3'

Nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type 'it.cast.circularDependency.Wheel' available:

Expected single matching bean but found 2: wheel,wheel1

The above is the log print of the error, which roughly means that when creating a bean named car, attribute injection cannot be done for the variable field wheel3, because two bean are found, wheel and wheel1.

If we replace the wheel3 in Car with wheel, we can complete the injection, and the injected bean is the bean injected into IOC through packet scan:

@ Componentpublic class Wheel {private int num = 2; / / the numm value of bean injected by packet scanning is 2 public int getNum () {return num;} public void setNum (int num) {this.num = num;}} @ Componentpublic class Car {@ Autowired private Wheel wheel / / change variable name to bean of type Wheel in wheel1,IOC container. Only wheel and wheel1 public Wheel getWheel () {return wheel;} public void setWheel (Wheel wheel3) {this.wheel = wheel;}} @ Configuration@ComponentScan ({"it.cast.circularDependency"}) public class AutowiredConfig {@ Bean public Wheel wheel1 () {Wheel wheel = new Wheel () / / the Num value is 0 wheel.setNum (0) when bean is injected into the configuration class; return wheel;}}

Print the bean value in the test class to see which Num is being injected:

@ Test public void AutowiredConfigTest () {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext (AutowiredConfig.class); Car bean = context.getBean (Car.class); System.out.println (bean.getWheel (). GetNum ());} / / print result: / / 2

Then the injection rule mentioned above is verified: by default, the injection is carried out by type. If there are two or more bean of the same type in the IOC container, the injection is carried out according to the name of the bean. If no bean with the specified name is specified, an error will be reported.

The @ Autowired annotation can also solve the problem of circular dependency when it is used in the variable domain. The problem of circular dependency is that B object is injected into An object, and An object is injected into B object. The knowledge of circular dependency in the interview Spring should often be asked, and the question of circular dependency will be updated in a later blog.

2.@Autowired annotations are used on constructors

There are several points to pay special attention to when using @ Autowired on constructors:

1.@Autowired tagging on the constructor cannot solve the problem of circular dependency construction.

2.@Autowired can be annotated on multiple constructors of the same class, but the required attribute must all be false, and when one of the required is true, other constructors are not allowed to be annotated with @ Autowired, even if the required attribute is false.

@ Componentpublic class A {private B b; private C c; @ Autowired public A (BB, C c) {System.out.println ("b =" + b + ", c =" + c); this.b = b; this.c = c;}} @ Componentpublic class B {} @ Componentpublic class C {} / / print result: / / b=it.cast.circularDependency.B@68e965f5, c=it.cast.circularDependency.C@6f27a732

@ Autowired is marked on the constructor. During the creation of B, you will go to Spring IOC to get the injected bean to complete the creation of B. in fact, @ Autowired can not be added in the case of only one constructor, because the Spring has the ability to automatically infer the constructor. If you want to know about the automatic inference constructor, you can do it on your own Baidu (it is really too difficult, blindfolded).

Let's look at an example of a constructor following bad dependencies:

@ Componentpublic class C {private B b; public C (BB) {this.b = b;} @ Componentpublic class B {private C c; public B (C c) {this.c = c;}}

Spring currently does not solve the circular dependency of constructors, so pay special attention to the error log when using it in a project:

Org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'a'defined in file

[e:\ IdeaProjects\ javaBasis\ spring\ target\ classes\ it\ cast\ circularDependency\ A.class]:

Unsatisfied dependency expressed through constructor parameter 0

Nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'b'defined in file

[e:\ IdeaProjects\ javaBasis\ spring\ target\ classes\ it\ cast\ circularDependency\ B.class]:

Unsatisfied dependency expressed through constructor parameter 0

Nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'c'defined in file

[e:\ IdeaProjects\ javaBasis\ spring\ target\ classes\ it\ cast\ circularDependency\ C.class]:

Unsatisfied dependency expressed through constructor parameter 0

Nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException:

Error creating bean with name'baked:

Requested bean is currently in creation: Is there an unresolvable circular reference?

Let's take a look at an example of multiple @ Autowired annotated constructors:

@ Componentpublic class A {private B b; private C c; @ Autowired (required = false) public A (BB) {this.b = b;} @ Autowired public A (BB, C c) {System.out.println ("b =" + b + ", c =" + c); this.b = b; this.c = c;} @ Componentpublic class B {} @ Componentpublic class C {}

As mentioned above, if the attribute required of @ Autowired annotation is true, no other constructors are allowed to be marked with @ Autowired annotation (the default of @ Autowired annotation is true, so the above will report an error), and the error log is:

Org.springframework.beans.factory.BeanCreationException:

Error creating bean with name'asides: Invalid autowire-marked constructors:

[public it.cast.circularDependency.A (it.cast.circularDependency.B)].

Found constructor with 'required' Autowired annotation:

Public it.cast.circularDependency.A (it.cast.circularDependency.B,it.cast.circularDependency.C)

There will be no errors using the following writing. Spring supports multiple constructors with @ Autowired annotations, but the required attribute must all be false

@ Componentpublic class A {private B b; private C c; @ Autowired (required = false) public A (BB) {this.b = b;} @ Autowired (required = false) public A (BB, C c) {System.out.println ("b =" + b + ", c =" + c); this.b = b; this.c = c }} @ Componentpublic class B {} @ Componentpublic class C {} Thank you for reading this article carefully. I hope the article "Spring how to use @ Autowired annotations to achieve automatic assembly" shared by the editor will be helpful to you. At the same time, I hope you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

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.