Spring3開發實戰 之 第二章:IoC/DI開發(1) – JAVA編程語言程序開發技術文章

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代碼:
[java] 
public interface HelloApi { 
public String helloSpring3(int a);  

開發實現類

java代碼:
[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版的。

java代碼:
[java] 
3:建議使用Spring3的Schema版本,示例如下: 
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="https://www.springframework.org/schema/beans" 
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" 
xmlns:context="https://www.springframework.org/schema/context" 
xmlns:aop="https://www.springframework.org/schema/aop" 
xmlns:tx="https://www.springframework.org/schema/tx" 
xsi:schemaLocation=" 
https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context-3.0.xsd 
https://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
https://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
"> 
……………………… 
</beans> 
4:配置applicationContext.xml如下:

java代碼:
[java] 
<bean name="helloBean" class="cn.javass.Spring3.hello.HelloImpl"></bean> 
  
編寫客戶端如下:

java代碼:
[java] 
package cn.javass.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代碼:
[java]
Resource resource = new FileSystemResource("beans.xml"); 
BeanFactory factory = new XmlBeanFactory(resource); 
  
2:第二種:

java代碼:
[java] 
ClassPathResource resource = new ClassPathResource("beans.xml"); 
BeanFactory factory = new XmlBeanFactory(resource); 
  
3:第三種:

java代碼:
[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代碼:
[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代碼:
[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="cn.javass.Spring3.hello.HelloImpl">
<property name="name"><value>javass Spring3</value></property>
</bean>
示例——Java類

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代碼:
[java] 
<bean name="helloBean" class="cn.javass.Spring3.hello.HelloImpl"> 
<constructor-arg><value>javass Spring3</value></constructor-arg> 
</bean> 
默認解析方式
構造器參數將根據類型來進行匹配。如果bean定義中的構造器參數類型明確,那麼bean定義中的參數順序就是對應構造器參數的順序
構造器參數類型匹配
可以使用type屬性來顯式的指定參數所對應的簡單類型。例如:

java代碼:
[java] 
<bean id="exampleBean" class="examples.ExampleBean"> 
<constructor-arg type="int" value="7500000"/> 
<constructor-arg type="java.lang.String" value="42"/> 
</bean> 
構造器參數的索引
使用index屬性可以顯式的指定構造器參數出現順序。例如:

java代碼:
[java]
<bean id="exampleBean" class="examples.ExampleBean"> 
<constructor-arg index="0" value="7500000"/> 
<constructor-arg index="1" value="42"/> 
</bean> 
構造器參數的名稱
在Spring3裡面,可以使用構造器參數的名稱來直接賦值。例如:

java代碼:
[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代碼:
[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代碼:
[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代碼:
[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代碼:
[java]  www.aiwalls.com
<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> 
 作者:jinnianshilongnian

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *