经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » Spring » 查看文章
Spring使用@Autowired注解实现自动装配方式
来源:jb51  时间:2021/9/27 13:08:05  对本文有异议

Spring支持注解配置

引入注解依赖

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xmlns:context="http://www.springframework.org/schema/context"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans.xsd
  6. http://www.springframework.org/schema/context
  7. http://www.springframework.org/schema/context/spring-context.xsd">

启用注解

  1. <context:annotation-config/>

使用@Autowired注解实现自动装配

1、IOC容器配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/context
  8. http://www.springframework.org/schema/context/spring-context.xsd">
  9. <context:annotation-config/>
  10. <bean id="cat" class="indi.stitch.pojo.Cat"/>
  11. <bean id="dog" class="indi.stitch.pojo.Dog"/>
  12. <bean id="people" class="indi.stitch.pojo.People" />
  13. </beans>

2、实体类使用@Autowired注解注入属性

  1. package indi.stitch.pojo;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. public class People {
  4. @Autowired
  5. private Cat cat;
  6. @Autowired
  7. private Dog dog;
  8. public Cat getCat() {
  9. return cat;
  10. }
  11. public Dog getDog() {
  12. return dog;
  13. }
  14. @Override
  15. public String toString() {
  16. return "People{" +
  17. "cat=" + cat +
  18. ", dog=" + dog +
  19. '}';
  20. }
  21. }

Cat实体类

  1. package indi.stitch.pojo;
  2. public class Cat {
  3. public void shout() {
  4. System.out.println("miao~");
  5. }
  6. }

Dog实体类

  1. package indi.stitch.pojo;
  2. public class Dog {
  3. public void shout() {
  4. System.out.println("wang~");
  5. }
  6. }

使用@Autowired注解支持自动注入后,可以省略实体类的setter方法

3、测试结果

在这里插入图片描述

使用Java类库中的@Resource注解可以实现相同的效果,@Autowired和@Resource注解的区别是

  • @Autowired注解默认按byType方式实现,@Resource注解默认按byName方式实现
  • @Autowired注解在IOC容器中配置了多个相同类型的bean时,需要配合@Qualifier找到唯一bean
  1. @Autowired
  2. @Qualifier("cat")
  3. private Cat cat;

@Resource注解可以配置name和type属性进行bean的注入

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


@Resource属性单独使用name属性后,将不会按照byType方式查找bean,@Autowired注解可以使用required属性来决定注入的属性是否允许为空

  1. @Autowired(required = false)
  2. @Qualifier("cat")
  3. private Cat cat;

@Autowired注解的使用和注入规则

作为一个Spring开发者对@Autowired注解必定是非常了解了, 顾名思义自动装配,应该是Spring会自动将我们标记为@Autowired的元素装配好,与其猜测不如看看它的定义:

  1. @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public @interface Autowired {
  5. boolean required() default true;
  6. }

很明显这个注解可以用到构造器,变量域,方法,注解类型和方法参数上。文档上这样描述:将一个构造器,变量域,setter方法,config方法标记为被Spring DI 工具自动装配。换句话说,在Spring创建bean的过程中,会为这个bean中标有@Autowired注解的构造器,变量域,方法和方法参数中自动注入我们需要的已经在Spring IOC容器里面的bean,,而无需我们手动完成,并且注入的bean都是单实例,也就是在两个bean中都依赖第三个bean,那么这两个bean中注入的第三个bean会是同一个bean(JVM中指向的地址相同)。

在@Autowired注解里面有一个required属性,该属性默认为true,当为true时,表示去Spring IOC中查找相应的bean,如果找不到,则会报错,如果为false时,表示去Spring IOC中查找相应的bean,如果找不到,则直接忽略,不再进行注入。

@Autowired注解的注入规则:默认按照类型进行注入,如果IOC容器中存在两个及以上的相同类型的bean时,根据bean的名称进行注入,如果没有指定名称的bean,则会报错。

可以使用@Qualifier("wheel")来使用指定id的bean,也可以在注入bean时,添加@Primary注解,优先添加一个bean,其规则如下:

如果指定添加了@Qualifier("wheel")则按照指定的bean id进行添加(优先级最高),找不到则直接报错。如果没有添加@Qualifier而添加了@Primary注解,则首先添加标注了@Primary注解的bean。当即存在@Qualifier注解也存在@Primary注解注解,则按照@Qualifier指定的bean id注入,找不到直接报错。

很多人java开发者都知道@Autowired注解,但是真正用的好的也不多(反正系统的学习Spring之前我是不知道的),那下面让我们来看一下@Autowired的用法:

1.使用在变量域上面

这个相信大家都已经清楚了,Spring会帮我们注入我们想要的bean,看下面的例子:

  1. package it.cast.circularDependency;
  2. @Component
  3. public class Wheel {
  4. }
  5. @Component
  6. public class Car {
  7. @Autowired
  8. private Wheel wheel2;
  9. public Wheel getWheel() {
  10. return wheel2;
  11. }
  12. public void setWheel(Wheel wheel2) {
  13. this.wheel2 = wheel2;
  14. }
  15. }
  16. @ComponentScan({"it.cast.circularDependency"})
  17. public class AutowiredConfig {
  18. }

下面进行测试,打印的结果显示可以拿到Wheel类,说明@Autowired注解在IOC容器中只有一个类型的bean时,按照类型进行注入。

  1. @Test
  2. public void AutowiredConfigTest(){
  3. AnnotationConfigApplicationContext context =
  4. new AnnotationConfigApplicationContext(AutowiredConfig.class);
  5. Car bean = context.getBean(Car.class);
  6. System.out.println(bean.getWheel());
  7. }
  8. //打印结果:
  9. // it.cast.circularDependency.Wheel@3eb25e1a

下面看一下当IOC容器中有两个Wheel类型的bean时的情况,改造Wheel类,增加一个属性标识用于记录向Car类中注入的哪个Wheel的bean,在AutowiredConfig配置类中添加一个bean,bean的名称默认为方法名,也就是wheel1。

  1. @Component
  2. public class Wheel {
  3. private int num = 2; //通过包扫描的方式注入的bean的num值为2
  4. public int getNum() {
  5. return num;
  6. }
  7. public void setNum(int num) {
  8. this.num = num;
  9. }
  10. }
  11. @Component
  12. public class Car {
  13. @Autowired
  14. private Wheel wheel3;//将变量名改成wheel3,IOC容器中Wheel类型的bean的名称只有wheel和wheel1
  15. public Wheel getWheel() {
  16. return wheel3;
  17. }
  18. public void setWheel(Wheel wheel3) {
  19. this.wheel3 = wheel3;
  20. }
  21. }
  22. @Configuration
  23. @ComponentScan({"it.cast.circularDependency"})
  24. public class AutowiredConfig {
  25. @Bean
  26. public Wheel wheel1(){
  27. Wheel wheel = new Wheel();//通过配置类注入bean的方式num值为0
  28. wheel.setNum(0);
  29. return wheel;
  30. }
  31. }

这时在Spring IOC中有两个Wheel类型的bean了,Car在注入Wheel类型的bean时,会根据变量名wheel3去找,也就是说会去找类型为Wheel,名称为wheel3的bean,显然是找不到的,也就会报错。

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

上面为报错的日志打印,大致意思说的在创建名称为car的bean时,不能为变量域wheel3完成属性注入,因为找到了两个bean,分别是wheel和wheel1。

如果我们把Car中的wheel3换成wheel就可以完成注入了,而且注入的bean是通过包扫描注入IOC的bean:

  1. @Component
  2. public class Wheel {
  3. private int num = 2; //通过包扫描的方式注入的bean的num值为2
  4. public int getNum() {
  5. return num;
  6. }
  7. public void setNum(int num) {
  8. this.num = num;
  9. }
  10. }
  11. @Component
  12. public class Car {
  13. @Autowired
  14. private Wheel wheel;//将变量名改成wheel1,IOC容器中Wheel类型的bean的名称只有wheel和wheel1
  15. public Wheel getWheel() {
  16. return wheel;
  17. }
  18. public void setWheel(Wheel wheel3) {
  19. this.wheel = wheel;
  20. }
  21. }
  22. @Configuration
  23. @ComponentScan({"it.cast.circularDependency"})
  24. public class AutowiredConfig {
  25. @Bean
  26. public Wheel wheel1(){
  27. Wheel wheel = new Wheel();//通过配置类注入bean的方式num值为0
  28. wheel.setNum(0);
  29. return wheel;
  30. }
  31. }

在测试类中打印num值看看注入的是哪个bean:

  1. @Test
  2. public void AutowiredConfigTest(){
  3. AnnotationConfigApplicationContext context =
  4. new AnnotationConfigApplicationContext(AutowiredConfig.class);
  5. Car bean = context.getBean(Car.class);
  6. System.out.println(bean.getWheel().getNum());
  7. }
  8. //打印结果:
  9. // 2

那么就验证了上面所说的注入规则:默认按照类型进行注入,如果IOC容器中存在两个及以上的相同类型的bean时,根据bean的名称进行注入,如果没有指定名称的bean,则会报错。

@Autowired注解使用在变量域中还可以解决循环依赖的问题,循环依赖问题就是A对象中注入了B对象,B对象中注入了A对象,循环依赖在面试Spring这一块的知识应该经常会被问题,关于循环依赖的问题,在后面的博客中会更新。

2.@Autowired注解使用在构造器上面

@Autowired使用在构造器上面有几条需要特别注意的点:

1.@Autowired标注在构造器上面不能解决循环依赖构造的问题

2.@Autowired可以标注在同一个类的多个构造器上面,但是required属性必须都为false,当required有一个为true时,不允许其他构造器标有@Autowired注解,即使required属性为false也不行。

  1. @Component
  2. public class A {
  3. private B b;
  4. private C c;
  5. @Autowired
  6. public A(B b, C c) {
  7. System.out.println("b=" + b + ", c=" + c);
  8. this.b = b;
  9. this.c = c;
  10. }
  11. }
  12. @Component
  13. public class B {
  14. }
  15. @Component
  16. public class C {
  17. }
  18. //打印结果:
  19. // b=it.cast.circularDependency.B@68e965f5, c=it.cast.circularDependency.C@6f27a732

@Autowired标注在构造器上面,在B创建的过程中,会去Spring IOC中拿到需要的注入的bean,完成B的创建,其实在只有一个构造器的情况中,@Autowired可以不加,因为Spring内部有自动推断构造器的能力,这个如果想了解自动推断构造器的同学可以自行百度(实在是太难了,一脸蒙蔽)。

下面看一个构造器循坏依赖的案例:

  1. @Component
  2. public class C {
  3. private B b;
  4. public C(B b) {
  5. this.b = b;
  6. }
  7. }
  8. @Component
  9. public class B {
  10. private C c;
  11. public B(C c) {
  12. this.c = c;
  13. }
  14. }

Spring目前不能解决构造器的循环依赖,所以在项目中使用的时候要格外注意一下,错误日志:

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 'b':
Requested bean is currently in creation: Is there an unresolvable circular reference?

下面看一下关于多个@Autowired标注的构造器的案例:

  1. @Component
  2. public class A {
  3. private B b;
  4. private C c;
  5. @Autowired(required = false)
  6. public A(B b) {
  7. this.b = b;
  8. }
  9. @Autowired
  10. public A(B b, C c) {
  11. System.out.println("b=" + b + ", c=" + c);
  12. this.b = b;
  13. this.c = c;
  14. }
  15. }
  16. @Component
  17. public class B {
  18. }
  19. @Component
  20. public class C {
  21. }

上面已经说到,如果@Autowired注解的属性required为true时,不允许再出现其他构造器上面标有@Autowired注解(@Autowired注解的required默认为true,所以上面的会报错),错误日志为:

org.springframework.beans.factory.BeanCreationException:
Error creating bean with name 'a': 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)

使用下面的写法就不会出现错误了,Spring支持多个构造器有@Autowired注解,但是required属性必须都是false

  1. @Component
  2. public class A {
  3. private B b;
  4. private C c;
  5. @Autowired(required = false)
  6. public A(B b) {
  7. this.b = b;
  8. }
  9. @Autowired(required = false)
  10. public A(B b, C c) {
  11. System.out.println("b=" + b + ", c=" + c);
  12. this.b = b;
  13. this.c = c;
  14. }
  15. }
  16. @Component
  17. public class B {
  18. }
  19. @Component
  20. public class C {
  21. }

关于@Autowired标注在方法上就不多介绍,会首先拿到方法的参数列表,然后根据上面所说的注入规则去Spring IOC中找相应的bean。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持w3xue。

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号