IOC 与 AOP

IOC和AOP是Spring的技术核心。网上已有很多介绍，这里借鉴过来作为学习。

IOC介绍：

   控制反转IOC(又称DI: Dependency Injection)，就是Inversion of Control。IOC主要协调个组件间的相互依赖关系，使组件间的耦合度降低。

   例子： 如果一个一个类调用另一个类的方法，一般是先new另一个类的对象，然后调用其方法。这种方法很显然耦合的厉害。

                

public class Girl implements Servicable {
　　
　　Kissable kissable;
　　
　　public void service(ServiceManager mgr) {
　　　　kissable = (Kissable) mgr.lookup(“kissable”);
　　}
　　
　　public void kissYourKissable() {
　　　　kissable.kiss();
　　 } 　　
 } 

IoC是一个很大的概念,可以用不同的方式实现。其主要形式有两种：

　　◇依赖查找：容器提供回调接口和上下文条件给组件。EJB和Apache Avalon 都使用这种方式。这样一来，组建就必须使用容器提供的API来查找资源和协作对象，仅有的控制反转只体现在那些回调方法上（也就是上面所说的方式）：容器将调用这些回调方法，从而让应用代码获得相关资源。

　　◇依赖注入：组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。容器全权负责的组建的装配，它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。通过JavaBean属性注射依赖关系的做法称为设值方法注入(Setter Injection)；将依赖关系作为构造函数参数传入的做法称为构造子注入（Constructor Injection）

                                                                以下转自(http://blog.csdn.net/ycyheartfly/article/details/1514190)  

Spring种提供了2种常用的注入方式，set方法注入和构造函数注入。由于这2种注入方式很相似，都可以满足我们的需求，所以在大多数情况下我们忽视了这2种注入方式的区别。下面让我们看看这2种注入方式的特点。
我们先看看Spring在使用set方法注入时，是怎样实例化一个Bean和Bean的合作者的：

在A中有一个setB方法用来接收B对象的实例。那么Spring实例化A对象的过程如下：

在不考虑Bean的初始化方法和一些Spring回调的情况下，Spring首先去调用A对象的构造函数实例化A，然后查找A依赖的对象本例子中是B（合作者）。一但找到合作者，Spring就会调用合作者(B)的构造函数实例化B。如果B还有依赖的对象Spring会把B上依赖的所有对象都按照相同的机制实例化然后调用A对象的setB(B b)把b对象注入给A。
因为Spring调用一个对象的set方法注入前,这个对象必须先被实例化。所以在"使用set方法注入"的情况下Spring会首先调用对象的构造函数。
我们在来看通过构造函数注入的过程：

如果发现配置了对象的构造注入，那么Spring会在调用构造函数前把构造函数需要的依赖对象都实例化好，然后再把这些实例化后的对象作为参数去调用构造函数。
在使用构造函数和set方法依赖注入时，Spring处理对象和对象依赖的对象的顺序时不一样的。一般把一个Bean设计为构造函数接收依赖对象时，其实是表达了这样一种关系：他们（依赖对象）不存在时我也不存在，即“没有他们就没有我”。
通过构造函数的注入方式其实表达了2个对象间的一种强的聚合关系：组合关系。就比如一辆车如果没有轮子、引擎等部件那么车也就不存在了。而且车是由若干重要部件组成的，在这些部件没有的情况下车也不可能存在。这里车和他的重要部件就时组合的关系。如果你的应用中有这样类似的场景那么你应该使用“构造函数注入”的方式管理他们的关系。“构造函数注入”可以保证合作者先创建，在后在创建自己。
通过set方法注入的方式表达了2个对象间较弱的依赖关系：聚合关系。就像一辆车，如果没有车内音像车也时可以工作的。当你不要求合作者于自己被创建时，“set方法注入”注入比较合适。
虽然在理论上“构造函数注入”和“set方法注入”代表2种不同的依赖强度，但是在spring中，spring并不会把无效的合作者传递给一个 bean。如果合作者无效或不存在spring会抛出异常，这样spring保证一个对象的合作者都是可用的。所以在spring中，“构造函数注入”和 “set方法注入”唯一的区别在于2种方式创建合作者的顺序不同。
使用构造函数依赖注入时，Spring保证所有一个对象所有依赖的对象先实例化后，才实例化这个对象。（没有他们就没有我原则）
使用set方法依赖注入时，Spring首先实例化对象，然后才实例化所有依赖的对象。

AOP

  我们首先用动态代理来实现AOP，看一下AOP的大概流程：

我们有一个类，简单的做一件事情，就是输出一句hi。不过我们想在输出hi之前打印一句话，输出后打印一句话。下面是代码。

//sayhi类的接口

public interface isayHi
{
public void sayHi();
}

//sayhi类

public class SayHi implements isayHi
{
public void sayHi() 
{
System.out.println("HI all");
}
}

//日志

public class LogHandler implements InvocationHandler { 


 private Object delegate; 
 public LogHandler(Object obj)
 {
delegate = obj;
 }
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
 Object o = null; 
 try {    
   System.out.println("before................");
   o = method.invoke(delegate,args); 
   System.out.println("after.................");   
   
   } catch (Exception e){   


   }
  return o; 
} 
}  

//测试用类

public class testAOP
{


/**
* @param args
*/
public static void main(String[] args)
{
// TODO Auto-generated method stub
isayHi sHi = new SayHi();
InvocationHandler handler = new LogHandler(sHi);

isayHi shproxyHi = (isayHi)Proxy.newProxyInstance(sHi.getClass().getClassLoader(), 
sHi.getClass().getInterfaces(),
handler);
shproxyHi.sayHi();
}
}

AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。然而殊途同归，实现AOP的技术特性却是相同的。