Spring中@Autowired注解作用在方法上和属性上说明_网站优化分享

您的位置：上海毫米网络优化公司 > 网站优化分享 >

文章目录

- @Autowired注解作用在方法上
- @Autowired注解作用在属性上
- @Autowired注解的使用和注入规则
- - 1.使用在变量域上面
  - 2.@Autowired注解使用在构造器上面
    @Autowired表示一个属性是否需要进行依赖注入，可以使用在属性、普通方法上、构造方法上。注解中的required属性默认是true，如果没有对象可以注入到属性，则会报出异常；
    
    @Autowired加在某个属性上，spring会从ioc容器中找到bean对象注入到属性上，如果找到多个该类型的Bean对象，则再根据属性的名字从多个Bean对象中确认一个；
    
    @Autowired写在set()方法上，在spring会根据方法的参数类型从ioc容器中找到该类型的Bean对象注入到方法的行参中，并且自动反射调用该方法(被@Autowired修饰的方法一定会执行)，所以一般使用在set方法中、普通方法不用；
    
    @Autowired使用在构造方法中：根据构造方法的形参、形参名，从ioc容器中找到该类型的Bean对象，注入到构造方法的形参中，并且执行该方法；
```
  //构造方法
    @Autowired
    public Bean03(Bean04 bean04) {
        System.out.println("11111111111111");
    }
    //属性上
    @Autowired
    Bean04 bean04;
  
    //set方法
    @Autowired
    public void setBean04(Bean04 bean) {
        this.bean04 = bean;
    }
    //普通方法
   @Autowired
    public void commonMethod(Bean04 bean04){
        System.out.println("普通方法的执行");
    }
```
    @Autowired使用在构造方法上的细节
    
    在同一个类上有多个构造方法上使用了@Autowired，默认情况下会报错；
    
    解决方法：可以把@Autowired的属性required设置成为false，此时spring会自己选择使用哪一种构造方法；
    
    spring在上述情况下的选择规则：
    
    1.会优先考虑参数多的
    
    （先ByType找到多个该类型的bean，再ByName进行注入）
    
    2.如果多个类型的bean按照ByName无法注入，则去考虑参数少的进行注入，依次类推；
    
    3.在参数个数相同、ByName,也可以注入的情况下，按照构造方法的书写顺序进行选择；
    
    @Autowired注解作用在方法上
    
    （1）该方法如果有参数，会使用autowired的方式在容器中查找是否有该参数
    
    （2）会执行该方法
    
    所以如果把@Autowired放在setter方法上，就等于给对象的属性赋值
    
    @Autowired注解作用在属性上
    
    即为在容器中创建对象时给该项属性注入值，效果同@Autowired在setter方法。
    
    @Autowired注解的使用和注入规则
    
    作为一个Spring开发者对@Autowired注解必定是非常了解了, 顾名思义自动装配，应该是Spring会自动将我们标记为@Autowired的元素装配好，与其猜测不如看看它的定义：
```
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
  
  boolean required() default true;
  
}
```
    很明显这个注解可以用到构造器，变量域，方法，注解类型和方法参数上。文档上这样描述：将一个构造器，变量域，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注入，找不到直接报错。
    
    下面让我们来看一下@Autowired的用法：
    
    1.使用在变量域上面
    
    这个相信大家都已经清楚了，Spring会帮我们注入我们想要的bean，看下面的例子：
```
@Component
public class Wheel {
  
}
  
@Component
public 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 {
  
}
```
    下面进行测试，打印的结果显示可以拿到Wheel类，说明@Autowired注解在IOC容器中只有一个类型的bean时，按照类型进行注入。
```
    @Test
    public void AutowiredConfigTest(){
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AutowiredConfig.class);
  
        Car bean = context.getBean(Car.class);
        System.out.println(bean.getWheel());
    }
  
//打印结果：
//   it.cast.circularDependency.Wheel@3eb25e1a
```
    下面看一下当IOC容器中有两个Wheel类型的bean时的情况，改造Wheel类，增加一个属性标识用于记录向Car类中注入的哪个Wheel的bean，在AutowiredConfig配置类中添加一个bean，bean的名称默认为方法名，也就是wheel1。
```
@Component
public class Wheel {
    private int num = 2;   //通过包扫描的方式注入的bean的num值为2
  
    public int getNum() {
        return num;
    }
  
    public void setNum(int num) {
        this.num = num;
    }
}
  
@Component
public class Car {
  
    @Autowired
    private Wheel wheel3;//将变量名改成wheel3，IOC容器中Wheel类型的bean的名称只有wheel和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();//通过配置类注入bean的方式num值为0
        wheel.setNum(0);
        return wheel;
    }
}
```
    这时在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：
```
@Component
public class Wheel {
    private int num = 2;   //通过包扫描的方式注入的bean的num值为2
  
    public int getNum() {
        return num;
    }
  
    public void setNum(int num) {
        this.num = num;
    }
}
  
@Component
public class Car {
  
    @Autowired
    private Wheel wheel;//将变量名改成wheel1，IOC容器中Wheel类型的bean的名称只有wheel和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();//通过配置类注入bean的方式num值为0
        wheel.setNum(0);
        return wheel;
    }
}
```
    在测试类中打印num值看看注入的是哪个bean：
```
    @Test
    public void AutowiredConfigTest(){
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AutowiredConfig.class);
  
        Car bean = context.getBean(Car.class);
        System.out.println(bean.getWheel().getNum());
    }
  
   //打印结果：
   //    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也不行。
```
@Component
public class A {
    private B b;
    private C c;
  
    @Autowired
    public A(B b, C c) {
        System.out.println("b=" + b + ", c=" + c);
        this.b = b;
        this.c = c;
    }
}
  
@Component
public class B {
  
}
  
@Component
public class C {
}
  
//打印结果：
//  b=it.cast.circularDependency.B@68e965f5, c=it.cast.circularDependency.C@6f27a732
```
    @Autowired标注在构造器上面，在B创建的过程中，会去Spring IOC中拿到需要的注入的bean，完成B的创建，其实在只有一个构造器的情况中，@Autowired可以不加，因为Spring内部有自动推断构造器的能力，这个如果想了解自动推断构造器的同学可以自行百度。
    
    下面看一个构造器循坏依赖的案例：
```
@Component
public class C {
    private B b;
  
    public C(B b) {
        this.b = b;
    }
}
  
@Component
public class B {
    private C c;
  
    public B(C c) {
        this.c = c;
    }
}
```
    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标注的构造器的案例：
```
@Component
public class A {
    private B b;
    private C c;
  
    @Autowired(required = false)
    public A(B b) {
        this.b = b;
    }
  
    @Autowired
    public A(B b, C c) {
        System.out.println("b=" + b + ", c=" + c);
        this.b = b;
        this.c = c;
    }
}
  
@Component
public class B {
  
}
  
@Component
public class C {
  
}
```
    上面已经说到，如果@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
```
@Component
public class A {
    private B b;
    private C c;
  
    @Autowired(required = false) 
    public A(B b) {
        this.b = b;
    }
  
    @Autowired(required = false)
    public A(B b, C c) {
        System.out.println("b=" + b + ", c=" + c);
        this.b = b;
        this.c = c;
    }
}
  
@Component
public class B {
  
}
  
@Component
public class C {
  
}
```
    关于@Autowired标注在方法上就不多介绍，会首先拿到方法的参数列表，然后根据上面所说的注入规则去Spring IOC中找相应的bean。
    
    陕西手机网站建设唐山企业网站建设公司网站设计制作费用一年长沙模板建站多少钱网站开发公司官网江门网站制作系统

上一篇：【微服务~原始真解】Spring Cloud —— 配置绑定和配置属性校验

下一篇：springboot log4j2日志配置路径

文章目录

@Autowired注解作用在方法上

@Autowired注解作用在属性上

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

1.使用在变量域上面

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