Spring配置與依賴注入基礎(chǔ)詳解

更新時間：2022年08月09日 08:53:22 作者：進擊攻城獅

依賴注入(Dependency?Injection)和控制反轉(zhuǎn)(Inversion?of?Control)是同一個概念。具體含義是:當(dāng)某個角色(可能是一個Java實例，調(diào)用者)需要另一個角色(另一個Java實例，被調(diào)用者)的協(xié)助時，在?傳統(tǒng)的程序設(shè)計過程中，通常由調(diào)用者來創(chuàng)建被調(diào)用者的實例

1.Spring配置

1.1.別名

別名

alias 設(shè)置別名 , 為bean設(shè)置別名 , 可以設(shè)置多個別名

<!--設(shè)置別名：在獲取Bean的時候可以使用別名獲取-->
<alias name="userT" alias="userNew"/>
12

1.2.Bean的配置

Bean的配置

  <!--bean就是java對象,由Spring創(chuàng)建和管理-->
<!--
   id 是bean的標識符,要唯一,如果沒有配置id,name就是默認標識符
   如果配置id,又配置了name,那么name是別名
   name可以設(shè)置多個別名,可以用逗號,分號,空格隔開
   如果不配置id和name,可以根據(jù)applicationContext.getBean(.class)獲取對象;
class是bean的全限定名=包名+類名
-->
<bean id="user" class="com.kuang.pojo.UserT" name="u1 u2,u3">
        <property name="name" value="西部開源"/>
    </bean>
    <!--    alias取別名-->
    <!--    <alias name="user" alias="ccccccccccccccccc"/>-->

1.3.import

import

團隊的合作通過import來實現(xiàn) .

    <import resource="beans2.xml"/>
    <import resource="beans.xml"/>
    <import resource="beans3.xml"/>

2.依賴注入（DI）

Dependency Injection

概念

依賴注入（Dependency Injection,DI）。
依賴 : 指Bean對象的創(chuàng)建依賴于容器 . Bean對象的依賴資源 .
注入 : 指Bean對象所依賴的資源 , 由容器來設(shè)置和裝配 .

2.1.構(gòu)造器注入

構(gòu)造器注入

我們在之前的案例已經(jīng)講過了

2.2.Set 注入（重點）

Set 注入（重點）

要求被注入的屬性 , 必須有set方法 , set方法的方法名由set + 屬性首字母大寫 , 如果屬性是boolean類型 , 沒有set方法 , 是 is .

測試pojo類 :

Address.java

public class Address {
    private String address;
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

Student.java

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbs;
    private Map<String,String> cad;
    private Set<String> games;
    private String wife;
    private Properties info;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public String[] getBooks() {
        return books;
    }
    public void setBooks(String[] books) {
        this.books = books;
    }
    public List<String> getHobbs() {
        return hobbs;
    }
    public void setHobbs(List<String> hobbs) {
        this.hobbs = hobbs;
    }
    public Map<String, String> getCad() {
        return cad;
    }
    public void setCad(Map<String, String> cad) {
        this.cad = cad;
    }
    public Set<String> getGames() {
        return games;
    }
    public void setGames(Set<String> games) {
        this.games = games;
    }
    public String getWife() {
        return wife;
    }
    public void setWife(String wife) {
        this.wife = wife;
    }
    public Properties getInfo() {
        return info;
    }
    public void setInfo(Properties info) {
        this.info = info;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbs=" + hobbs +
                ", cad=" + cad +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

2.3.擴展的注入

1、常量注入

 <bean id="address" class="com.kaung.pojo.Address">
        <property name="address" value="西安"/>

測試：

public class MyTest {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}

2、Bean注入

注意點：這里的值是一個引用，ref

 <bean id="student" class="com.kaung.pojo.Student">
        <property name="name" value="秦疆"/>
        <property name="address" ref="address"/>
        <property name="books">
     </bean>

3、List注入

 <bean id="student" class="com.kaung.pojo.Student">
        <property name="name" value="秦疆"/>
        <property name="address" ref="address"/>
        <property name="hobbs">
            <list>
                <value>聽歌</value>
                <value>敲代碼</value>
                <value>看電影</value>
            </list>
        </property>      
    </bean>

4、數(shù)組注入

 <property name="books">
            <array>
                <value>紅樓夢</value>
                <value>三國演義</value>
                <value>西游記</value>
                <value>水滸傳</value>
            </array>
        </property>

5、Map注入

 <property name="cad">
            <map>
                <entry key="身份證" value="111111111111111"/>
                <entry key="銀行卡" value="2222222222222221"/>
            </map>
        </property>

6、set注入

<property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

7、Null注入

<property name="wife">
            <null></null>
        </property>

8、Properties注入

 <property name="info">
            <props>
                <prop key="學(xué)號">202001020114</prop>
                <prop key="姓名">小明</prop>
                <prop key="url">男</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

測試結(jié)果：

Student{name='...', address=Address{address='西安'}, books=[紅樓夢, 三國演義, 西游記, 水滸傳], hobbs=[聽歌, 敲代碼, 看電影], cad={身份證=111111111111111, 銀行卡=2222222222222221}, games=[LOL, COC, BOB], wife='null', info={學(xué)號=*********, password=123456, url=男, 姓名=小明}}

9、p命名和c命名注入

p命名和c命名注入

User.java ：【注意：這里沒有有參構(gòu)造器！】

public class User {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public User() {
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

1、P命名空間注入 : 需要在頭文件中加入約束文件

導(dǎo)入約束 : xmlns:p="http://www.springframework.org/schema/p" 
 <!--P(屬性: properties)命名空間 , 直接注入屬性-->
<bean id="user" class="com.kaung.pojo.User" p:name="狂神" p:age="18"/>

2、c 命名空間注入 : 需要在頭文件中加入約束文件

導(dǎo)入約束 : xmlns:c="http://www.springframework.org/schema/c"
 <!--C(構(gòu)造: Constructor)命名空間 , 使用構(gòu)造器注入-->
<bean id="user2" class="com.kaung.pojo.User" c:age="19" c:name="狂神" scope="singleton"/>
</beans>

發(fā)現(xiàn)問題：爆紅了，剛才我們沒有寫有參構(gòu)造！

解決：把有參構(gòu)造器加上，這里也能知道，c 就是所謂的構(gòu)造器注入！

測試代碼：

  @Test
    public void test2()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user);
        System.out.println(user.hashCode());
        System.out.println(user2.hashCode());
        System.out.println(user==user2);
    }

2.4.Bean的作用域

Bean的作用域

在Spring中，那些組成應(yīng)用程序的主體及由Spring IoC容器所管理的對象，被稱之為bean。簡單地講，bean就是由IoC容器初始化、裝配及管理的對象 .

幾種作用域中，request、session作用域僅在基于web的應(yīng)用中使用（不必關(guān)心你所采用的是什么web應(yīng)用框架），只能用在基于web的Spring ApplicationContext環(huán)境。

Singleton(單例模式)

當(dāng)一個bean的作用域為Singleton，那么Spring IoC容器中只會存在一個共享的bean實例，并且所有對bean的請求，只要id與該bean定義相匹配，則只會返回bean的同一實例。Singleton是單例類型，就是在創(chuàng)建起容器時就同時自動創(chuàng)建了一個bean的對象，不管你是否使用，他都存在了，每次獲取到的對象都是同一個對象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中將bean定義成singleton，可以這樣配置：

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">
1

測試：

  @Test
    public void test2()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user);
        System.out.println(user.hashCode());
        System.out.println(user2.hashCode());
        System.out.println(user==user2);
    }
}

Prototype(原型模式)

當(dāng)一個bean的作用域為Prototype，表示一個bean定義對應(yīng)多個對象實例。Prototype作用域的bean會導(dǎo)致在每次對該bean請求（將其注入到另一個bean中，或者以程序的方式調(diào)用容器的getBean()方法）時都會創(chuàng)建一個新的bean實例。Prototype是原型類型，它在我們創(chuàng)建容器的時候并沒有實例化，而是當(dāng)我們獲取bean的時候才會去創(chuàng)建一個對象，而且我們每次獲取到的對象都不是同一個對象。根據(jù)經(jīng)驗，對有狀態(tài)的bean應(yīng)該使用prototype作用域，而對無狀態(tài)的bean則應(yīng)該使用singleton作用域。在XML中將bean定義成prototype，可以這樣配置：

  <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>    或者 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

當(dāng)一個bean的作用域為Request，表示在一次HTTP請求中，一個bean定義對應(yīng)一個實例；即每個HTTP請求都會有各自的bean實例，它們依據(jù)某個bean定義創(chuàng)建而成。該作用域僅在基于web的Spring ApplicationContext情形下有效?？紤]下面bean定義：

 <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>
1

針對每次HTTP請求，Spring容器會根據(jù)loginAction bean的定義創(chuàng)建一個全新的LoginAction bean實例，且該loginAction bean實例僅在當(dāng)前HTTP request內(nèi)有效，因此可以根據(jù)需要放心的更改所建實例的內(nèi)部狀態(tài)，而其他請求中根據(jù)loginAction bean定義創(chuàng)建的實例，將不會看到這些特定于某個請求的狀態(tài)變化。當(dāng)處理請求結(jié)束，request作用域的bean實例將被銷毀。

Session

當(dāng)一個bean的作用域為Session，表示在一個HTTP Session中，一個bean定義對應(yīng)一個實例。該作用域僅在基于web的Spring ApplicationContext情形下有效?？紤]下面bean定義：

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
1

針對某個HTTP Session，Spring容器會根據(jù)userPreferences bean定義創(chuàng)建一個全新的userPreferences bean實例，且該userPreferences bean僅在當(dāng)前HTTP Session內(nèi)有效。與request作用域一樣，可以根據(jù)需要放心的更改所創(chuàng)建實例的內(nèi)部狀態(tài)，而別的HTTP Session中根據(jù)userPreferences創(chuàng)建的實例，將不會看到這些特定于某個HTTP Session的狀態(tài)變化。當(dāng)HTTP Session最終被廢棄的時候，在該HTTP Session作用域內(nèi)的bean也會被廢棄掉。

到此這篇關(guān)于Spring配置與依賴注入基礎(chǔ)詳解的文章就介紹到這了,更多相關(guān)Spring依賴注入內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: