Spring 依賴注入

一、Spring 基于構造函數的依賴注入三、Spring 注入内部 Beans

二、Spring 基于設值函數的依賴注入四、Spring 注入集合

Spring 依賴注入

依賴注入

每個基于應用程式的 java 都有幾個對象，這些對象一起工作來呈現出終端使用者所看到的工作的應用程式。當編寫一個複雜的 Java 應用程式時，應用程式類應該盡可能獨立于其他 Java 類來增加這些類重用的可能性，并且在做單元測試時，測試獨立于其他類的獨立性。依賴注入（或有時稱為布線）有助于把這些類粘合在一起，同時保持他們獨立。

假設你有一個包含文本編輯器元件的應用程式，并且你想要提供拼寫檢查。标準代碼看起來是這樣的：

public class TextEditor {
   private SpellChecker spellChecker;  
   public TextEditor() {
      spellChecker = new SpellChecker();
   }
}

在這裡我們所做的就是建立一個 TextEditor 和 SpellChecker 之間的依賴關系。在控制反轉的場景中，我們反而會做這樣的事情：

public class TextEditor {
   private SpellChecker spellChecker;
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
}

在這裡，TextEditor 不應該擔心 SpellChecker 的實作。SpellChecker 将會獨立實作，并且在 TextEditor 執行個體化的時候将提供給 TextEditor，整個過程是由 Spring 架構的控制。

在這裡，我們已經從 TextEditor 中删除了全面控制，并且把它儲存到其他地方（即 XML 配置檔案），且依賴關系（即 SpellChecker 類）通過類構造函數被注入到 TextEditor 類中。是以，控制流通過依賴注入（DI）已經“反轉”，因為你已經有效地委托依賴關系到一些外部系統。

依賴注入的第二種方法是通過 TextEditor 類的 Setter 方法，我們将建立 SpellChecker 執行個體，該執行個體将被用于調用 setter 方法來初始化 TextEditor 的屬性。

是以，DI 主要有兩種變體和下面的兩個子章将結合執行個體涵蓋它們：

序号	依賴注入類型 & 描述
1	Constructor-based dependency injection 當容器調用帶有多個參數的構造函數類時，實作基于構造函數的 DI，每個代表在其他類中的一個依賴關系。
2	Setter-based dependency injection 基于 setter 方法的 DI 是通過在調用無參數的構造函數或無參數的靜态工廠方法執行個體化 bean 之後容器調用 beans 的 setter 方法來實作的。

序号

依賴注入類型 & 描述

Constructor-based dependency injection

當容器調用帶有多個參數的構造函數類時，實作基于構造函數的 DI，每個代表在其他類中的一個依賴關系。

Setter-based dependency injection

基于 setter 方法的 DI 是通過在調用無參數的構造函數或無參數的靜态工廠方法執行個體化 bean 之後容器調用 beans 的 setter 方法來實作的。

你可以混合這兩種方法，基于構造函數和基于 setter 方法的 DI，然而使用有強制性依存關系的構造函數和有可選依賴關系的 sette r是一個好的做法。

代碼是 DI 原理的清洗機，當對象與它們的依賴關系被提供時，解耦效果更明顯。對象不查找它的依賴關系，也不知道依賴關系的位置或類，而這一切都由 Spring 架構控制的。

一、Spring 基于構造函數的依賴注入

Spring 基于構造函數的依賴注入

當容器調用帶有一組參數的類構造函數時，基于構造函數的 DI 就完成了，其中每個參數代表一個對其他類的依賴。

示例：

下面的例子顯示了一個類 TextEditor，隻能用構造函數注入來實作依賴注入。

讓我們用 Eclipse IDE 适當地工作，并按照以下步驟建立一個 Spring 應用程式。

步驟	描述
1	建立一個名為 SpringExample 的項目，并在建立的項目中的 src 檔案夾下建立包 com.tutorialspoint 。
2	使用 Add External JARs 選項添加必需的 Spring 庫，解釋見 Spring Hello World Example chapter.
3	在 com.tutorialspoint 包下建立 Java類 TextEditor，SpellChecker 和 MainApp。
4	在 src 檔案夾下建立 Beans 的配置檔案 Beans.xml 。
5	最後一步是建立所有 Java 檔案和 Bean 配置檔案的内容并按照如下所示的方法運作應用程式。

這是 TextEditor.java 檔案的内容：

package com.tutorialspoint;
public class TextEditor {
   private SpellChecker spellChecker;
   public TextEditor(SpellChecker spellChecker) {
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
   public void spellCheck() {
      spellChecker.checkSpelling();
   }
}

下面是另一個依賴類檔案 SpellChecker.java 的内容：

package com.tutorialspoint;
public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

以下是 MainApp.java 檔案的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
             new ClassPathXmlApplicationContext("Beans.xml");
      TextEditor te = (TextEditor) context.getBean("textEditor");
      te.spellCheck();
   }
}

下面是配置檔案 Beans.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-3.0.xsd">

   <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <constructor-arg ref="spellChecker"/>
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>

</beans>

當你完成了建立源和 bean 配置檔案後，讓我們開始運作應用程式。如果你的應用程式運作順利的話，那麼将會輸出下述所示消息：

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

構造函數參數解析:

如果存在不止一個參數時，當把參數傳遞給構造函數時，可能會存在歧義。要解決這個問題，那麼構造函數的參數在 bean 定義中的順序就是把這些參數提供給适當的構造函數的順序就可以了。考慮下面的類:

package x.y;
public class Foo {
   public Foo(Bar bar, Baz baz) {
      // ...
   }
}

下述配置檔案工作順利：

<beans>
   <bean id="foo" class="x.y.Foo">
      <constructor-arg ref="bar"/>
      <constructor-arg ref="baz"/>
   </bean>

   <bean id="bar" class="x.y.Bar"/>
   <bean id="baz" class="x.y.Baz"/>
</beans>

讓我們再檢查一下我們傳遞給構造函數不同類型的位置。考慮下面的類：

package x.y;
public class Foo {
   public Foo(int year, String name) {
      // ...
   }
}

如果你使用 type 屬性顯式的指定了構造函數參數的類型，容器也可以使用與簡單類型比對的類型。例如：

<beans>

   <bean id="exampleBean" class="examples.ExampleBean">
      <constructor-arg type="int" value="2001"/>
      <constructor-arg type="java.lang.String" value="Zara"/>
   </bean>

</beans>

最後并且也是最好的傳遞構造函數參數的方式，使用 index 屬性來顯式的指定構造函數參數的索引。下面是基于索引為 0 的例子，如下所示：

<beans>

   <bean id="exampleBean" class="examples.ExampleBean">
      <constructor-arg index="0" value="2001"/>
      <constructor-arg index="1" value="Zara"/>
   </bean>

</beans>

最後，如果你想要向一個對象傳遞一個引用，你需要使用标簽的 ref 屬性，如果你想要直接傳遞值，那麼你應該使用如上所示的 value 屬性。

二、Spring 基于設值函數的依賴注入

Spring 基于設值函數的依賴注入

當容器調用一個無參的構造函數或一個無參的靜态 factory 方法來初始化你的 bean 後，通過容器在你的 bean 上調用設值函數，基于設值函數的 DI 就完成了。

示例：

下述例子顯示了一個類 TextEditor，它隻能使用純粹的基于設值函數的注入來實作依賴注入。

讓我們用 Eclipse IDE 适當地工作，并按照以下步驟建立一個 Spring 應用程式。

步驟	描述
1	建立一個名為 SpringExample 的項目，并在建立的項目中的 src 檔案夾下建立包 com.tutorialspoint 。
2	使用 Add External JARs 選項添加必需的 Spring 庫，解釋見 Spring Hello World Example chapter.
3	在 com.tutorialspoint 包下建立 Java類 TextEditor，SpellChecker 和 MainApp。
4	在 src 檔案夾下建立 Beans 的配置檔案 Beans.xml 。
5	最後一步是建立所有 Java 檔案和 Bean 配置檔案的内容并按照如下所示的方法運作應用程式。

下面是 TextEditor.java 檔案的内容：

package com.tutorialspoint;
public class TextEditor {
   private SpellChecker spellChecker;
   // a setter method to inject the dependency.
   public void setSpellChecker(SpellChecker spellChecker) {
      System.out.println("Inside setSpellChecker." );
      this.spellChecker = spellChecker;
   }
   // a getter method to return spellChecker
   public SpellChecker getSpellChecker() {
      return spellChecker;
   }
   public void spellCheck() {
      spellChecker.checkSpelling();
   }
}

在這裡，你需要檢查設值函數方法的名稱轉換。要設定一個變量 spellChecker，我們使用 setSpellChecker() 方法，該方法與 Java POJO 類非常相似。讓我們建立另一個依賴類檔案 SpellChecker.java 的内容：

package com.tutorialspoint;
public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   }  
}

以下是 MainApp.java 檔案的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
             new ClassPathXmlApplicationContext("Beans.xml");
      TextEditor te = (TextEditor) context.getBean("textEditor");
      te.spellCheck();
   }
}

下面是配置檔案 Beans.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-3.0.xsd">

   <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <property name="spellChecker" ref="spellChecker"/>
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>

</beans>

你應該注意定義在基于構造函數注入和基于設值函數注入中的 Beans.xml 檔案的差別。唯一的差別就是在基于構造函數注入中，我們使用的是〈bean〉标簽中的〈constructor-arg〉元素，而在基于設值函數的注入中，我們使用的是〈bean〉标簽中的〈property〉元素。

第二個你需要注意的點是，如果你要把一個引用傳遞給一個對象，那麼你需要使用标簽的 ref 屬性，而如果你要直接傳遞一個值，那麼你應該使用 value 屬性。

當你完成了建立源和 bean 配置檔案後，讓我們開始運作應用程式。如果你的應用程式運作順利的話，那麼将會輸出下述所示消息：

Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.

使用 p-namespace 實作 XML 配置：

如果你有許多的設值函數方法，那麼在 XML 配置檔案中使用 p-namespace 是非常友善的。讓我們檢視一下差別：

以帶有标簽的标準 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-3.0.xsd">

   <bean id="john-classic" class="com.example.Person">
      <property name="name" value="John Doe"/>
      <property name="spouse" ref="jane"/>
   </bean>

   <bean name="jane" class="com.example.Person">
      <property name="name" value="John Doe"/>
   </bean>

</beans>

上述 XML 配置檔案可以使用 p-namespace 以一種更簡潔的方式重寫，如下所示：

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="john-classic" class="com.example.Person"
      p:name="John Doe"
      p:spouse-ref="jane"/>
   </bean>

   <bean name="jane" class="com.example.Person"
      p:name="John Doe"/>
   </bean>

</beans>

在這裡，你不應該差別指定原始值和帶有 p-namespace 的對象引用。-ref 部分表明這不是一個直接的值，而是對另一個 bean 的引用。

三、Spring 注入内部 Beans

注入内部 Beans

正如你所知道的 Java 内部類是在其他類的範圍内被定義的，同理，inner beans 是在其他 bean 的範圍内定義的 bean。是以在或元素内元素被稱為内部bean，如下所示。

<?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-3.0.xsd">

   <bean id="outerBean" class="...">
      <property name="target">
         <bean id="innerBean" class="..."/>
      </property>
   </bean>

</beans>

例子

我們在适當的位置使用 Eclipse IDE，然後按照下面的步驟來建立一個 Spring 應用程式：

步驟	描述
1	建立一個名稱為 SpringExample 的項目，并且在建立項目的 src 檔案夾中建立一個包 com.tutorialspoint 。
2	使用 Add External JARs 選項，添加所需的 Spring 庫，解釋見 Spring Hello World Example 章節。 option as explained in the chapter.
3	在 com.tutorialspoint 包中建立Java類TextEditor、SpellChecker 和 MainApp。
4	在 src 檔案夾中建立 Beans 配置檔案 Beans.xml。
5	最後一步是建立的所有Java檔案和Bean配置檔案的内容，并運作應用程式，解釋如下所示。

這裡是 TextEditor.java 檔案的内容：

package com.tutorialspoint;
public class TextEditor {
   private SpellChecker spellChecker;
   // a setter method to inject the dependency.
   public void setSpellChecker(SpellChecker spellChecker) {
      System.out.println("Inside setSpellChecker." );
      this.spellChecker = spellChecker;
   }  
   // a getter method to return spellChecker
   public SpellChecker getSpellChecker() {
      return spellChecker;
   }
   public void spellCheck() {
      spellChecker.checkSpelling();
   }
}

下面是另一個依賴的類檔案 SpellChecker.java 内容：

package com.tutorialspoint;
public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }   
}

下面是 MainApp.java 檔案的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      TextEditor te = (TextEditor) context.getBean("textEditor");
      te.spellCheck();
   }
}

下面是使用内部 bean 為基于 setter 注入進行配置的配置檔案 Beans.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-3.0.xsd">

   <!-- Definition for textEditor bean using inner bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <property name="spellChecker">
         <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"/>
       </property>
   </bean>

</beans>

一旦你建立源代碼和 bean 配置檔案完成後，我們就可以運作該應用程式。如果你的應用程式一切都正常，将輸出以下資訊：

Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.

四、Spring 注入集合

注入集合

你已經看到了如何使用 value 屬性來配置基本資料類型和在你的 bean 配置檔案中使用

<property>

标簽的 ref 屬性來配置對象引用。這兩種情況下處理奇異值傳遞給一個 bean。

現在如果你想傳遞多個值，如 Java Collection 類型 List、Set、Map 和 Properties，應該怎麼做呢。為了處理這種情況，Spring 提供了四種類型的集合的配置元素，如下所示：

元素	描述
<list>	它有助于連線，如注入一列值，允許重複。
<set>	它有助于連線一組值，但不能重複。
<map>	它可以用來注入名稱-值對的集合，其中名稱和值可以是任何類型。
<props>	它可以用來注入名稱-值對的集合，其中名稱和值都是字元串類型。

你可以使用

<list>

或

<set>

來連接配接任何

java.util.Collection

的實作或數組。

你會遇到兩種情況（a）傳遞集合中直接的值（b）傳遞一個 bean 的引用作為集合的元素。

例子

我們在适當的位置使用 Eclipse IDE，然後按照下面的步驟來建立一個 Spring 應用程式：

步驟	描述
1	建立一個名稱為 SpringExample 的項目，并且在建立項目的 src 檔案夾中建立一個包 com.tutorialspoint 。
2	使用 Add External JARs 選項，添加所需的 Spring 庫，解釋見 Spring Hello World Example 章節。 option as explained in the chapter.
3	在 com.tutorialspoint 包中建立Java類TextEditor、SpellChecker 和 MainApp。
4	在 src 檔案夾中建立 Beans 配置檔案 Beans.xml。
5	最後一步是建立的所有Java檔案和Bean配置檔案的内容，并運作應用程式，解釋如下所示。

這裡是 JavaCollection.java 檔案的内容：

package com.tutorialspoint;
import java.util.*;
public class JavaCollection {
   List addressList;
   Set  addressSet;
   Map  addressMap;
   Properties addressProp;
   // a setter method to set List
   public void setAddressList(List addressList) {
      this.addressList = addressList;
   }
   // prints and returns all the elements of the list.
   public List getAddressList() {
      System.out.println("List Elements :"  + addressList);
      return addressList;
   }
   // a setter method to set Set
   public void setAddressSet(Set addressSet) {
      this.addressSet = addressSet;
   }
   // prints and returns all the elements of the Set.
   public Set getAddressSet() {
      System.out.println("Set Elements :"  + addressSet);
      return addressSet;
   }
   // a setter method to set Map
   public void setAddressMap(Map addressMap) {
      this.addressMap = addressMap;
   }  
   // prints and returns all the elements of the Map.
   public Map getAddressMap() {
      System.out.println("Map Elements :"  + addressMap);
      return addressMap;
   }
   // a setter method to set Property
   public void setAddressProp(Properties addressProp) {
      this.addressProp = addressProp;
   } 
   // prints and returns all the elements of the Property.
   public Properties getAddressProp() {
      System.out.println("Property Elements :"  + addressProp);
      return addressProp;
   }
}

下面是 MainApp.java 檔案的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
             new ClassPathXmlApplicationContext("Beans.xml");
      JavaCollection jc=(JavaCollection)context.getBean("javaCollection");
      jc.getAddressList();
      jc.getAddressSet();
      jc.getAddressMap();
      jc.getAddressProp();
   }
}

下面是配置所有類型的集合的配置檔案 Beans.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-3.0.xsd">

   <!-- Definition for javaCollection -->
   <bean id="javaCollection" class="com.tutorialspoint.JavaCollection">

      <!-- results in a setAddressList(java.util.List) call -->
      <property name="addressList">
         <list>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
         </list>
      </property>

      <!-- results in a setAddressSet(java.util.Set) call -->
      <property name="addressSet">
         <set>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
            <value>USA</value>
        </set>
      </property>

      <!-- results in a setAddressMap(java.util.Map) call -->
      <property name="addressMap">
         <map>
            <entry key="1" value="INDIA"/>
            <entry key="2" value="Pakistan"/>
            <entry key="3" value="USA"/>
            <entry key="4" value="USA"/>
         </map>
      </property>

      <!-- results in a setAddressProp(java.util.Properties) call -->
      <property name="addressProp">
         <props>
            <prop key="one">INDIA</prop>
            <prop key="two">Pakistan</prop>
            <prop key="three">USA</prop>
            <prop key="four">USA</prop>
         </props>
      </property>

   </bean>

</beans>

一旦你建立源代碼和 bean 配置檔案完成後，我們就可以運作該應用程式。你應該注意這裡不需要配置檔案。如果你的應用程式一切都正常，将輸出以下資訊：

List Elements :[INDIA, Pakistan, USA, USA]
Set Elements :[INDIA, Pakistan, USA]
Map Elements :{1=INDIA, 2=Pakistan, 3=USA, 4=USA}
Property Elements :{two=Pakistan, one=INDIA, three=USA, four=USA}

注入 Bean 引用

下面的 Bean 定義将幫助你了解如何注入 bean 的引用作為集合的元素。甚至你可以将引用和值混合在一起，如下所示：

<?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-3.0.xsd">

   <!-- Bean Definition to handle references and values -->
   <bean id="..." class="...">

      <!-- Passing bean reference  for java.util.List -->
      <property name="addressList">
         <list>
            <ref bean="address1"/>
            <ref bean="address2"/>
            <value>Pakistan</value>
         </list>
      </property>

      <!-- Passing bean reference  for java.util.Set -->
      <property name="addressSet">
         <set>
            <ref bean="address1"/>
            <ref bean="address2"/>
            <value>Pakistan</value>
         </set>
      </property>

      <!-- Passing bean reference  for java.util.Map -->
      <property name="addressMap">
         <map>
            <entry key="one" value="INDIA"/>
            <entry key ="two" value-ref="address1"/>
            <entry key ="three" value-ref="address2"/>
         </map>
      </property>

   </bean>

</beans>

為了使用上面的 bean 定義，你需要定義 setter 方法，它們應該也能夠是用這種方式來處理引用。

注入 null 和空字元串的值

如果你需要傳遞一個空字元串作為值，那麼你可以傳遞它，如下所示：

<bean id="..." class="exampleBean">
   <property name="email" value=""/>
</bean>

前面的例子相當于 Java 代碼：exampleBean.setEmail("")。

如果你需要傳遞一個 NULL 值，那麼你可以傳遞它，如下所示：

<bean id="..." class="exampleBean">
   <property name="email"><null/></property>
</bean>

前面的例子相當于 Java 代碼：exampleBean.setEmail(null)。

Spring 依賴注入Spring 依賴注入一、Spring 基于構造函數的依賴注入二、Spring 基于設值函數的依賴注入三、Spring 注入内部 Beans 四、Spring 注入集合

Spring 依賴注入

依賴注入

一、Spring 基于構造函數的依賴注入

Spring 基于構造函數的依賴注入

示例：

構造函數參數解析:

二、Spring 基于設值函數的依賴注入

Spring 基于設值函數的依賴注入

示例：

使用 p-namespace 實作 XML 配置：

三、Spring 注入内部 Beans

注入内部 Beans

例子

四、Spring 注入集合

注入集合

例子

注入 Bean 引用

注入 null 和空字元串的值

繼續閱讀

MyBatis-Plus 之AR模式

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法