Spring依賴注入的幾種方式分享梳理總結

2022-07-08 18:06:23

環境

Ubuntu 22.04
IntelliJ IDEA 2022.1.3
JDK 17.0.3
Spring 5.3.21

準備

建立Maven專案 test0706 。

修改 pom.xml 檔案，新增依賴：

        ......
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.21</version>
        </dependency>
        ......

在 src/main/resources 目錄下建立 applicationContext.xml 檔案：

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

在 src/test/java 目錄下建立測試：

public class Test0706 {
}

設值注入

建立如下POJO：

Axe ：Axe介面；
StoneAxe ：Axe實現類；
SteelAxe ：Axe實現類；
Person ：Person持有Axe；

package pojo;
public interface Axe {
    public void chop();
}

package pojo;

public class StoneAxe implements Axe{
    public StoneAxe() {
        System.out.println("StoneAxe constructor");
    }
    @Override
    public void chop() {
        System.out.println("Stone axe!");
    }
}

package pojo;
public class SteelAxe implements Axe{
    public SteelAxe() {
        System.out.println("SteelAxe constructor");
    }
    @Override
    public void chop() {
        System.out.println("Steel axe!");
    }
}

package pojo;

public class Person {
    private String name;
    private Axe axe;
    public void setAxe(Axe axe) {
        this.axe = axe;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void useAxe() {
        System.out.println("I am " + name);
        axe.chop();
    }
    public Person() {
        System.out.println("Person constructor");
    }
}

在 applicationContext.xml 中註冊bean：

    ......
    <bean id="stoneAxe" class="pojo.StoneAxe"/>
    <bean id="steelAxe" class="pojo.SteelAxe"/>
    <bean id="person" class="pojo.Person">
        <property name="name" value="Tom"/>
        <property name="axe" ref="stoneAxe"/>
    </bean>
    ......

建立測試用例：

    @Test
    public void test1() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("before getBean");
        var person = ctx.getBean("person", Person.class);
        person.useAxe();
    }

執行測試，如下：

StoneAxe constructor
SteelAxe constructor
Person constructor
before getBean
I am Tom
Stone axe!

總結：

一般的bean（相對工廠bean）是在Spring初始化時建立的（注意：預設的scope是 singleton ，如果是 prototype ，則是在每次 getBean() 的時候建立範例物件）；
可以直接注入值（ value ），也可以注入bean（ ref ）；
被注入的bean（如本例中的 stoneAxe ）在 Person 之前範例化；
具體如何注入呢？是通過反射來呼叫Person的setter方法，其中方法名是字串拼起來的，具體來講是 set 加上首字母大寫的 屬性名 。本例中， person 有一個屬性叫做 axe ，則Spring會拼出 setAxe() 方法，並把 ref 的物件作為引數傳進去。所以，一定要確保Person有對應的方法；

構造注入

構造注入和設值注入非常相像，二者的主要區別為：

設值注入是通過setter方法來注入被依賴物件；
構造注入是通過構造方法來注入被依賴物件；

建立如下POJO：

Book ：Book介面；
PlayBook ：Book實現類；
StudyBook ：Book實現類；
Student ：Student持有Book；

package pojo;
public interface Book {
    public void show();
}

package pojo;

public class PlayBook implements Book{
    public PlayBook() {
        System.out.println("PlayBook constructor");
    }
    @Override
    public void show() {
        System.out.println("Play book!");
    }
}

package pojo;

public class StudyBook implements Book{
    public StudyBook() {
        System.out.println("StudyBook constructor");
    }
    @Override
    public void show() {
        System.out.println("Study book!");
    }
}

package pojo;

public class Student {
    private String name;
    private Book book;
    public Student(String name, Book book) {
        System.out.println("Student constructor");
        this.name = name;
        this.book = book;
    }
    public void readBook() {
        System.out.println("I am " + name);
        book.show();
    }
}

在 applicationContext.xml 中註冊bean：

    ......
    <bean id="playBook" class="pojo.PlayBook"/>

    <bean id="studyBook" class="pojo.StudyBook"/>

    <bean id="student" class="pojo.Student">
        <constructor-arg index="0" value="Jerry"/>
        <constructor-arg index="1" ref="playBook"/>
    </bean>
    ......

建立測試用例：

    @Test
    public void test2() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("before getBean");
        var student = ctx.getBean("student", Student.class);
        student.readBook();
    }

執行測試，如下：

......
PlayBook constructor
StudyBook constructor
Student constructor
before getBean
I am Jerry
Play book!

總結：

一般的bean（相對工廠bean）是在Spring初始化時建立的（注意：預設的scope是 singleton ，如果是 prototype ，則是在每次 getBean() 的時候建立範例物件）；
可以直接注入值（ value ），也可以注入bean（ ref ）；
被注入的bean（如本例中的 PlayBook ）在 Student 之前範例化；
具體如何注入呢？是通過反射來呼叫bean的構造方法，如果有多個引數，可以用 index 來區分（下標從 0 開始），所以一定要確保有對應的構造方法；介面注入

介面注入和設值注入也很相像，都是通過setter方法來注入被依賴物件，二者的主要區別為：

介面注入需要實現特定介面，因此setter方法是固定的；
在設值注入中，被注入的具體物件是我們自己定的，而在介面注入中，被注入的物件是Spring決定的，我們不需要設定 <property> 來注入物件；

以 ApplicationContextAware 介面為例，在Spring初始化時，會掃描所有的bean，如果發現某個bean實現了該介面，就會自動呼叫其 setApplicationContext() 方法，把Spring容器本身傳進去；

建立POJO MyBean ：

package pojo;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class MyBean implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("before setter");

        this.applicationContext = applicationContext;
    }
    public void foo() {
        System.out.println(applicationContext.getDisplayName());
    }
}

在 applicationContext.xml 中註冊bean：

    ......
    <bean id="myBean" class="pojo.MyBean"/>
    ......

建立測試用例：

    @Test
    public void test3() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("before getBean");
        var myBean = ctx.getBean("myBean", MyBean.class);
        myBean.foo();
    }

執行測試，如下：

......
before setter
before getBean
org.springframework.context.support.ClassPathXmlApplicationContext@506e6d5e

總結：

無需設定注入物件；
具體如何注入呢？Spring會掃描所有的bean，如果發現某個bean實現了某些介面，就會自動呼叫其介面方法，把特定物件（比如Spring容器本身）傳進去；自動裝配

對於bean之前的依賴關係，通常我們使用 ref 來顯式指定被注入的物件。Spring也支援自動裝配（autowire）。

常見的自動裝配策略有：

byName ：通過setter方法名來查詢bean ID，跟前面說的通過bean ID來呼叫setter方法正好相反。具體操作為：去掉 set 字首，然後首字母小寫。比如 setName() 方法，得到的bean ID是 name 。如果找不到對應的bean ID，則不進行注入操作。由於ID是唯一的，所以不存在找到多個bean的情況；
byType ：根據setter方法的引數型別來查詢bean，如果找不到符合的bean，則不進行注入操作。如果找到多個符合的bean，則丟擲異常；

建立如下POJO：

Ball：Ball介面；
FootBall ：Ball實現類；
BasketBall ：Ball實現類；
Athlete ：Athlete持有Ball；

package pojo;
public interface Ball {
    public void fly();
}

package pojo;

public class FootBall implements Ball{
    @Override
    public void fly() {
        System.out.println("FootBall is flying");
    }
}

package pojo;

public class BasketBall implements Ball{
    @Override
    public void fly() {
        System.out.println("BasketBall is flying");
    }
}

package pojo;

public class Athlete {
    private Ball ball;
    public void setBall(Ball ball) {
        this.ball = ball;
    }
    public void play() {
        ball.fly();
    }
}

在 applicationContext.xml 中註冊bean：

    ......
    <bean id="footBall" class="pojo.FootBall"/>
    <bean id="basketBall" class="pojo.BasketBall"/>
    <bean id="athlete" class="pojo.Athlete" autowire="byName"/>
    ......

建立測試用例：

    @Test
    public void test4() {
        var ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        var athlete = ctx.getBean("athlete", Athlete.class);
        athlete.play();
    }

執行測試，如下：

java.lang.NullPointerException: Cannot invoke "pojo.Ball.fly()" because "this.ball" is null

這是因為 autowire="byName" ，setter方法為 setBall() 。移除 set 字首，並把首字母 B 變成 b ，所以會查詢ID為 ball 的bean，但是沒有找到，所以不會注入物件。但是後面呼叫了Ball的 fly() 方法，所以報了空指標錯誤。

修改設定如下：

    ......
    <bean id="ball" class="pojo.FootBall"/>
    <bean id="basketBall" class="pojo.BasketBall"/>
    <bean id="athlete" class="pojo.Athlete" autowire="byName"/>
    ......

再次執行測試，這次成功了：

FootBall is flying

修改設定，把 byName 改為 byType ：

    ......
    <bean id="athlete" class="pojo.Athlete" autowire="byName"/>
    ......

再次執行測試，如下：

org.springframework.beans.factory.UnsatisfiedDependencyException:
Error creating bean with name 'athlete' defined in class path resource [applicationContext.xml]:
Unsatisfied dependency expressed through bean property 'ball';
nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:
No qualifying bean of type 'pojo.Ball' available:
expected single matching bean but found 2: ball,basketBall

找到了多個符合的bean，所以報錯了。

修改設定，只保留一個Ball的實現類：

    ......
<!--    <bean id="ball" class="pojo.FootBall"/>-->
    <bean id="basketBall" class="pojo.BasketBall"/>
    <bean id="athlete" class="pojo.Athlete" autowire="byType"/>
    ......

再次執行測試，這次成功了。

BasketBall is flying

總結

Bean預設的scope是 singleton ，表示在Spring初始化的時候建立，如果設定為 prototype ，則是在每次 getBean() 的時候建立範例物件（注：工廠bean建立bean行為有所不同，即使是singleton，也不是在Spring初始化時建立，而是在第一次 getBean() 時建立，參見我另一篇檔案）。
可以直接注入值（ value ），也可以注入bean（ ref ）；
被注入的bean（如本例中的 stoneAxe ）在 Person 之前範例化；

具體如何注入呢？

設值注入：通過反射來呼叫bean的setter方法，其中方法名是字串拼起來的，具體來講是 set 加上首字母大寫的 屬性名 。所以，一定要確保bean有對應的方法；
構造注入：通過反射來呼叫bean的構造方法，如果有多個引數，可以用 index 來區分（下標從 0 開始），所以一定要確保有對應的構造方法；
介面注入：無需設定注入物件。Spring會掃描所有的bean，如果發現某個bean實現了某些介面，就會自動呼叫其介面方法，把特定物件（比如Spring容器本身）傳進去；

自動裝配：

byName ：通過setter方法名來查詢bean ID，跟前面說的通過bean ID來呼叫setter方法正好相反。把setter方法名去掉 set 字首，然後首字母小寫。比如對於 setName() 方法，得到的bean ID是 name ：

如果找不到對應的bean ID，則不進行注入操作；
如果找到對應的bean ID，則進行注入操作；
由於ID是唯一的，所以不存在找到多個bean ID的情況；

byType ：根據setter方法的引數型別來查詢bean：

如果找不到符合的bean，則不進行注入操作；
如果找到唯一符合的bean，則進行注入操作；
如果找到多個符合的bean，則丟擲異常；

到此這篇關於Spring依賴注入的幾種方式分享梳理總結的文章就介紹到這了,更多相關Spring依賴注入內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！

Spring依賴注入的幾種方式分享梳理總結

目錄

環境

準備

設值注入

構造注入

總結

熱門文章