Spring 依賴注入原理學習

首先我們來看看 Spring 參考文檔的 11.2.6. 執行SQL語句 這裏有個代碼片斷:

import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class ExecuteAStatement {

private JdbcTemplate jt;
private DataSource dataSource;

public void doExecute() {
jt = new JdbcTemplate(dataSource);
jt.execute("create table mytable (id integer, name varchar(100))");
}

public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}

這個就是普通的 Java 類, 再參考 11.2.4. DataSource接口, 這裏的另一個代碼片斷:
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
dataSource.setUrl("jdbc:hsqldb:hsql://localhost:");
dataSource.setUsername("sa");
dataSource.setPassword("");

當然上面的連接方式可以配置成我們課程裏面介紹的 MyEclipse Derby 的數據庫連接:
org.apache.derby.jdbc.ClientDriver
jdbc:derby://localhost:1527/myeclipse;create=true
app
app

我們可以寫一個測試類來執行代碼:

import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class TestTemplate {
public static void main(String[] args) {
// 新建一個數據源對象
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
dataSource.setUrl("jdbc:hsqldb:hsql://localhost:");
dataSource.setUsername("sa");
dataSource.setPassword("");

// 新建一個ExecuteAStatement 對象
ExecuteAStatement eas = new ExecuteAStatement();
// 給執行表達式的對象關聯數據源(也就是常說的注入, 通過 JavaBean 的 setXxx 方法關聯起來)
eas.setDataSource(dataSource);
// 執行功能代碼
eas.doExecute();
}
}

這個代碼可以跑通, 就是普通的編程方式, 大家可以去看剛纔介紹的文檔附近的詳細說明.

那麼如果用 Spring 來做, 代碼會變成這樣:
ExecuteAStatement 類代碼保持不變, 多了個 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-2.0.xsd">

<bean id="userDAO" class="ExecuteAStatement">
<property name="dataSource">
<ref bean="myDataSource" />
</property>
</bean>

<bean id="myDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.hsqldb.jdbcDriver</value>
</property>

<property name="url">
<value>jdbc:hsqldb:hsql://localhost:</value>
</property>

<property name="username">
<value>sa</value>
</property>

<property name="password">
<value></value>
</property>
</bean>

</beans>

測試類:

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

public class Test {

public static void main(String[] args) throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
ExecuteAStatement eas =(ExecuteAStatement)context.getBean("userDAO");
// 執行功能代碼
eas.doExecute();
}
}

和上面的 TestTemplate 類相比, 就會發現 new DriverManagerDataSource() 這個過程不用我們寫了, 運行的時候會發現一切都執行的好好的, 也就是常說的 ExecuteAStatement 的 dataSource 這個屬性被注入了.

那麼這個過程到底該如何理解呢? Spring 是一個對象池, 可以簡化爲一個 Map, 存多個主鍵和對象的映射. 那麼 Spring 運行的過程中, 會根據 beans.xml 一步步進行必要的解析工作:

Map springEngine = new HashMap();

OK, 解析到了
<bean id="userDAO" class="ExecuteAStatement">, 發現 bean 定義, 那就新建一個實例存到對象池裏吧, 主鍵就是 userDAO, 值就是對象:
ExecuteAStatement bean1 = new ExecuteAStatement();
springEngine.put("userDAO", bean1);

再往下執行, 發現 property 定義:
<property name="dataSource">
到了這裏, 就知道應該調用 bean1.setDataSource(DataSource) 方法了. 可以接着執行, 發現
<ref bean="myDataSource" />, 哦, 這個方法的參數還沒有呢, 是個 bean 的引用, 好了, 要調用這個方法, 還是先 new 一個名字爲 myDataSource 的 bean2 吧. 就跳到下面尋找 myDataSource 的定義, 找到了:
<bean id="myDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.hsqldb.jdbcDriver</value>
</property>

<property name="url">
<value>jdbc:hsqldb:hsql://localhost:</value>
</property>

<property name="username">
<value>sa</value>
</property>

<property name="password">
<value></value>
</property>
</bean>
像以前一樣, 先實例化這個類, 然後看到 property 表情就調用對應的 setXxx() 這樣的方法, 相當於下面一段代碼:
// 新建一個數據源對象
DriverManagerDataSource bean2 = new DriverManagerDataSource();
bean2.setDriverClassName("org.hsqldb.jdbcDriver");
bean2.setUrl("jdbc:hsqldb:hsql://localhost:");
bean2.setUsername("sa");
bean2.setPassword("");
不是還有個 bean 的 id 名字爲 myDataSource 嘛, 那就把它存到對象池裏面:

springEngine.put("myDataSource", bean2);

好了, 最後就是把他們兩個關聯起來了, 通過 ref 裏指定的 bean id 名來關聯起來:

// 省略類型轉換的代碼
springEngine.get("userDAO").setDataSource(springEngine.get("myDataSource"));

最後返回給用戶的就是一個對象池(一個 Map)了, 所以別人調用的時候, 就發現 springEngine.get("userDAO") 回來的類的 dataSource 屬性已經被實例化過了, 這些都是 Spring 幕後工作的代碼, 通過反射機制來實現.

所以最後寫代碼調用:
context.getBean("userDAO") 的時候, 得到的是 ExecuteAStatement, 這時候還有一個 myDataSource, 也可以被調用:
context.getBean("myDataSource"), 得到的是 DriverManagerDataSource.

介紹的過程, 僅供參考. 歡迎大家交流更好的原理介紹文章.




再轉一篇別人推薦的通俗易懂的說明, 非實現方面的:


IoC就是Inversion of Control，控制反轉。在Java開發中，IoC意味着將你設計好的類交給系統去控制，而不是在你的類內部控制。這稱爲控制反轉。


下面我們以幾個例子來說明什麼是IoC


假設我們要設計一個Girl和一個Boy類，其中Girl有kiss方法，即Girl想要Kiss一個Boy。那麼，我們的問題是，Girl如何能夠認識這個Boy？


在我們中國，常見的MM與GG的認識方式有以下幾種
1 青梅竹馬； 2 親友介紹； 3 父母包辦
那麼哪一種纔是最好呢？


青梅竹馬：Girl從小就知道自己的Boy。


public class Girl {
void kiss(){
Boy boy = new Boy();
}
}


然而從開始就創建的Boy缺點就是無法在更換。並且要負責Boy的整個生命週期。如果我們的Girl想要換一個怎麼辦？（嚴重不支持Girl經常更換Boy,#_#）


親友介紹：由中間人負責提供Boy來見面


public class Girl {
void kiss(){
Boy boy = BoyFactory.createBoy();
}
}


親友介紹，固然是好。如果不滿意，儘管另外換一個好了。但是，親友BoyFactory經常是以Singleton的形式出現，不然就是，存在於Globals，無處不在，無處不能。實在是太繁瑣了一點，不夠靈活。我爲什麼一定要這個親友摻和進來呢？爲什麼一定要付給她介紹費呢？萬一最好的朋友愛上了我的男朋友呢？


父母包辦：一切交給父母，自己不用費吹灰之力，只需要等着Kiss就好了。


public class Girl {
void kiss(Boy boy){
// kiss boy
boy.kiss();
}
}


Well，這是對Girl最好的方法，只要想辦法賄賂了Girl的父母，並把Boy交給他。那麼我們就可以輕鬆的和Girl來Kiss了。看來幾千年傳統的父母之命還真是有用哦。至少Boy和Girl不用自己瞎忙乎了。


這就是IOC，將對象的創建和獲取提取到外部。由外部容器提供需要的組件。


我們知道好萊塢原則：“Do not call us, we will call you.” 意思就是，You, girlie, do not call the boy. We will feed you a boy。


我們還應該知道依賴倒轉原則即 Dependence Inversion Princinple，DIP


Eric Gamma說，要面向抽象編程。面向接口編程是面向對象的核心。


組件應該分爲兩部分，即 Service, 所提供功能的聲明 Implementation, Service的實現


好處是：多實現可以任意切換，防止 “everything depends on everything” 問題．即具體依賴於具體。


所以，我們的Boy應該是實現Kissable接口。這樣一旦Girl不想kiss可惡的Boy的話，還可以kiss可愛的kitten和慈祥的grandmother。
二、IOC的type


IoC的Type指的是Girl得到Boy的幾種不同方式。我們逐一來說明。


IOC type 0：不用IOC
public class Girl implements Servicable {
private Kissable kissable;
public Girl() {
kissable = new Boy();
}
public void kissYourKissable() {
kissable.kiss();
}
}

Girl自己建立自己的Boy，很難更換，很難共享給別人，只能單獨使用，並負責完全的生命週期。


IOC type 1，先看代碼：代碼


public class Girl implements Servicable {

Kissable kissable;

public void service(ServiceManager mgr) {
kissable = (Kissable) mgr.lookup(“kissable”);
}

public void kissYourKissable() {
kissable.kiss();
}

}


這種情況出現於Avalon Framework。一個組件實現了Servicable接口，就必須實現service方法，並傳入一個ServiceManager。其中會含有需要的其它組件。只需要在service方法中初始化需要的Boy。


另外，J2EE中從Context取得對象也屬於type 1。它依賴於配置文件。


IOC type 2：


public class Girl {

private Kissable kissable;

public void setKissable(Kissable kissable) {
this.kissable = kissable;
}

public void kissYourKissable() {
kissable.kiss();
}

}


Type 2出現於Spring Framework，是通過JavaBean的set方法來將需要的Boy傳遞給Girl。它必須依賴於配置文件。

IOC type 3:


public class Girl {

private Kissable kissable;

public Girl(Kissable kissable) {
this.kissable = kissable;
}

public void kissYourKissable() {
kissable.kiss();
}

}


這就是PicoContainer的組件 。通過構造函數傳遞Boy給Girl

PicoContainer container = new DefaultPicoContainer();
container.registerComponentImplementation(Boy.class);
container.registerComponentImplementation(Girl.class);
Girl girl = (Girl) container.getComponentInstance(Girl.class);
girl.kissYourKissable();