ioc在spring中的作用有哪些

今天就跟大家聊聊有關ioc在spring中的作用有哪些，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。

IoC——Inversion of Control，控制反轉

在Java開發中，IoC意味著將你設計好的類交給系統去控制，而不是在你的類內部控制。IoC是一種讓服務消費者不直接依賴于服務提供者的組件設計方式，是一種減少類與類之間依賴的設計原則。 

DI——Dependency Injection（依賴注入）

即組件之間的依賴關系由容器在運行期決定，形象的來說，即由容器動態的將某種依賴關系注入到組件之中。
依賴注入的目標并非為軟件系統帶來更多的功能，而是為了提升組件重用的概率，并為系統搭建一個靈活、可擴展的平臺。通過依賴注入機制，我們只需要通過簡單的配置，而無需任何代碼就可指定目標需要的資源，完成自身的業務 邏輯，而不用關心具體的資源來自何處、由誰實現。

1：控制反轉：

誰控制誰？控制什么？為何叫反轉（對應于正向）？哪些方面反轉了 ？為何需要反轉？

2：依賴：

什么是依賴（按名詞理解，按動詞理解）？誰依賴于誰？為什么需要依賴？依賴什么東西？

3：注入：

誰注入于誰？注入什么東西？為何要注入?

4：依賴注入和控制反轉是同一概念嗎？

5：參與者都有哪些？

6：IoC/DI是什么？能做什么？怎么做？用在什么地方？

還不能完全回答和理解，沒有關系，先來看看IoC/DI的基本思想演變，然后再回頭來回答這些問題

IoC容器

簡單的理解就是：實現IoC思想，并提供對象創建、對象裝配以及對象生命周期管理的軟件就是IoC容器。

IoC理解

1：應用程序無需主動new對象；而是描述對象應該如何被創建即可

IoC容器幫你創建，即被動實例化；

2：應用程序不需要主動裝配對象之間的依賴關系，而是描述需要哪個服務

IoC容器會幫你裝配（即負責將它們關聯在一起），被動接受裝配；

3：主動變被動，體現好萊塢法則：別打電話給我們，我們會打給你

4：體現迪米特法則（最少知識原則）：應用程序不知道依賴的具體實現，只知道需要提供某類服務的對象（面向接口編程）；并松散耦合，一個對象應當對其他對象有盡可能少的了解，不和陌生人（實現）說話

5：是一種讓服務消費者不直接依賴于服務提供者的組件設計方式，是一種減少類與類之間依賴的設計原則。

使用IoC/DI容器開發需要改變的思路

1：應用程序不主動創建對象，但要描述創建它們的方式。

2：在應用程序代碼中不直接進行服務的裝配，但要描述哪一個組件需要哪一項服務，由容器負責將這些裝配在一起。

也就是說：所有的組件都是被動的，組件初始化和裝配都由容器負責，應用程序只是在獲取相應的組件后，實現應用的功能即可。 

提醒一點

IoC/DI是思想，不是純實現技術。IoC是框架共性，只是控制權的轉移，轉移到框架，所以不能因為實現了IoC就叫IoC容器，而一般除了實現了IoC外，還具有DI功能的才叫IoC容器，因為容器除了要負責創建并裝配組件關系，還需要管理組件生命周期。

n工具準備

1：Eclipse + Jdk6.0 ，示例用的Eclipse是Eclipse Java EE IDE for Web Developers，Version: Helios Service Release 1

2：spring-framework-3.1.0.M2-with-docs.zip

構建環境

1：在Eclipse里面新建一個工程，設若名稱是Spring3test

2：把發行包里面的dist下面的jar包都添加到Eclipse里面

3：根據Spring的工程來獲取Spring需要的依賴包，在聯網的情況下，通過Ant運行projects/build-spring-framework/build.xml，會自動去下載所需要的jar包，下載后的包位于projects/ivy-cache/repository下面。

4：為了方便，把這些jar包也添加到Eclipse里面

開發接口

java代碼：

public interface HelloApi { 
public String helloSpring3(int a); 
}

開發實現類

java代碼：

public class HelloImpl implements HelloApi{ 
public String helloSpring3(int a){ 
System.out.println("hello Spring3==="+a); 
return "Ok,a="+a; 
} 
} 

配置文件

1：在src下面新建一個文件叫applicationContext.xml

2：在Spring發行包里面搜索一個例子，比如使用：projects\org.springframework.context\src\test\java\org\springframework\jmx下的applicationContext.xml，先把里面的配置都刪掉，留下基本的xml定義和根元素就可以了,它是一個DTD版的，而且還是2.0版的。

建議使用Spring3的Schema版本，示例如下：  

java代碼：

<&#63;xml version="1.0" encoding="UTF-8"&#63;> 
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:context="http://www.springframework.org/schema/context" 
xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx" 
xsi:schemaLocation=" 
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
"> 
……………………… 
</beans> 

4：配置applicationContext.xml如下：

java代碼：

<bean name="helloBean" class="com.bjpowernode.Spring3.hello.HelloImpl"></bean> 

編寫客戶端如下：

java代碼：

package com.bjpowernode.Spring3.hello;  
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
public class Client { 
public static void main(String[] args) { 
ApplicationContext context = new ClassPathXmlApplicationContext( 
 new String[] {"applicationContext.xml"}); 
HelloApi api = (HelloApi)context.getBean("helloBean"); 
String s = api.helloSpring3(3); 
System.out.println("the s="+s); 
} 
} 

審視和結論

1：所有代碼中（除測試代碼之外），并沒有出現Spring的任何組件 。

2：客戶代碼（這里就是我們的測試代碼）僅僅面向接口編程，而無需知道實現類的具體名稱。同時，我們可以很簡單的通過修改配置文件來切換具體的底層實現類 。 

結論

1：首先，我們的組件并不需要實現框架指定的接口，因此可以輕松的將組件從Spring脫離，甚至不需要任何修改（這在基于EJB架實現的應用中是難以想象的）。

2：其次，組件間的依賴關系減少，極大改善了代碼的可重用性和可維護性

3：面向接口編程

什么是Spring中的Bean

在Spring中，那些組成應用的主體及由Spring IoC容器所管理的對象被稱之為bean。簡單地講，bean就是由Spring容器初始化、裝配及被管理的對象，除此之外，bean就沒有特別之處了(與應用中的其他對象沒有什么區別)。而bean定義以及bean相互間的依賴關系將通過配置元數據來描述。

為什么使用Bean這個名字

使用‘bean'這個名字而不是‘組件'(component) 或‘對象'(object)的動機源于Spring框架本身(部分原因則是相對于復雜的EJB而言的)。

Spring的IoC容器

org.springframework.beans.factory.BeanFactory是Spring IoC容器的實際代表者，IoC容器負責容納bean，并對bean進行管理。

Spring IoC容器將讀取配置元數據；并通過它對應用中各個對象進行實例化、配置以及組裝。通常情況下我們使用簡單直觀的XML來作為配置元數據的描述格式。在XML配置元數據中我們可以對那些我們希望通過Spring IoC容器管理的bean進行定義。

IoC/DI是Spring最核心的功能之一， Spring框架所提供的眾多功能之所以能成為一個整體正是建立在IoC的基礎之上

BeanFactory和ApplicationContext

org.springframework.beans及org.springframework.context包是Spring IoC容器的基礎。BeanFactory提供的高級配置機制，使得管理任何性質的對象成為可能。 ApplicationContext是BeanFactory的擴展，功能得到了進一步增強，比如更易與Spring AOP集成、消息資源處理(國際化處理)、事件傳遞及各種不同應用層的context實現(如針對web應用的WebApplicationContext)。

接口選擇之惑

在實際應用中，用戶有時候不知道到底是選擇BeanFactory接口還是ApplicationContext接口。但是通常在構建JavaEE應用時，使用ApplicationContext將是更好的選擇，因為它不僅提供了BeanFactory的所有特性，同時也允許使用更多的聲明方式來得到我們想要的功能。

簡而言之，BeanFactory提供了配制框架及基本功能，而ApplicationContext則增加了更 多支持企業核心內容的功能。ApplicationContext完全由BeanFactory擴展而來，因而BeanFactory所具備的能力和行為也適用于ApplicationContext。

Spring IoC容器的實例化非常簡單，如下面的例子：

1：第一種：

java代碼：

Resource resource = new FileSystemResource("beans.xml"); 
BeanFactory factory = new XmlBeanFactory(resource); 

2：第二種：

java代碼：

ClassPathResource resource = new ClassPathResource("beans.xml"); 
BeanFactory factory = new XmlBeanFactory(resource); 

3：第三種：

java代碼：

ApplicationContext context = new ClassPathXmlApplicationContext( 
 new String[] {"applicationContext.xml", "applicationContext-part2.xml"}); 
// of course, an ApplicationContext is just a BeanFactory 
BeanFactory factory = (BeanFactory) context; 

讀取多個配置文件

第一種方法：

為了加載多個XML文件生成一個ApplicationContext實例，可以將文件路徑作為字符串數組傳給ApplicationContext構造器。而bean factory將通過調用bean defintion reader從多個文件中讀取bean定義。通常情況下，Spring團隊傾向于上述做法，因為這樣各個配置并不會查覺到它們與其他配置文件的組合。

第二種方法：

使用一個或多個的<import/>元素來從另外一個或多個文件加載bean定義。所有的<import/>元素必須放在<bean/>元素之前以完成bean定義的導入。 讓我們看個例子：

java代碼：

<beans><import resource="services.xml"/> 
 <import resource=“/resources/messageSource.xml"/> 
 <import resource="/resources/themeSource.xml"/> 
 <bean id="bean1" class="..."/> 
 <bean id="bean2" class="..."/> 
 </beans> 

配置文件中常見的配置內容

在IoC容器內部，bean的定義由BeanDefinition 對象來表示，該定義將包含以下信息：

1：全限定類名：這通常就是已定義bean的實際實現類。如果通過調用static factory方法來實例化bean，而不是使用常規的構造器，那么類名稱實際上就是工廠類的類名。

2：bean行為的定義，即創建模式（prototype還是singleton）、自動裝配模式、依賴檢查模式、初始化以及銷毀方法。這些定義將決定bean在容器中的行為。

3：用于創建bean實例的構造器參數及屬性值。比如使用bean來定義連接池，可以通過屬性或者構造參數指定連接數，以及連接池大小限制等。

4：bean之間的關系，即協作 (或者稱依賴)。

Bean的命名

每個bean都有一個或多個id(或稱之為標識符或名稱，在術語上可以理解成一回事)，這些id在當前IoC容器中必須唯一。

當然也可以為每個bean定義一個name，但是并不是必須的，如果沒有指定，那么容器將為其生成一個惟一的name。對于不指定name屬性的原因我們會在后面介紹(比如內部bean就不需要)。

Bean命名的約定

bean的命名采用標準的Java命名約定，即小寫字母開頭，首字母大寫間隔的命名方式。如accountManager、 accountService等等。

對bean采用統一的命名約定將會使配置更加簡單易懂。而且在使用Spring AOP，這種簡單的命名方式將會令你受益匪淺。

Bean的別名

一個Bean要提供多個名稱，可以通過alias屬性來加以指定 ，示例如下：

<alias name="fromName" alias="toName"/>

容器如何實例化Bean

當采用XML描述配置元數據時，將通過<bean/>元素的class屬性來指定實例化對象的類型。class屬性主要有兩種用途：在大多數情況下，容器將直接通過 反射調 用指定類的構造器來創建bean(這有點等類似于在Java代碼中使用new操作符)；在極少數情況下，容器將調用類的靜態工廠方法來創建bean實例，class屬性將用來指定實際具有靜態工廠方法的類(至于調用靜態工廠方法創建的對象類型是當前class還是其他的class則無關緊要)。

用構造器來實例化Bean ，前面的實例就是

使用靜態工廠方法實例化

采用靜態工廠方法創建bean時，除了需要指定class屬性外，還需要通過factory-method屬性來指定創建bean實例的工廠方法，示例如下：

<bean id="exampleBean"
 class="examples.ExampleBean2"
 factory-method="createInstance"/>

使用實例工廠方法實例化

使用此機制，class屬性必須為空，而factory-bean屬性必須指定為當前(或其祖先)容器中包含工廠方法的bean的名稱，而該工廠bean的工廠方法本身必須通過factory-method屬性來設定，并且這個方法不能是靜態的，示例如下：

<bean id="exampleBean" factory-bean="myFactoryBean" factory-method="createInstance"/>

使用容器

從本質上講，BeanFactory僅僅只是一個維護bean定義以及相互依賴關系的高級工廠接口。使用getBean(String)方法就可以取得bean的實例；BeanFactory提供的方法極其簡單。n依賴注入（DI） 背后的基本原理
是對象之間的依賴關系（即一起工作的其它對象）只會通過以下幾種方式來實現： 構造器的參數、 工廠方法的參數，或 給由構造函數或者工廠方法創建的對象設 置屬性。

因此，容器的工作就是創建bean時注入那些依賴關系。相對于由bean自己來控制其實例化、直接在構造器中指定依賴關系或則類似服務定位器（Service Locator）模式這3種自主控制依賴關系注入的方法來說，控制從根本上發生了倒轉，這也正是控制反轉IoC名字的由來。

應用依賴注入（DI）的好處、

應用DI原則后，代碼將更加清晰。而且當bean自己不再擔心對象之間的依賴關系（以及在何時何地指定這種依賴關系和依賴的實際類是什么）之后，實現更高層次的 松耦合將易如反掌。
依賴注入（DI）基本的實現方式

DI主要有兩種注入方式，即 Setter注入和 構造器注入。

通過調用無參構造器或無參static工廠方法實例化bean之后，調用該bean的setter方法，即可實現基于setter的DI。 示例如下：

示例——Java類

java代碼：

public class HelloImpl implements HelloApi{ 
private String name = ""; 
public void setName(String name){ 
this.name = name; 
} 
public String helloSpring3(int a){ 
System.out.println("hello Spring3==="+a+",name="+name); 
return "Ok,a="+a; 
} 
} 

示例——配置文件

<bean name="helloBean" class="com.bjpowernode.Spring3.hello.HelloImpl">
<property name="name"><value>bjpowernode Spring3</value></property>
</bean>

示例——Java類

java代碼：

public class HelloImpl implements HelloApi{ 
private String name = ""; 
public HelloImpl(String name){ 
this.name = name; 
} 
public String helloSpring3(int a){ 
System.out.println("hello Spring3==="+a+",name="+name); 
return "Ok,a="+a; 
} 
} 

示例——配置文件

java代碼：

<bean name="helloBean" class="com.bjpowernode.Spring3.hello.HelloImpl"> 
<constructor-arg><value>bjpowernode Spring3</value></constructor-arg> 
</bean> 

默認解析方式

構造器參數將根據類型來進行匹配。如果bean定義中的構造器參數類型明確，那么bean定義中的參數順序就是對應構造器參數的順序

構造器參數類型匹配

可以使用type屬性來顯式的指定參數所對應的簡單類型。例如：

java代碼：

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

構造器參數的索引

使用index屬性可以顯式的指定構造器參數出現順序。例如：

java代碼：

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

構造器參數的名稱

在Spring3里面,可以使用構造器參數的名稱來直接賦值。例如：

java代碼：

<bean id="exampleBean" class="examples.ExampleBean"> 
<constructor-arg name="years" value="7500000"/> 
<constructor-arg name="ultimateanswer" value="42"/> 
</bean> 

直接量(基本類型、Strings類型等)

<value/>元素通過字符串來指定屬性或構造器參數的值。JavaBean屬性編輯器將把字符串從java.lang.String類型轉化為實際的屬性或參數類型。示例：

java代碼：

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"> 
<property name="driverClassName"> 
<value>oracle.jdbc.driver.OracleDriver</value> 
</property> 
<property name="url"> 
<value>jdbc:oracle:thin:@localhost:1521:orcl</value>
</property> 
<property name="username"> <value>test</value> </property> 
<property name="password" value=“test"/> 
</bean> 

Value可以做為子元素或者是屬性使用。

nidref元素

idref元素用來將容器內其它bean的id傳給<constructor-arg/> 或 <property/>元素，同時提供錯誤驗證功能。 idref元素和<value>差不多，只是傳遞 一個字符串，用來方便xml檢查。示例如下：

java代碼：

<bean id="theTargetBean" class="..."/> 
<bean id="theClientBean" class="..."> 
<property name="targetName"> <idref bean="theTargetBean" /> </property> 
</bean> 
上述bean定義片段完全地等同于（在運行時）以下的片段 
<bean id="theTargetBean" class="..."/> 
<bean id="client" class="..."> 
<property name="targetName"> <value>theTargetBean</value> </property> 
</bean> 

idref元素 續

第一種形式比第二種更可取的主要原因是，使用idref標記允許容器在部署時 驗證所被引用的bean是否存在。而第二種方式中，傳給client bean的targetName屬性值并沒有被驗證。任何的輸入錯誤僅在client bean實際實例化時才會被發現（可能伴隨著致命的錯誤）。如果client bean 是prototype類型的bean，則此輸入錯誤（及由此導致的異常）可能在容器部署很久以后才會被發現。

如果被引用的bean在同一XML文件內，且bean名字就是bean id，那么可以使用local屬性，此屬性允許XML解析器在解析XML文件時來對引用的bean進行驗證 ，示例如下：

<property name="targetName">
<idref local="theTargetBean"/>
</property>

引用其它的bean（協作者） ——ref元素

盡管都是對另外一個對象的引用，但是通過id/name指向另外一個對象卻有三種不同的形式，不同的形式將決定如何處理作用域及驗證。

1：第一種形式也是最常見的形式是使用<ref/>標記指定目標bean，示例：

<ref bean=“someBean”/> 

2：第二種形式是使用ref的local屬性指定目標bean，它可以利用XML解析器來驗證所引用的bean是否存在同一文件中。示例：

<ref local="someBean"/>

3：第三種方式是通過使用ref的parent屬性來引用當前容器的父容器中的bean，并不常用。示例：

java代碼：

<bean id="accountService" class="com.foo.SimpleAccountService"> </bean> 
<bean id=“accountService” <-- 注意這里的名字和parent的名字是一樣的--> class="org.springframework.aop.framework.ProxyFactoryBean"> 
 <property name="target"><ref parent="accountService"/> </property> 
</bean> 

內部Bean

所謂的內部bean（inner bean）是指在一個bean的<property/>或 <constructor-arg/>元素中使用<bean/>元素定義的bean。內部bean定義不需要有id或name屬性，即使指定id 或 name屬性值也將會被容器忽略。示例：

java代碼：

<bean id="outer" class="..."> 
<property name="target"> 
<bean class="com.mycompany.Person"> 
<property name="name" value="Fiona Apple"/> 
<property name="age" value="25"/> 
</bean> 
</property> 
</bean> 

看完上述內容，你們對ioc在spring中的作用有哪些有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。