推荐订阅源

1：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();

2：AOP

 AOP即Aspect-Oriented Programming的缩写，中文意思是面向切面编程，也有译作面向方面编程的，因为Aspect有“方面、见地”的意思。AOP实际上是一种编程思想，由Gregor Kiczales在Palo Alto研究中心领导的一个研究小组于1997年提出[1]。在传统的面向对象（Object-Oriented Progr amming，OOP）编程中，对垂直切面关注度很高，横切面关注却很少，也很难关注。也就是说，我们利用OOP思想可以很好的处理业务流程，却不能把系统中的某些特定的重复性行为封装在某个模块中。比如在很多的业务中都需要记录操作日志，结果我们不得不在业务流程种嵌入大量的日志记录代码。无论是对业务代码还是对日志记录代码来说，今后的维护都是非常复杂的。由于系统种嵌入了这种大量的与业务无关的其它重复性代码，系统的复杂性、代码的重复性增加了，从而使bug的发生率也大大的增加。

       在OOP面向对象编程中，我们总是按照某种特定的执行顺序来实现业务流程，各个执行步骤之间是相互衔接、相互耦合的。比如某个对象抛出了异常，我们就必须对异常进行处理后才能进行下一步的操作；又比如我们要把一个学生记录插入到教务管理系统的学生表中去，那么我们就必须按照注册驱动程序、连接数据库、创建一个statement、生成并执行SQL语句、处理结果、关闭JDBC对象等步骤按部就班的编写我们的代码。可以看到上面的步骤种除了执行SQL和处理结果是我们业务流程所必须的外，其它的都是重复的准备和殿后工作，与业务流程毫无关系，另外我们还得要考虑程序执行过程中的异常。天！我们只是需要向一张表中插入数据而已，可是却不得不和这些大量的重复代码纠缠在一起，我们不得不把大量的精力用在这些代码上而无法专心的设计业务流程。

       那么什么可以解决这个问题呢？这时候，我们需要AOP，关注系统的“截面”，在适当的时候“拦截”程序的执行流程，把程序的预处理和后处理交给某个拦截器来完成。比如在操作数据库时要记录日志，如果使用AOP的编程思想，那么我们在处理业务流程时不必再考虑日志记录，而是把它交给一个特定的日志记录模块去完成。这样，业务流程就完全的从其它无关的代码中解放出来，各模块之间的分工更加明确，程序维护也变得容易多了。

      正如上所说，AOP不是一种技术，而是编程思想。凡是符合AOP思想的技术，都可以看成是AOP的实现。目前的AOP实现有AspectJ、JBoss4.0、nanning、spring等项目。其中Spring对AOP进行了很好的实现，同时Spring AOP也是Spring的两大核心之一。

     下面介绍一些关于AOP的一些概念，如果觉得有些晦涩，也可以先不必仔细关注。

     连接点（join point）：它是指应用中执行的某个点，即程序执行流程中的某个点。如执行某个语句或者语句块、执行某个方法、装载某个类、抛出某个异常……，如下：

1. public static void main(String[] args) throws Exception {   
2.     
3.      int i = 0;   
4.     
5.      i++;   
6.      CallMyMethod();   
7.     
8.      throw new Exception("哈哈，一个异常！");   
9.     
10. }   

      注意：这里每一个语句都可以被称作一个连接点。
      连接点是有“强弱”的，这种强弱可以用“粒度”来表示，Spring AOP支持到方法级的连接点粒度。

     切入点（pointcut）：切入点是连接点的集合，它通常和装备联系在一起，是切面和程序流程的交叉点。比如说，定义了一个pointcut，它将抛出异常ClassNotFoundException和某个装备联系起来，那么在程序执行过程中，如果抛出了该异常，那么相应的装备就会被触发执行。

     装备（advice）：也可以叫做“通知”，指切面在程序运行到某个连接点所触发的动作。在这个动作种我们可以定义自己的处理逻辑。装备需要利用切入点和连接点联系起来才会被触发。目前AOP定义了五种装备：前置装备（Before advice）、后置装备（After advice）、环绕装备（Around Advice）、异常装备（After throwing advice）、返回后装备（After returning advice）。这些装备以后会逐一介绍。

    目标对象（target object）：被一个或者多个切面装备的对象。所以它有时候也被称为Advised Object。

    引入（introduction）： 声明额外的成员字段或者成员方法。它可以给一个确定的对象新增某些字段或者方法。

     织入（weaving）：将切面和目标对象联系在一起的过程。这个过程可以在编译期完成，也可以在类加载时和运行时完成。Spring AOP是在运行期完成织入的。

     切面（aspect）：一个关注点的模块化。它实际上是一段将被织入到程序流程中的一段代码。