控制反转和容器(一)

IoC(Inversion of control，控制反转)是一个通用的设计原则，而DI(Dependency Injection，依赖注入)则是具体的设计模式，它充分体现了IoC的设计原则，是IoC的典型实现(非唯一实现)，所以IoC和DI经常混用。Ioc是Spring框架的核心基础，不深入理解它也只能比葫芦画瓢地拷贝applicationContext.xml，做够了搬运工之后还是看看我们每次项目都在搬运的东西到底什么吧。本文不涉及Spring框架，就是研究控制反转和容器。
案例：开发一个这样的系统，功能之一是生成Bar Chart或Pie Chart不同类型的统计图，实现这个子系统。首先想到了JFreeChart，没错，它是一个非常好用的Java开源图形API，不过这里我们只研究一下控制反转。
分析：根据面向对象的设计思想，将系统分解成一组可重用的组件，“接口与实现分离”的原则很容易想到。创建出图形的通用接口，再进行具体的实现。我们得到如下代码。
[img]http://dl.iteye.com/upload/attachment/205684/d1b7529b-e877-378b-bfc7-15e8f8f26e1c.jpg[/img]
(代码均省略包名和import语句)

public interface ChartGenerator {// 接口
    public void generate(List dataSet); // 抽象方法
}

public class BarChartGenerator implements ChartGenerator {
    public void generate(List dataSet) {
       System.out.println("Generating Bar Chart ... ");
       for (Object data : dataSet) {// JDK5新特性：For-Each循环
           System.out.println(data); 
// System.out.println()方法参数可以是Object型，执行时自动调用对象的toString()方法
       }
    }
}

PieChartGenerator代码省略，参照上方的即可。

public class ChartService {
    private ChartGenerator chartGenerator = new PieChartGenerator();
    public void generateAnnualChart(int year) {
       List dataSet = new ArrayList();
       dataSet.add("data " + year);
       chartGenerator.generate(dataSet);
    }
    public void generateMonthlyChart(int month) {
       // 实现从略
    }
    public void generateDailyChart(int day) {
       // 实现从略
    }
}

public class Main {
    /** 这是测试程序的入口方法 */
    public static void main(String[] args) {
       ChartService chartService = new ChartService();
       chartService.generateAnnualChart(2009);
    }
}

至此，任务完成了。可是如果没有一个核心模块来管理这些对象，它们将不得不各自创建和管理自己的依赖，结果就是这些对象会紧紧地耦合在一起，ChartService也定义死了。需求变更时，那就是牵一发而动全身的壮烈景象。一个核心管理者自然要引入了，这里我们使用容器。
[img]http://dl.iteye.com/upload/attachment/205686/0442adfa-c0bf-38d5-b954-47694c2056ec.jpg[/img]

public class Container { 
    // 组件用来定位的全局容器类实例 
    public static Container instance; 
    // 用来存储组件的Map对象 
    private Map<String, Object> components; 
    public Container() { 
       components = new HashMap<String, Object>(); 
       instance = this; 
       ChartGenerator chartGenerator = new PieChartGenerator(); 
       components.put("chartGenerator", chartGenerator); 
       ChartService chartService = new ChartService(); 
       components.put("chartService", chartService); 
    } 
    public Object getComponent(String id) {// 根据ID寻找组件对象 
       return components.get(id); 
    } 
} 

public class ChartService { 
private ChartGenerator chartGenerator = (ChartGenerator) Container.instance.getComponent("chartGenerator"); 
    … … … 
} 

public class Main { 
    public static void main(String[] args) { 
       Container container = new Container(); 
       ChartService chartService = (ChartService) container 
              .getComponent("chartService"); 
       chartService.generateAnnualChart(2009); 
    } 
} 

v2中，加入了容器，又容器管理组件，service类就和组件解除耦合关系，但是此时service类还对容器有依赖，可以采用定位器解除这个依赖关系。
[img]http://dl.iteye.com/upload/attachment/205688/3a72ff2c-d4bf-3da0-87ed-b1930e0fe43b.jpg[/img]

public class ServiceLocator {
    private static Container container = Container.instance;
    public static ChartGenerator getChartGenerator() {
return (ChartGenerator) container.getComponent("chartGenerator");
    }
}

public class ChartService {
private ChartGenerator chartGenerator = ServiceLocator.getChartGenerator();
    …   …   …
}

服务定位器可以将查找逻辑从组件中分离出来，降低组件在查找方面的复杂性，增加了组件的重用性。但是这种方式依旧存在一个缺点：组件需要知道如何获取资源。那么要解决这个问题，控制反转的思想就要引入了，它是反转资源获取的方向。主动查找方式要求组件向容器发起请求来查找，最为回应，容器返回所需资源。而应用控制反转之后，则是容器主动地将资源送至它所管理的组件里，组件要做的就是选择一种合适的方式来接收资源。对于组件本身，这就是被动查找。
依赖注入是IoC的实现模式，主要有三种方案：setter方法注入，构造方法注入和接口注入。我们先看接口注入，接口注入要求组件必须实现容器定义的特定接口，容器正是通过这个接口注入依赖。
个人的一点体会，希望对学习者有用，也欢迎大家交流。(未完待续)