【Spring】依賴注入（DI）

h# 依賴注入（DI）

依賴注入（DI）

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

構造器注入

我們在之前的案例4已經詳細講過了

有參注入
無參注入

`set`注入 (重點)

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

測試pojo類 :

Address.java

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

Student.java

package com.demo.pojo;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    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> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    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;
    }

    public void show() {
        System.out.println("name=" + name
                           + ",address=" + address.getAddress()
                           + ",books="
                          );
        for (String book : books) {
            System.out.print("<<" + book + ">>\t");
        }
        System.out.println("\n愛好:" + hobbys);

        System.out.println("card:" + card);

        System.out.println("games:" + games);

        System.out.println("wife:" + wife);

        System.out.println("info:" + info);

    }
}

1、常量注入

<bean id="student" class="com.demo.pojo.Student">
  <property name="name" value="小明"/>
</bean>

測試：

@Test
public void test01(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    Student student = (Student) context.getBean("student");

    System.out.println(student.getName());

}

2、Bean注入

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

<bean id="addr" class="com.demo.pojo.Address">
<property name="address" value="重慶"/>
</bean>

<bean id="student" class="com.demo.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
</bean>

3、數組注入

<bean id="student" class="com.demo.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
<property name="books">
<array>
<value>西游記</value>
<value>紅樓夢</value>
<value>水滸傳</value>
</array>
</property>
</bean>

4、List注入

<property name="hobbys">
<list>
<value>聽歌</value>
<value>看電影</value>
<value>爬山</value>
</list>
</property>

5、Map注入

<property name="card">
<map>
<entry key="中國郵政" value="456456456465456"/>
<entry key="建設" value="1456682255511"/>
</map>
</property>

6、set注入

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

7、Null注入

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

8、Properties注入

<property name="info">
    <props>
        <prop key="學號">20190604</prop>
        <prop key="性別">男</prop>
        <prop key="姓名">小明</prop>
    </props>
</property>

測試結果：

拓展注入實現

User.java ：【注意：這里沒有有參構造器！】

public class User {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
        "name='" + name + '\'' +
        ", age=" + age +
        '}';
    }
}

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

導入約束 :xmlns:p="http://www.springframework.org/schema/p"

properties屬性注入：有構造方法時需要有無參構造

scope屬性 :

singleton 單例模式，Spring的默認機制單線程使用

prototype 原型模式每次從容器中get的時候都會生成一個新的對象

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

  <!--  p命名空間注入 properties屬性注入 ： 有構造方法時需要有 無參構造-->
  <!--	P(屬性: properties)命名空間 , 屬性依然要設置set方法-->
  <bean id="user" class="com.demo.pojo.User" p:age="18" p:name="zhang"/>
</beans>

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

導入約束 : xmlns:c="http://www.springframework.org/schema/c"


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

  <!--  c標簽注入 構造器注入:有參構造  多線程-->
  <!--C(構造: Constructor)命名空間 , 屬性依然要設置set方法-->
  <bean id="userR" class="com.demo.pojo.User" c:name="wang" c:age="18" scope="prototype"/>

</beans>

發(fā)現問題：沒有寫有參構造，使用構造器注入需要有有參構造。

解決：把有參構造器加上，c標簽（Constructor）就是另類的一種構造器注入！

測試代碼：

public class TestMain {

    public static void main(String[] args) {

        // beans注入
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        
        System.out.println( "姓名 " + student.getName());
        System.out.println("地址" +  student.getAddress().getAddress());
        System.out.println("getBooks"+Arrays.toString(student.getBooks()));
        System.out.println("getHobbys"+student.getHobbys());
        System.out.println("getCard"+student.getCard());
        System.out.println("getGames"+student.getGames());
        System.out.println("getWife"+student.getWife());
        System.out.println("getInfo"+student.getInfo());
        student.show();

    }

    @Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("userBean.xml");

        // scope = singleton
        User user = context.getBean("user", User.class);
        User user2 = context.getBean("user", User.class);
        // scope = prototype
        User userR = context.getBean("userR", User.class);
        User userR2 = context.getBean("userR", User.class);

        System.out.println("singleton：單例");
        System.out.println(user);
        System.out.println(user2);
        System.out.println(user == user2);

        System.out.println("prototype：原型");
        System.out.println(userR);
        System.out.println(userR2);
        System.out.println(userR == userR2);
    }

Bean的作用域

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

Bean Scopes :: Spring Framework

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

Singleton 單例模式

當一個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" >
<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

測試：

@Test
public void test03(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = (User) context.getBean("user");
    User user2 = (User) context.getBean("user");
    System.out.println(user==user2);
}

Prototype 原型模式

當一個bean的作用域為prototype，表示一個bean定義對應多個對象實例。

Prototype作用域的bean會導致在每次對該bean請求（將其注入到另一個bean中，或者以程序的方式調用容器的getBean()方法）時都會創(chuàng)建一個新的bean實例。

Prototype是原型類型，它在我們創(chuàng)建容器的時候并沒有實例化，而是當我們獲取bean的時候才會去創(chuàng)建一個對象，而且我們每次獲取到的對象都不是同一個對象。對有狀態(tài)的bean應該使用prototype作用域，而對無狀態(tài)的bean則應該使用singleton作用域。在XML中將bean定義成prototype，可以這樣配置：

<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
<!-- 錯誤案例，以前可以 -->
<!-- <bean id="account" class="com.foo.DefaultAccount" singleton="false"/> -->

其他幾種模式：request、session、application、websocket都是在web模式中才能使用。 Only valid in the context of a web-aware

Request 請求

當一個bean的作用域為Request，表示在一次HTTP請求中，一個bean定義對應一個實例；

即每個HTTP請求都會有各自的bean實例，它們依據某個bean定義創(chuàng)建而成。該作用域僅在基于web的Spring ApplicationContext情形下有效。考慮下面bean定義：

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

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

當處理請求結束 request作用域的bean實例將被銷毀。

Session 會話

當一個bean的作用域為session，表示在一個HTTP Session中，一個bean定義對應一個實例。該作用域僅在基于web的Spring ApplicationContext情形下有效。考慮下面bean定義：

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

針對某個HTTP Session，Spring容器會根據userPreferences bean定義創(chuàng)建一個全新的userPreferences bean實例，且該userPreferences bean僅在當前`HTTP Session**內有效**。

與request作用域一樣，可以根據需要放心的更改所創(chuàng)建實例的內部狀態(tài)，而別的HTTP Session中根據userPreferences創(chuàng)建的實例，將不會看到這些特定于某個HTTP Session的狀態(tài)變化。當HTTP 會話被廢棄的時候，在該HTTP Session作用域內的bean也會被廢棄掉。

簡單概括：application就是在全局中存在，session就是在session中存在，request就是在request中存在。當請求、會話、這個應用結束的時候，就會銷毀。

Listener

監(jiān)聽器

Listener 是用于監(jiān)聽 Servlet 容器中某些特定事件（如請求的開始和結束，Session 的創(chuàng)建和銷毀等）的組件。Spring 提供了一些內置的監(jiān)聽器，能夠幫助你在應用的生命周期中執(zhí)行特定的操作。

監(jiān)聽web

<web-app>
	...
	<listener>
		<listener-class>
			org.springframework.web.context.request.RequestContextListener
		</listener-class>
	</listener>
	...
</web-app>

RequestContextListener 是一個用于監(jiān)聽請求上下文的 Spring 監(jiān)聽器，它在每個 HTTP 請求的生命周期開始時初始化 Spring RequestContext。通過這個監(jiān)聽器，可以讓 Spring 在每個請求中管理與請求相關的環(huán)境變量和資源。具體來說，它確保在每個請求線程中創(chuàng)建并管理 Spring 的 RequestContext。
它通常用于 Web 應用程序中，以便在每個請求過程中能夠獲取到如 Spring 的 Locale 或其他請求相關的信息。

過濾器

Filter 是用于攔截請求和響應的組件，在請求被分發(fā)給 Servlet 之前或響應被返回之前進行某些處理。可以用于日志記錄、權限檢查、數據壓縮、請求和響應的修改等

監(jiān)聽其他加一個過濾器

<web-app>
	...
	<filter>
		<filter-name>requestContextFilter</filter-name>
		<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>requestContextFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	...
</web-app>

RequestContextFilter 是 Spring 提供的一個過濾器，它與 RequestContextListener 類似，作用是在每個 HTTP 請求的生命周期中，為請求上下文提供支持。它保證在每個請求的線程中，Spring 的 RequestContext 能夠正確地初始化，并且能夠正確地傳遞給后續(xù)的 Servlet、Filter 或其他組件。
url-pattern="/*" 表示此過濾器會應用到所有 URL 路徑，也就是所有的請求都會經過這個過濾器。你也可以根據需要配置更精確的路徑模式（例如 /api/*）。
過濾器的優(yōu)先級會影響其執(zhí)行順序。一般來說，RequestContextFilter 被放在最前面，因為它需要確保請求上下文在其他組件之前已正確創(chuàng)建。

總結

通常放在 web.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                             http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
    <!-- 其他配置 -->
</web-app>

使用 RequestContextListener 監(jiān)聽器可以確保 Spring 的請求上下文在每個 HTTP 請求的生命周期內得到正確的初始化。
使用 RequestContextFilter 過濾器也能達到類似目的，但它的優(yōu)勢在于可以在請求和響應的過程中進行更靈活的攔截和修改。

posted @ 2025-07-24 14:38 柯基大大閱讀(23) 評論(0) 收藏舉報來源

刷新頁面返回頂部

柯基大大

【Spring】 依賴注入（DI）