Spring使用@Autowired註解實現自動裝配方式

Posted on by

Spring支持註解配置

引入註解依賴

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">

啟用註解

<context:annotation-config/>

使用@Autowired註解實現自動裝配

1、IOC容器配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context="http://www.springframework.org/schema/context"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
      <context:annotation-config/>
   <bean id="cat" class="indi.stitch.pojo.Cat"/>
   <bean id="dog" class="indi.stitch.pojo.Dog"/>
   <bean id="people" class="indi.stitch.pojo.People" />
</beans>

2、實體類使用@Autowired註解註入屬性

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實體類

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

Dog實體類

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

使用@Autowired註解支持自動註入後，可以省略實體類的setter方法

3、測試結果

在這裡插入圖片描述

使用Java類庫中的@Resource註解可以實現相同的效果，@Autowired和@Resource註解的區別是

  • @Autowired註解默認按byType方式實現，@Resource註解默認按byName方式實現
  • @Autowired註解在IOC容器中配置瞭多個相同類型的bean時，需要配合@Qualifier找到唯一bean
@Autowired
@Qualifier("cat")
private Cat cat;

@Resource註解可以配置name和type屬性進行bean的註入

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

@Resource屬性單獨使用name屬性後，將不會按照byType方式查找bean，@Autowired註解可以使用required屬性來決定註入的屬性是否允許為空

@Autowired(required = false)
 @Qualifier("cat")
 private Cat cat;

@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註入，找不到直接報錯。

很多人java開發者都知道@Autowired註解，但是真正用的好的也不多（反正系統的學習Spring之前我是不知道的），那下面讓我們來看一下@Autowired的用法：

1.使用在變量域上面

這個相信大傢都已經清楚瞭，Spring會幫我們註入我們想要的bean，看下面的例子：

package it.cast.circularDependency; 
@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。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

推薦閱讀：