首先我們來看看 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();

參考資料

1 http://www.picocontainer.org/presentations/JavaPolis2003.ppt
http://www.picocontainer.org/presentations/JavaPolis2003.pdf

2 DIP， Robert C Martin, Bob大叔的優秀論文
http://www.objectmentor.com/resources/articles/dip.pdf

3 Dependency Injection 依賴注射，Matrin Fowler對DIP的擴展
http://www.martinfowler.com/articles/injection.html

4 IOC框架

PicoContainer 優秀的IOC框架
http://picocontainer.org/

Avalon
http://avalon.apache.org/

Spring Framework
http://www.springframework.org/

HiveMind
http://jakarta.apache.org/commons/hivemind

----

IoC是一種模式
IoC(Inversion of Control)中文譯為控制反轉，目前Java社群中流行的各種輕量級容器的實現都是以IoC模式作為基礎的。控制反轉意味著在系統開發過程中，設計的類將交由容器去控制，而不是在類的內部去控制，類與類之間的關系將交由容器處理,一個類在需要調用另一個類時,只要調用另一個類在容器中注冊的名字就可以得到這個類的實例,與傳統的編程方式有了很大的不同,”不用你找,我來提供給你”,這就是控制反轉的含義。Martin Fowler在他的一篇文章中給IoC起了一個更為直觀的名字：依賴注射DI(Dependency Injection)。下面先引入這個模式。

在設計模式中，我們已經習慣一種思維編程方式：Interface Driven Design 接口驅動，接口驅動有很多好處，可以提供不同靈活的子類實現，增加代碼穩定和健壯性等等，但是接口一定是需要實現的，也就是如下語句遲早要執行：

InterfaceA a = new InterfaceAImp()；

InterfaceAImp是接口InterfaceA的一個子類，IoC模式可以延緩接口的實現，根據需要實現，有個比喻：接口如同空的模型套，在必要時，需要向模型套注射石膏，這樣才能成為一個模型實體，因此，我們將人為控制接口的實現成為注射。IoC模式是解決調用者和被調用者之間的一種關系，上述InterfaceA實現語句表明當前是在調用被調用者InterfaceAImp，由于被調用者名稱寫入了調用者的代碼中，這產生了一個接口實現的原罪：彼此聯系，調用者和被調用者有緊密聯系，在UML中是用依賴 Dependency 表示。但是這種依賴在分離關注的思維下是不可忍耐的，必須切割，實現調用者和被調用者解耦，新的Ioc模式依賴注射 (Dependency Injection)模式由此產生了，也就是將依賴先剝離，然后在適當時候再注射進入。