2. 程式人生 > >Spring Bean管理--依賴注入、自動裝配

Spring Bean管理--依賴注入、自動裝配

阿新 • • 發佈：2019-02-19

一、摘要

本文主要介紹Spring Bean管理的依賴注入（Dependency Injection，DI）部分：基於Setter方法注入，建構函式注入，自動裝配注入，@Autowired註解注入等。

二、依賴注入

所謂注入，就是給某一個bean例項的屬性設值時，無需顯性編寫Java程式碼就可以實現屬性賦值；所謂依賴注入，則通常指bean例項引用了其它例項，如常見的service引用dao，則對於service來說，用到的dao就需要依賴注入，spring ioc容器在建立service bean時會根據既定規則自動注入dao例項。

1、基於建構函式的依賴注入

建構函式注入也就是通過構造方法注入依賴，建構函式的引數一般情況下就是依賴項，spring容器會根據bean中指定的建構函式引數來決定呼叫那個建構函式，看一個案例：

TextEditor.java

package com.marcus.spring.beans;

public class TextEditor {
	private SpellChecker spellChecker;
	private String generateType;
	private String text;
	
	@SuppressWarnings("rawtypes")
	private List keywords;
	
	public TextEditor() {
	}
	@SuppressWarnings("rawtypes")
	public TextEditor(
 
List list) {
		System.out.println("Inside TextEditor constructor(list).");
		this.keywords = list;
	}	
	public TextEditor(SpellChecker spellChecker) {
		System.out.println("Inside TextEditor constructor(checker).");
		this.spellChecker = spellChecker;
	}	
	public TextEditor(SpellChecker spellChecker,
 
 String generateType) {
		System.out.println("Inside TextEditor constructor.");
		this.spellChecker = spellChecker;
		this.generateType = generateType;
	}
	public TextEditor(SpellChecker spellChecker, String generateType, String text) {
		System.out.println("Inside TextEditor constructor(checker, generteType, text).");
		this.spellChecker = spellChecker;
		this.generateType = generateType;
		this.text = text;
	}
	public String getText() {
		return this.text;
	}
	public void setText(String text) {
		this.text = text;
	}			
	public String getGenerateType() {
		System.out.println("TextEditor generate type: " + this.generateType);
		return this.generateType;
	}
	@SuppressWarnings("rawtypes")
	public List getKeyWords() {
		return this.keywords;
	}	
	public void spellCheck() {
		spellChecker.checkSpelling("TextEditor");
	}
}

SpellChecker.java

package com.marcus.spring.beans;

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

public class SpellChecker {
	@SuppressWarnings("rawtypes")
	private List wordsList;
	
	@SuppressWarnings("rawtypes")
	private Set wordsSet;
	
	@SuppressWarnings("rawtypes")
	private Map wordsMap;
	
	Properties wordsProp;
	
	public SpellChecker() {
		System.out.println("Inside SpellChecker constructor.");
	}	
	public String checkSpelling(String text) {
		String result = "success";
		String errWords = "";
		if (text == null || text.trim().length() < 1 
				|| wordsList == null || wordsList.size() < 1) {
			return result;
		}
		String[] words = text.trim().split(",");
		for(String word : words) {
			if (word != null && word.trim().length() > 0) {
				if(! wordsList.contains(word.trim().toLowerCase())) {
					errWords += "".equals(errWords) ? word.trim() : "," + word.trim();
				}
			}
		}
		return errWords.length() < 1 ? result : errWords + " spells error!";
	}
	@SuppressWarnings("rawtypes")
	public void setWordsList(List wordsList) {
		this.wordsList = wordsList;
	}
	@SuppressWarnings("rawtypes")
	public List getWordsList() {
		System.out.println("List Elements :" + wordsList);
		return wordsList;
	}
	
	@SuppressWarnings("rawtypes")
	public void setWordsSet(Set wordsSet) {
		this.wordsSet = wordsSet;
	}
	@SuppressWarnings("rawtypes")
	public Set getWordsSet() {
		System.out.println("Set Elements :" + wordsSet);
		return wordsSet;
	}
	
	@SuppressWarnings("rawtypes")
	public void setWordsMap(Map wordsMap) {
		this.wordsMap = wordsMap;
	}
	@SuppressWarnings("rawtypes")
	public Map getWordsMap() {
		System.out.println("Map Elements :" + wordsMap);
		return wordsMap;
	}
	
	public void setWordsProp(Properties wordsProp) {
		this.wordsProp = wordsProp;
	}
	public Properties getWordsProp() {
		System.out.println("Property Elements :" + wordsProp);
		return wordsProp;
	}
}

ioc-di.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="textEditor" class="com.marcus.spring.beans.TextEditor">
      <constructor-arg ref="spellChecker"/>
   </bean>
   <bean id="textEditor2" class="com.marcus.spring.beans.TextEditor">
      <constructor-arg ref="spellChecker"/>
      <constructor-arg type="java.lang.String" value="constructor(checker, generatType)"/>
   </bean>
   <bean id="textEditor3" class="com.marcus.spring.beans.TextEditor">
      <constructor-arg ref="spellChecker"/>
      <constructor-arg type="java.lang.String" index="1" value="constructor(checker, generatType)"/>
      <constructor-arg type="java.lang.String" index="2" value="Text, Wood, SuperMen"/>
   </bean> 
   <bean id="textEditor4" class="com.marcus.spring.beans.TextEditor">
      <constructor-arg type="java.util.List">
         <list>
            <value>INDIA</value>
            <value>Pakistan</value>
            <value>USA</value>
         </list>      	
      </constructor-arg>
   </bean>       
   <bean id="spellChecker" class="com.marcus.spring.beans.SpellChecker" />
</beans>

該配置檔案定義了TextEditor的3個例項，對應TextEditor的3個建構函式。spring ioc容器會根據引數型別嘗試查詢合適的建構函式並建立TextEditor例項，因此＜constructor-arg＞的注入順序並不重要。

請注意textEditor3，其建構函式後兩個引數型別都是string，此時，我們必須標記引數位置索引index，否則對於spring ioc容器來說是一個災難。

請注意textEditor4，其建構函式引數是一個集合，map、set等其它集合類似。

如果你想向一個物件傳遞一個引用，你需要使用標籤的 ref 屬性，如果你想直接傳遞值，那麼你應該使用如上所示的 value 屬性，如果引數是集合型別則參考textEditor4。

測試類BeanDIApp.java

package com.marcus.spring.beans;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanDIApp {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("ioc-di.xml");
		
     System.out.println("=================================================");
		TextEditor textEditor = context.getBean("textEditor", TextEditor.class);
		System.out.println("textEditor: " + textEditor.toString());
		
		TextEditor textEditor2 = context.getBean("textEditor2", TextEditor.class);
		System.out.println("textEditor2: " + textEditor2.toString());

		TextEditor textEditor3 = context.getBean("textEditor3", TextEditor.class);
		System.out.println("textEditor3: " + textEditor3.toString());
		System.out.println("textEditor3->text: " + textEditor3.getText());

		TextEditor textEditor4 = context.getBean("textEditor4", TextEditor.class);
		System.out.println("textEditor4: " + textEditor4.toString());
		System.out.println("textEditor4->keywords: " + textEditor4.getKeyWords());
		context.close();
	}
}

輸出結果

Inside SpellChecker constructor.
Inside TextEditor constructor(checker).
Inside TextEditor constructor(checker, generteType).
Inside TextEditor constructor(checker, generteType, text).
Inside TextEditor constructor(list).
=================================================
textEditor: com.marcus.spring.beans.TextEditor@14bf9759
textEditor2: com.marcus.spring.beans.TextEditor@5f341870
textEditor3: com.marcus.spring.beans.TextEditor@589838eb
textEditor3->text: Text, Wood, SuperMen
textEditor4: com.marcus.spring.beans.TextEditor@544fe44c
textEditor4->keywords: [INDIA, Pakistan, USA]

迴圈依賴

建構函式迴圈依賴，class A構造時引用B，class B構造時引用A，就是迴圈依賴，這種情況下spring ioc容器無法例項化這兩個bean，會報Is there an unresolvable circular reference?看一個案例：

LoopDependA.java

package com.marcus.spring.beans;

public class LoopDependA {
	private LoopDependB dependB;
	public LoopDependA(){
	}
	public LoopDependA(LoopDependB dependB) {
		this.dependB = dependB;
	}
	public void setDependency(LoopDependB dependB) {
		this.dependB = dependB;
	}
	public LoopDependB getDependency() {
		return this.dependB;
	}
}

LoopDependB.java

package com.marcus.spring.beans;

public class LoopDependB {
	private LoopDependA dependA;
	public LoopDependB() {
	}
	public LoopDependB(LoopDependA dependA) {
		this.dependA = dependA;
	}
	
	public void setDependency(LoopDependA dependA) {
		this.dependA = dependA;
	}
	public LoopDependA getDependency() {
		return this.dependA;
	}
}

ioc-di-loop.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="loopA" class="com.marcus.spring.beans.LoopDependA">
      <constructor-arg ref="loopB"/>
   </bean>
   <bean id="loopB" class="com.marcus.spring.beans.LoopDependB">
      <constructor-arg ref="loopA"/>
   </bean>
    -->
   <bean id="loopA" class="com.marcus.spring.beans.LoopDependA">
   	<property name="dependency" ref="loopB" />
   </bean>
   <bean id="loopB" class="com.marcus.spring.beans.LoopDependB">
   	<property name="dependency" ref="loopA" />
   </bean>
</beans>

建構函式迴圈依賴時，spring ioc容器無法例項化這2個bean，簡單理解就是競爭鎖，A例項化時需要B（B尚未例項化），B例項化需要A（A尚未例項化），A等B，B等A，誰也建立不了。

換成Setter注入，則可以，原因是Setter注入是在bean例項化完成之後通過呼叫set方法完成。因此，強烈不建議在配置檔案中使用迴圈依賴。

DILoopApp.java 測試類和輸出結果

package com.marcus.spring.beans;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * BeanApp.
 */
public class DILoopApp {
	public static void main(String[] args) {
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("ioc-di-loop.xml");
		
		LoopDependA loopA = context.getBean("loopA", LoopDependA.class);
		System.out.println("LoopDependA->getDependency(), " + loopA.getDependency());
		
		LoopDependB loopB = context.getBean("loopB", LoopDependB.class);
		System.out.println("LoopDependB->getDependency(), " + loopB.getDependency());
		
		context.close();
		
		//輸出結果
		//LoopDependA->getDependency(), com.marcus.spring.beans.LoopDependB@77cd7a0
		//LoopDependB->getDependency(), com.marcus.spring.beans.LoopDependA@204f30ec
	}
}

小結

  • 引用型別請用標籤的 ref 屬性，簡單值型別請用標籤的value屬性，如果是集合型別則參考上文的textEditor4例項配置
  • 多個引數請設定type屬性
  • 多個引數型別一致時，如多個字串等，請設定index屬性
  • 避免迴圈依賴

2、基於Setter函式的依賴注入

Setter注入顧名思義，被注入的屬性需要有set方法， Setter注入支援簡單型別、集合型別和引用型別，Setter注入時在bean例項建立完成後執行。Setter注入與建構函式注入唯一的區別就是在基於建構函式注入中，我們使用的是〈bean〉標籤中的〈constructor-arg〉元素，而在基於設值函式的注入中，我們使用的是〈bean〉標籤中的〈property〉元素。看一個案例：

TextEditor.java, SpellChecker.java 同上例

ioc-di2.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"
    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="textEditor" class="com.marcus.spring.beans.TextEditor">
   	<property name="spellChecker" ref="spellChecker"/>
   	<property name="text" value="Text, Wood, SuperMen"/>
   </bean>
   
   <bean id="textEditor2" class="com.marcus.spring.beans.TextEditor"
      p:spellChecker-ref="spellChecker" p:text="Text, Wood, SuperMen, Compute"/>

   <bean id="spellChecker" class="com.marcus.spring.beans.SpellChecker">
   	<property name="wordsList">
    	<list>
            <value>text</value>
            <value>wood</value>
            <value>superman</value>
    	</list>
   	</property>
   </bean>
</beans>

例項textEditor設定了2個屬性：spellChecker和text，textEditor2功能等同textEditor，但是我們發現設定屬性值時簡單了很多。

可以使用 p-namespace 以一種更簡潔的方式來設定bean屬性值，要求配置檔案必須引入xmlns:p=“http://www.springframework.org/schema/p”，參考textEditor2 bean配置。

相關推薦

Spring Bean管理--依賴注入、自動裝配

一、摘要 本文主要介紹Spring Bean管理的依賴注入（Dependency Injection，DI）部分：基於Setter方法注入，建構函式注入，自動裝配注入，@Autowired註解注入等。 二、依賴注入 所謂注入，就是給某一個bean例項的屬性設值時

Spring依賴注入 — 屬性自動裝配

設定屬性值的三種基本方式： 在Bean定義檔案中使用<value>指定字串以及基本型別值。 使用<ref>直接指定參考至其他Bean例項。 使用<bean>標籤指定value屬性。 自動裝配方式 屬性值 說明 byName 容器將查詢與屬性名相

依賴注入和自動裝配

參考：https://zhidao.baidu.com/question/1577675767538514300.html          https://blog.csdn.net/u012843873/article/details/52399206之前一直沒有注意一個

Spring 學習筆記（五）—— Bean之間的關系、作用域、自動裝配

mar byname pps etc 有時 sysman 對象實例 構造 encoding 繼承 　　Spring提供了配置信息的繼承機制，可以通過為<bean>元素指定parent值重用已有的<bean>元素的配置信息。 <?xml

java之Spring裝配Bean（手動裝配、自動裝配、註解裝配）

fault tran 常見 成員 如果 on() base 反轉 tor 在上一篇控制反轉中我們看到了依靠一個Bean文件來實現對代碼的控制，可謂十分便捷，再也不用去實例化對象了，2333~~~ 1.手動裝配 1 <bean id="todo" class="

23、自動裝配-Aware注入Spring底層元件&原理

23、自動裝配-Aware注入Spring底層元件&原理 Aware 介面，提供了類似回撥函式的功能 自定義元件想要使用Spring 容器底層的一些元件（Application Context，Bean Factory）;自定義元件需要實現xxxAware介面；在建立物件的時候，會呼叫介面

Spring-方法注入、depends-on、自動裝配協作物件

方法注入 對於大部分的使用者來說，容器中多數的bean是singleton的。當一個singleton的bean需要同另一個singleton的bean合作（使用）時，或者一個非singleton的bean需要同另外一個非singleton的bean合作的時候，通過定義一個

25、自動裝配-@Profile根據環境註冊bean

激活 void default tty pre face 運行時 local 參數 25、自動裝配-@Profile根據環境註冊bean 指定組件在哪個環境的情況下才能被註冊到容器中 加了環境標識的，只有這個環境被激活才能註冊到組件中 默認是default環境 寫在類上，

25、自動裝配[email protected]根據環境註冊bean

25、自動裝配[email protected]根據環境註冊bean 指定元件在哪個環境的情況下才能被註冊到容器中 加了環境標識的，只有這個環境被啟用才能註冊到元件中 預設是default環境 寫在類上，整個配置類的啟用的時候才能生效 沒有標註環境標識的bean，在任何環境下

Spring之 IOC的繼續---bean標籤 --依賴注入 DI

引用官方的 標準配置 IOC 中 bean 標籤和管理物件細節 bean 標籤作用：用於配置物件讓 spring 來建立的。 * 預設情況下它呼叫的是類中的無參建構函式。如果沒有無參建構函式則不能建立成屬性 ：id：給物件在容器中提供一個唯一標識。用於獲取物件。 class：

控制反轉IOC的依賴注入方式 【調侃】IOC前世今生 IoC模式 談談對Spring IOC的理解 一個簡單的小程式演示Unity的三種依賴注入方式 小菜學習設計模式（五）—控制反轉（Ioc） IoC模式（依賴、依賴倒置、依賴注入、控制反轉） IoC模式

轉自：https://www.cnblogs.com/ysyn/p/5563256.html 引言：  　　專案中遇到關於IOC的一些內容，因為和正常的邏輯程式碼比較起來，IOC有點反常。因此本文記錄IOC的一些基礎知識，並附有相應的簡單例項，而在實際專案中再複雜的應用也只是在

關於laravel 自動載入和依賴注入、服務容器、服務提供者的理解--1

class Container {     protected $binds;      protected $instances;     public function bind($abstract, $concrete)     {         if ($concrete instanceof C

Spring Boot自動配置（Auto-Configuration），@EnableAutoConfiguration，Spring Beans和依賴注入

自動配置（Auto-Configuration） 自動配置（auto-configuration）是Spring Boot最重要的特性之一，因為該特性會根據應用的classpath（這個主要是根據maven pom.xml決定），annotations和其他的

spring ioc中例項化bean以及依賴注入bean和基本型別屬性簡單實現方案

Spring兩個重要特性IOC和AOP，本文中簡單實現bean的建立以及屬性依賴注入。 實現步驟如下: 1、通過dom4j解析bean.xml檔案,將bean物件以及依賴屬性裝入List。 2、遍歷list，通過反射機制例項化物件。 3、遍歷list，通過反射呼叫bean裡

【Spring註解】四、自動裝配@[email protec

四、自動裝配 [email protected]&@Qualifier和@Primary @Autowried是Spring2.5定義的自動裝配的註解,它可以對類成員變數、方法及建構函式進行標註，完成自動裝配的工作。 使用 @Au

Bean配置、屬性配置、自動裝配

一、配置Bean概述 1、配置形式： ①基於xml檔案 ②基於註解 2、配置方式： ①通過全類名(反射) ②通過工廠方法(靜態工廠方法、例項工廠方法) ③FactoryBean 3、依賴注入方式： ①屬性注入 ②構造器注入 二、Spring配

【Spring原始碼--IOC容器的實現】（六）Bean的依賴注入

程式碼1.:8：BeanWrapperImpl類的setPropertyValue方法： @SuppressWarnings("unchecked") private void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) t

Spring依賴配置與自動裝配的先後順序問題

在Spring配置當中，物件的依賴可以通過顯示的<property>進行配置，也可以通過autowire自動裝配。 那麼問題來了：如果一個依賴進行了<property>配置，同時又存在符合的物件進行了autowire裝配，最終保留哪個，其先後順序是

使用XPath解析xml實現簡單的Spring IOC完成bean的依賴注入

幾天使用Xpath解析xml檔案，例項化bean，完成spring IOC bean的依賴注入的簡單實現。 假設用如下格式的bean檔案： <?xml version="1.0" encoding="UTF-8"?> <beans> <b

【Spring學習筆記】7：裝配bean的三種方式(自動裝配,JavaConfig,XML),配置匯入

跟著《Spring實戰》徹底系統地學習一下Spring。 對Spring的新認識 Spring的關鍵 基於POJO的輕量級和最小侵入性程式設計。 通過DI和麵向介面實現鬆耦合。 基於切面和慣例進行宣告式程式設計。 通過切面和模板減少樣板式程式碼。 所