<? xml version="1.0" encoding="gb2312" ?>
<! DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
 "http://www.springframework.org/dtd/spring-beans.dtd" >

< beans >

  < bean  id ="chinese"  class ="Chinese" >
  < property  name ="friends" >
             < list >
                 < value > 张三 </ value >
                 < value > 李四 </ value >
                 < value > 王五 </ value >
             </ list >
   </ property >
   < property  name ="score" >
             < map >
                 < entry  key ="数学" >
                     < value > 60 </ value >
                 </ entry >
                 < entry  key ="英语" >
                     < value > 70 </ value >
                 </ entry >
                 < entry  key ="语文" >
                     < value > 80 </ value >
                 </ entry >
                 < entry  key ="物理" >
                     < value > 90 </ value >
                 </ entry >
                 < entry  key ="化学" >
                     < value > 95 </ value >
                 </ entry >
             </ map >
   </ property >
   < property  name ="basicInfo" >
             < props >
                 < prop  key ="身高" > 165 </ prop >
                 < prop  key ="体重" > 45kg </ prop >
                 < prop  key ="学历" > 大学本科 </ prop >
             </ props >
    </ property >
    < property  name ="interest" >
             < set >
                 < value > 唱歌 </ value >
                 < value > 跳舞 </ value >
                 < value > 书法 </ value >
             </ set >
    </ property >

</ bean >

</ beans >

  对应的java类为:

public   class  Chinese  implements  People  {
     private  List friends  =   new  ArrayList();
     private  Map score  =   new  HashMap();
     private  Properties basicInfo  =   new  Properties();
     private  Set interest  =   new  HashSet();
     // 省略对应set方法
    .
}

<? xml version="1.0" encoding="gb2312" ?>
<! DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
 "http://www.springframework.org/dtd/spring-beans.dtd" >

< beans >

  < bean  id ="chinese"  class ="Chinese" >
  < property  name ="friends" >
             < list >
                 < value > 张三 </ value >
                 < value > 李四 </ value >
                 < value > 王五 </ value >
             </ list >
   </ property >
   < property  name ="score" >
             < map >
                 < entry  key ="数学" >
                     < value > 60 </ value >
                 </ entry >
                 < entry  key ="英语" >
                     < value > 70 </ value >
                 </ entry >
                 < entry  key ="语文" >
                     < value > 80 </ value >
                 </ entry >
                 < entry  key ="物理" >
                     < value > 90 </ value >
                 </ entry >
                 < entry  key ="化学" >
                     < value > 95 </ value >
                 </ entry >
             </ map >
   </ property >
   < property  name ="basicInfo" >
             < props >
                 < prop  key ="身高" > 165 </ prop >
                 < prop  key ="体重" > 45kg </ prop >
                 < prop  key ="学历" > 大学本科 </ prop >
             </ props >
    </ property >
    < property  name ="interest" >
             < set >
                 < value > 唱歌 </ value >
                 < value > 跳舞 </ value >
                 < value > 书法 </ value >
             </ set >
    </ property >

</ bean >

</ beans >

  对应的java类为:

public   class  Chinese  implements  People  {
     private  List friends  =   new  ArrayList();
     private  Map score  =   new  HashMap();
     private  Properties basicInfo  =   new  Properties();
     private  Set interest  =   new  HashSet();
     // 省略对应set方法
    .
}

    ApplicationContext ctx =new FileSystemXmlApplicationContext("D:/project/bean.xml");//根据具体路径加载文件
  2. ClassPathXmlApplicationContext
       eg1.  ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
       eg2.
               String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};
               ApplicationContext ctx = new ClassPathXmlApplication(locations);
       注：其中FileSystemXmlApplicationContext和ClassPathXmlApplicationContext与BeanFactory的xml文件定位方式一样是基于路径的。
 3. XmlWebApplicationContext
   eg1. ServletContext servletContext = request.getSession().getServletContext();    
        ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);

/** *//**
 * Copyright 2007 GuangZhou Cotel Co. Ltd.
 * All right reserved.    
 * 测试异常拦截的bean     
 * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * @version 1.0 
 * Creation date: 2007-7-24 - 下午08:00:37
 */
public class TestBean {
    public void method1() throws Exception {
        throw new Exception("Exception happened!");
    }

    /** *//**
     * 将字符串转换为整数.
     * @param number 需转换的字符串
     * @return 转换成的字符串
     * @throws NumberFormatException
     * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
     * Creation date: 2007-7-24 - 下午08:05:41
     */
    public int changeToNumber(String number) throws NumberFormatException {
        //当number为空或非数字时，将抛出NumberFormatException
        int num = Integer.parseInt(number);
        return num;
    }
}

import org.springframework.aop.ThrowsAdvice;
import org.springframework.aop.framework.ProxyFactory;

import java.lang.reflect.Method;

/** *//**
 * Copyright 2007 GuangZhou Cotel Co. Ltd.
 * All right reserved.    
 * 异常拦截类.      
 * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * @version 1.0 
 * Creation date: 2007-7-24 - 下午08:12:25
 */
public class ExceptionAdvisor implements ThrowsAdvice {
    public static void main(String[] args) {
        TestBean bean = new TestBean();
        ProxyFactory pf = new ProxyFactory();
        pf.setTarget(bean);
        pf.addAdvice(new ExceptionAdvisor());

        TestBean proxy = (TestBean) pf.getProxy();
        try {
            proxy.method1();
        } catch (Exception ignore) {
        }
        
        try {
            proxy.changeToNumber("amigo");
        } catch (Exception ignore) {
        }
    }

    /** *//**
     * 对未知异常的处理.
     * @param method
     * @param args
     * @param target
     * @param ex
     * @throws Throwable
     * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
     * Creation date: 2007-7-24 - 下午03:35:02
     */
    public void afterThrowing(Method method, Object[] args, Object target,
            Exception ex) throws Throwable {
        System.out.println("*************************************");
        System.out.println("Error happened in class: " + target.getClass().getName());
        System.out.println("Error happened in method: " + method.getName());
        
        for (int i = 0; i < args.length; i++) {
            System.out.println("arg[" + i + "]: " + args[i]);
        }
        
        System.out.println("Exception class: " + ex.getClass().getName());
        System.out.println("*************************************");
    }
    
    /** *//**
     * 对NullPointerException异常的处理
     * @param method
     * @param args
     * @param target
     * @param ex
     * @throws Throwable
     * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
     * Creation date: 2007-7-24 - 下午01:17:35
     */
    public void afterThrowing(Method method, Object[] args, Object target,
            NullPointerException ex) throws Throwable {
        System.out.println("*************************************");
        System.out.println("Error happened in class: " + target.getClass().getName());
        System.out.println("Error happened in method: " + method.getName());
        
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
        
        System.out.println("Exception class: " + ex.getClass().getName());
        System.out.println("*************************************");
    }
}

     运行ExceptionAdvisor类后，结果如下：
     ************************************
     Error happened in class: TestBean
     Error happened in method: method1
     Exception class: java.lang.Exception
    *************************************
    *************************************
    Error happened in class: TestBean
    Error happened in method: changeToNumber
    arg[0]: amigo
    Exception class: java.lang.NumberFormatException
    *************************************

    在工程中，可将ExceptionAdvisor类作为bean定义，并指定要纳入其进行异常拦截的类。

1. 新建普通 Java 项目 MySpringTest. 这个过程无需赘述了, 建议建项目的时候将 src 目录和 bin(或者classes)目录分开, 另外提示你切换透视图的时候一定要切换过去到 Java 透视图, 此时默认会在 Package Explorer 中选中刚才已经建好的 Java Project, 但是背景为灰色.
2. 首先单击一下左边的 Package Explorer 中新建的 MySpringTest 项目来使其高亮选中, 接着点击菜单项 MyEclipse -> Add Spring Capabilities..., 接着会弹出对话框 Add Spring Capabilities 提示你设置当前项目的 Spring 属性.
对话框的第一页可以选择全部的 Spring 框架, 这是最保险的做法, 不过我们的例子只需要选中Spring 2.0 Core Libraries 就可以了. 点击 "Next" 继续.
第二页是 Add Spring bean configuration file. 保持默认值不变就可以了. 最后点击 Finish.
3. Spring 的开发没法自动生成 Bean, 这里大家只好手工来写了, 也很简单. 分别复制下面的三个代码, 然后在 MyEclipse src 目录上点击右键后选择菜单项 Paste 就可以生成 Java 类文件了.

public interface Action {
 
  public String execute(String str);
 
}

public class UpperAction implements Action {
 
  private String message;
 
  public String getMessage() {
   return message;
  }
 
  public void setMessage(String string) {
    message = string;
  }
 
  public String execute(String str) {
   return (getMessage() + str).toUpperCase();
  }
}

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

public class TestAction {

 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "applicationContext.xml");
  Action bean = (Action) ctx.getBean("theAction");
  System.out.println(bean.execute("Rod"));
 }
}

4. 双击左侧在第2步生成的 applicationContext.xml, 然后选择菜单项 Window -> Show View -> Other..., 在弹出的对话框中选择 MyEclipse Enterprise Workbench 节点下的 Spring Beans 子节点打开视图 Spring Beans. 此视图讲出现在主界面的右下侧.

5. 展开此视图中的 MySpringTest 父节点, 并选中 src/applicationContext.xml 子节点, 在此节点上点击右键并选择弹出菜单项中的 New Bean 来打开 Create a new Spring bean 对话框, 并按照下图输入对应的内容.
Bean Id: [theAction]
Bean class: [UpperAction]
接下来请单击一下 Tab 面板 Properties 并点击其中的 Add... 按钮, 在接下来弹出的 Property Wizard 对话框中按照下图输入/选择内容:
Name: [message]
Spring type: [value]
Type: [java.lang.String]
Value:[Hello_]
最后点击两次 Finish 按钮关闭所有向导对话框. 然后点击菜单 File -> Save. 此时可以看到 applicationContext.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="theAction" class="UpperAction" abstract="false"
  lazy-init="default" autowire="default" dependency-check="default">
  <property name="message">
   <value type="java.lang.String">Hello_</value>
  </property>
 </bean></beans>
然后双击 Package Explorer 下 MySpringTest/src/TestAction.java 打开源代码, 然后点击菜单 Run -> Run As -> 1. Java Application, 如果没有错误的话将会出现如下的输入, 您的第一个 Hello Spring 运行成功了:
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
HELLO_ROD

接着您就可以对着参考书继续创建类, 修改 applicationContext.xml 做更多的练习了.

开发整合 Hibernate 的关键操作点截图:
1. 在数据库浏览器中选择反向工程菜单;

2. 对话框的选项说明

首先学习 Spring 等框架应该本着简化程序员负担, 加快开发速度的原则来进行, 而不是把框架的知识点都给学习, 练习一遍. 另外用 Spring 的时候也要注意不要过渡依赖 Spring 框架, 注意它们的宣传语是: 无侵入, 轻量级. 所以, 除非必要, 千万不要让 Spring 侵入你的代码啊, 例如哪些 Aware 接口, 不也是变相的侵入了你的代码嘛. 还有不要为了 Spring 而 Spring, 明明一段代码用 new JavaBean().setUsername("xxx") 这样的方式非常简练, 你非要整出个 bean 的配置文件来, 纯属多此一举. 所以无侵入只是个相对概念, 代码写少了, 但是 bean.xml 配置文件和 Spring.jar 你不能丢吧, 所以你已经被 Spring 侵入了, 而且以后想换第二家公司来做个框架解析你这些 XML 文件都困难呢, 因为 Spring 本身并不是可替换或者热插拔的, 换句话说所有用 Spring 的代码都已经被绑定到了 Spring 框架上.  好了, 先说一下目前了解的 Spring 的主要应用场合.

1. 依赖注入, 主要是把一些需要经常修改的内容提取为 Bean, 也是尽量能不提取就不提取, 要不然到最后那个 bean.xml 增加到了几千行你也就不会觉得这时候有什么方便的地方了;

2. 整合 Hibernate, 这个可以说是最强大最实用的功能了, 也是为什么一提到 Spring 后面总是跟着 Hibernate 的原因. 在文档的 12.2. Hibernate 有相关的介绍. 例如看看下面的调用代码:

import java.io.IOException;

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

import dao.Testuser;
import dao.TestuserDAO;

// 调用 Hibernate DAO
public class Test {

 public static void main(String[] args) throws IOException {
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  TestuserDAO dao =(TestuserDAO)context.getBean("userDAO");
  Testuser user = new Testuser();
//  user.setxxx..., 设置值.
  dao.save(user);
 }

}

再看 DAO 的代码:

package dao;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 * Data access object (DAO) for domain model class Testuser.
 */

public class TestuserDAO extends HibernateDaoSupport {

 public void save(Testuser transientInstance) {
  getHibernateTemplate().save(transientInstance);
 }

 public void delete(Testuser persistentInstance) {
  getHibernateTemplate().delete(persistentInstance);

 }

}

是不是感觉简单到令人难以置信?  要保存的实体 POJO 也很简单:
package dao;

/**
 * Testuser generated by MyEclipse Persistence Tools
 */

public class Testuser implements java.io.Serializable {

 // Fields

 private Integer id;

 private String username;

 private Integer age;
 
 getXXX();
 setXXX();
}

然后我们看主要的配置文件 applicationContext.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="dao.TestuserDAO">
  <property name="sessionFactory">
   <ref bean="hibernateSessionFactory" />
  </property>
 </bean>

 <bean id="hibernateSessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="configLocation"
   value="file:src/hibernate.cfg.xml">
  </property>
 </bean>

</beans>

大家可以看到 DAO 的  HibernateSessionFactory 完全是配置出来的, 不用我们写一行 Hibernate 初始化的代码, Spring 已经帮我们做好了一切. 完整的代码大家可以下载附件. 但是大家也请注意, 我们的代码这样做也是依赖了 Spring 的框架, 其实功能强大和不依赖具体的框架本身就是个谬论, 你不用(依赖)它的框架又怎么能用到它的强大的功能呢?

3. 使用 JDBCTemplate 简化普通的 JDBC 代码编写, 这个大家可以去看参考文档(官方的 Spring Framework 开发参考手册, 中英文均可) " 第 11 章 使用JDBC进行数据访问", 老师也介绍过了.

4. 整合 Struts, 也参考文档里的内容, 具体是 15.4. Struts., 让 Struts 的 Action 可以被注入内容.

5. AOP 功能, 我没用过, 只是听一些朋友介绍说他们用的有, 所以建议大家了解一下, 个人觉得挺难理解, 开发的时候也是完全依赖 Spring 的 API, 比较难做. AOP 是 Spring 后来加入的内容, 按照官方文档是"锦上添花的内容", 其实就是捆绑了自己的 AOP, 而 Spring 最核心的内容当属依赖注入功能.

6.  事务管理, 据说有一些人在用. 但是感觉开发起来挺费劲的, 不如 EJB 3 的标注来的简便. 不过你被绑在了 Spring 框架上, 一般就只好用它自己做的这些个功能了.

7. 其它的 Spring MVC 等内容, 都是可选项, 具体来说开发工具支持上并不如 Struts 来的那么直接好用.

至于 Spring 的缺点:
1. 不支持分布式访问,分布式事务和集群, 这些是 EJB 3 的优点, 但是 Spring 目前还不支持;
2. 配置使用 XML 文件, 如果文件内容很多的话对维护的人来说是个负担;
3. 提供 Spring 容器的只有一家公司(Interface21), 换句话说它是非标准的, 被个别公司垄断的技术, 不能像 EJB 那样可以换一家厂商的服务器, Spring 不存在第二家公司来做.

另外开发工具的支持上, MyEclipse 5 可以快速的 5 分钟就做好 Spring 整合 Hibernate 的框架代码. 如果大家有兴趣可以自己找点资料来看或者直接咨询我.

那么大家看了这篇文档希望能有一些自己的想法, 把内容 100% 掌握是不现实的, 而且过了一阵子不用就肯定会忘, 所以现在需要的是了解概念, 能跑一些基础的代码以后用到的话再深入研究.

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)模式由此产生了，也就是将依赖先剥离，然后在适当时候再注射进入。

首先学习 Spring 等框架应该本着简化程序员负担, 加快开发速度的原则来进行, 而不是把框架的知识点都给学习, 练习一遍. 另外用 Spring 的时候也要注意不要过渡依赖 Spring 框架, 注意它们的宣传语是: 无侵入, 轻量级. 所以, 除非必要, 千万不要让 Spring 侵入你的代码啊, 例如哪些 Aware 接口, 不也是变相的侵入了你的代码嘛. 还有不要为了 Spring 而 Spring, 明明一段代码用 new JavaBean().setUsername("xxx") 这样的方式非常简练, 你非要整出个 bean 的配置文件来, 纯属多此一举. 所以无侵入只是个相对概念, 代码写少了, 但是 bean.xml 配置文件和 Spring.jar 你不能丢吧, 所以你已经被 Spring 侵入了, 而且以后想换第二家公司来做个框架解析你这些 XML 文件都困难呢, 因为 Spring 本身并不是可替换或者热插拔的, 换句话说所有用 Spring 的代码都已经被绑定到了 Spring 框架上.  好了, 先说一下目前了解的 Spring 的主要应用场合.

1. 依赖注入, 主要是把一些需要经常修改的内容提取为 Bean, 也是尽量能不提取就不提取, 要不然到最后那个 bean.xml 增加到了几千行你也就不会觉得这时候有什么方便的地方了;

2. 整合 Hibernate, 这个可以说是最强大最实用的功能了, 也是为什么一提到 Spring 后面总是跟着 Hibernate 的原因. 在文档的 12.2. Hibernate 有相关的介绍. 例如看看下面的调用代码:

import java.io.IOException;

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

import dao.Testuser;
import dao.TestuserDAO;

// 调用 Hibernate DAO
public class Test {

 public static void main(String[] args) throws IOException {
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  TestuserDAO dao =(TestuserDAO)context.getBean("userDAO");
  Testuser user = new Testuser();
//  user.setxxx..., 设置值.
  dao.save(user);
 }

}

再看 DAO 的代码:

package dao;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 * Data access object (DAO) for domain model class Testuser.
 */

public class TestuserDAO extends HibernateDaoSupport {

 public void save(Testuser transientInstance) {
  getHibernateTemplate().save(transientInstance);
 }

 public void delete(Testuser persistentInstance) {
  getHibernateTemplate().delete(persistentInstance);

 }

}

是不是感觉简单到令人难以置信?  要保存的实体 POJO 也很简单:
package dao;

/**
 * Testuser generated by MyEclipse Persistence Tools
 */

public class Testuser implements java.io.Serializable {

 // Fields

 private Integer id;

 private String username;

 private Integer age;
 
 getXXX();
 setXXX();
}

然后我们看主要的配置文件 applicationContext.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="dao.TestuserDAO">
  <property name="sessionFactory">
   <ref bean="hibernateSessionFactory" />
  </property>
 </bean>

 <bean id="hibernateSessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="configLocation"
   value="file:src/hibernate.cfg.xml">
  </property>
 </bean>

</beans>

大家可以看到 DAO 的  HibernateSessionFactory 完全是配置出来的, 不用我们写一行 Hibernate 初始化的代码, Spring 已经帮我们做好了一切. 完整的代码大家可以下载附件. 但是大家也请注意, 我们的代码这样做也是依赖了 Spring 的框架, 其实功能强大和不依赖具体的框架本身就是个谬论, 你不用(依赖)它的框架又怎么能用到它的强大的功能呢?

3. 使用 JDBCTemplate 简化普通的 JDBC 代码编写, 这个大家可以去看参考文档(官方的 Spring Framework 开发参考手册, 中英文均可) " 第 11 章 使用JDBC进行数据访问", 老师也介绍过了.

4. 整合 Struts, 也参考文档里的内容, 具体是 15.4. Struts., 让 Struts 的 Action 可以被注入内容.

5. AOP 功能, 我没用过, 只是听一些朋友介绍说他们用的有, 所以建议大家了解一下, 个人觉得挺难理解, 开发的时候也是完全依赖 Spring 的 API, 比较难做. AOP 是 Spring 后来加入的内容, 按照官方文档是"锦上添花的内容", 其实就是捆绑了自己的 AOP, 而 Spring 最核心的内容当属依赖注入功能.

6.  事务管理, 据说有一些人在用. 但是感觉开发起来挺费劲的, 不如 EJB 3 的标注来的简便. 不过你被绑在了 Spring 框架上, 一般就只好用它自己做的这些个功能了.

7. 其它的 Spring MVC 等内容, 都是可选项, 具体来说开发工具支持上并不如 Struts 来的那么直接好用.

至于 Spring 的缺点:
1. 不支持分布式访问,分布式事务和集群, 这些是 EJB 3 的优点, 但是 Spring 目前还不支持;
2. 配置使用 XML 文件, 如果文件内容很多的话对维护的人来说是个负担;
3. 提供 Spring 容器的只有一家公司(Interface21), 换句话说它是非标准的, 被个别公司垄断的技术, 不能像 EJB 那样可以换一家厂商的服务器, Spring 不存在第二家公司来做.

另外开发工具的支持上, MyEclipse 5 可以快速的 5 分钟就做好 Spring 整合 Hibernate 的框架代码. 如果大家有兴趣可以自己找点资料来看或者直接咨询我.

那么大家看了这篇文档希望能有一些自己的想法, 把内容 100% 掌握是不现实的, 而且过了一阵子不用就肯定会忘, 所以现在需要的是了解概念, 能跑一些基础的代码以后用到的话再深入研究.