Java server框架之(2): Spring中的AOP

背景：

 现阶段java web server开发的流行框架包括： Sping SpringMVC iBatis(MyBatis)等。在面试中，Spring的IOC和AOP会经常被问到:它们的含义，甚至是如何使用纯java实现它们？

 什么是AOP？

AOP（Aspect Orient Programming），作为面向对象编程的一种补充，广泛应用于处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。 AOP 实现的关键就在于 AOP 框架自动创建的AOP代理，AOP代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。

面向切面编程（aop）是对面向对象编程（oop）的补充，面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。比如说,我们现在要开发的一个应用里面有很多的业务方法,但是,我们现在要对这个方法的执行做全面监控,或部分监控.也许我们就会在要一些方法前去加上一条日志记录.我们写个例子看看我们最简单的解决方案.
我们先写一个接口IHello.java代码如下:

package sinosoft.dj.aop.staticaop;
    public interface IHello { 
    /** 假设这是一个业务方法      
    * @param name      
    */     
    void sayHello(String name); 
} 

 

 

里面有个方法,用于输入"Hello" 加传进来的姓名;我们去写个类实现IHello接口

package sinosoft.dj.aop.staticaop; 
public class Hello implements IHello {     
    public void sayHello(String name) {         
        System.out.println("Hello " + name);     
    } 
}

 

 

现在我们要为这个业务方法加上日志记录的业务,我们在不改变原代码的情况下,我们会去怎么做呢?也许,你会去写一个类去实现IHello接口,并依赖Hello这个类.代码如下:

package sinosoft.dj.aop.staticaop; 
public class HelloProxy implements IHello { 
    private IHello hello; 
    public HelloProxy(IHello hello) { 
        this.hello = hello;     
    } 
    public void sayHello(String name) { 
        Logger.logging(Level.DEBUGE, "sayHello method start.");                 
        hello.sayHello(name); 
        Logger.logging(Level.INFO, "sayHello method end!"); 
   } 
} 

 

 

其中Logger类和Level枚举代码如下:
Logger.java

 

package sinosoft.dj.aop.staticaop; 

import java.util.Date; 

public class Logger{ 
    /** 
    * 根据等级记录日志      
    * @param level      
    * @param context      
    */ 
    public static void logging(Level level, String context) { 
        if (level.equals(Level.INFO)) { 
            System.out.println(new Date().toLocaleString() + " " + context); 
        } 
        if (level.equals(Level.DEBUGE)) { 
            System.err.println(new Date() + " " + context); 
        } 
   } 
} 

 

Level.java

package sinosoft.dj.aop.staticaop; 
public enum Level { 
    INFO,DEBUGE; 
}

 

 那我们去写个测试类看看,代码如下:
Test.java

package sinosoft.dj.aop.staticaop; 
public class Test { 
    public static void main(String[] args) { 
        IHello hello = new HelloProxy(new Hello());    
        hello.sayHello("Doublej");
    } 
}

 

运行以上代码我们可以得到下面结果:

Tue Mar 04 20:57:12 CST 2008 sayHello method start. 
Hello Doublej 
2008-3-4 20:57:12 sayHello method end!

 

从上面的代码我们可以看出,hello对象是被HelloProxy这个所谓的代理类所创建的.这样,如果我们以后要把日志记录的功能去掉.那我们只要把得到hello对象的代码改成以下:

package sinosoft.dj.aop.staticaop; 
public class Test { 
    public static void main(String[] args) { 
        IHello hello = new Hello(); 
        hello.sayHello("Doublej"); 
    } 
} 

 

上面代码,可以说是AOP最简单的实现!

  动态代理

但是我们会发现一个问题,如果我们像Hello这样的类很多,那么,我们是不是要去写很多个HelloProxy这样的类呢.没错,是的.其实也是一种很麻烦的事.在jdk1.3以后.jdk向我们提供了一个名为java.lang.reflect.InvocationHandler的类. 这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.让我们把以上的代码改一下来看看效果.同样,我们写一个IHello的接口和一个Hello的实现类.在接口中我们定义两个方法。代码如下 :

IHello.java

package sinosoft.dj.aop.proxyaop; 
public interface IHello { 
    /** *//** 
    * 业务处理A方法 
    * @param name 
    */ 
    void sayHello(String name); 

    /** *//** 
    * 业务处理B方法 
    * @param name 
    */ 
    void sayGoogBye(String name); 
} 

 

Hello.java

package sinosoft.dj.aop.proxyaop; 
public class Hello implements IHello { 
    public void sayHello(String name) { 
        System.out.println("Hello " + name); 
    } 
    public void sayGoogBye(String name) { 
        System.out.println(name+" GoodBye!"); 
    } 
}

 

我们一样的去写一个代理类.只不过，代理类不再实现具体的接口，而是让这个类去实现java.lang.reflect.InvocationHandler接口,代码如下:

package sinosoft.dj.aop.proxyaop; 

import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method; 
import java.lang.reflect.Proxy; 

public class DynaProxyHello implements InvocationHandler { 
    /**  
    * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello) 
    */
    private Object delegate; 

    /**  
    * 动态生成方法被处理过后的对象 (写法固定) 
    * 
    * @param delegate 
    * @param proxy 
    * @return 
    */ 
    public Object bind(Object delegate) { 
        this.delegate = delegate; 
        return Proxy.newProxyInstance( 
                this.delegate.getClass().getClassLoader(), this.delegate 
                .getClass().getInterfaces(), this); 
    } 

    /** *//** 
    * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用 
    * 此方法是动态的,不是手动调用的 
    */ 
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable { 
        Object result = null; 
        try { 
            //执行原来的方法之前记录日志 
            Logger.logging(Level.DEBUGE, method.getName() + " Method end ."); 
            //JVM通过这条语句执行原来的方法(反射机制) 
            result = method.invoke(this.delegate, args); 
            //执行原来的方法之后记录日志 
            Logger.logging(Level.INFO, method.getName() + " Method Start!"); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
        //返回方法返回值给调用者 
        return result; 
    } 
}

 可见，在这里使用了Java反射机制。

 

上面类中出现的Logger类和Level枚举还是和上一例子的实现是一样的.这里就不贴出代码了.
让我们写一个Test类去测试一下.代码如下:
Test.java

package sinosoft.dj.aop.proxyaop; 
public class Test { 
    public static void main(String[] args) { 
        IHello hello = (IHello)new DynaProxyHello().bind(new Hello());    
        // here, new Hello() should can be replaced by other class& object. 
        hello.sayGoogBye("Double J"); 
        hello.sayHello("Double J"); 
    } 
} 

 

运行输出的结果如下:

Tue Mar 04 21:24:03 CST 2008 sayGoogBye Method end . 
Double J GoodBye! 
2008-3-4 21:24:03 sayGoogBye Method Start! 
Tue Mar 04 21:24:03 CST 2008 sayHello Method end . 
Hello Double J 
2008-3-4 21:24:03 sayHello Method Start!

 

由于线程的关系,第二个方法的开始出现在第一个方法的结束之前.这不是我们所关注的!
从上面的例子我们看出，只要你是采用面向接口编程,那么,你的任何对象的方法执行之前要加上记录日志的操作都是可以的.他(DynaPoxyHello) 自动去代理执行被代理对象(Hello)中的每一个方法,一个java.lang.reflect.InvocationHandler接口就把我们的代理对象和被代理对象解藕了.

 

在上述代码示例中，涉及一个概念，动态代理。什么是动态代理： 说起动态，其实不如先说什么是静态。所谓静态代理，个人理解为自己手写的代理类，或者用工具生成的代理类，或者别人帮你写的代理类(没说一样...)。总之，就是程序运行前就已经存在的编译好的代理类。相反，如果代理类程序运行前并不存在，需要在程序运行时动态生成(无需手工编写代理类源码)，那就是今天要说的动态代理了。如何生成的：根据Java的反射机制动态生成。

 

Java中的代理(具体来说，就是java.lang.reflect.Proxy这个类)是针对接口的动态代理，当然java也可以使用第三方的CGLIB实现针对类的代理，但是JDK中只支持针对接口的动态代理，我们只分析JDK的动态代理。需要指出的是，java.lang.reflect.Proxy这个类是设计模式中的结构模式Proxy在JDK中的典型实现之一。

JDK动态代理的要素：

(1).实现了InvocationHandler的代理处理类，实现其invoke方法，该方法是代理调用目标对象方法以及提供额外操作的方法。

(2).使用Proxy.newProxyInstance(类加载器, 代理接口列表,InvocationHandler对象)方法创建实现了指定接口的动态代理。

 

在上述实现中，涉及到了java.lang.reflect.InvocationHandler接口。 InvocationHandler是一个proxy实例的invocation handler所实现的接口，该接口只有一个方法声明：

 public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

 

每一个proxy实例都有一个与之关联的invocaion handler：

  /**
     * the invocation handler for this proxy instance.
     * @serial
     */
    protected InvocationHandler h;

 

当调用一个proxy实例的方法时，这个调用被分发到该实例的invocation handler的invoke方法。

 CGLIB

 在Spring中有CGLIB的实现，在jdk中的动态代理是面向接口的，所以在Spring中提供了cglib，使用cglib实现的动态代理是面向类的。

之所以说jdk中的Proxy类是面向接口的，是会因为它的方法newProxyInstance把接口作为它的参数：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

 

 

 

 

 

进一步问题

>> 代理模式在server programming中的重要性，可以更方便地实现各种log。 此处可以跟traveler server的log机制多做对比。 ? 待补充。

nts中的log机制比较重要的是level。 aop当中，是否也可以实现log的level？

其实，在本文的代码示例中，还可以与logger进一步解耦。。。

 

参考文献：

http://blog.csdn.net/hsuxu/article/details/9340619
http://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/index.html

http://www.cnblogs.com/aurawing/articles/1886982.html

http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

 

http://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/index.html