Java的面向AOP编程

一、 引言

AOP（Aspect-Oriented Programming，面向切面的编程），是一种新型的编程范式，主张关注软件流程中的一个切面，将同样功能的代码整合打包在一起，降低系统的耦合性，增强其扩展性。

传统的软件设计，往往采取事件驱动模型带来类似的效果，通过在可能的事件切入点插入事件回调函数，将对应位置插入外置代码。

函数式编程，也有类似的解决方案，通过函数传递，将对应位置的扩展上新的功能。

Java作为一门严谨的传统式开发语言，以安全性和可靠性为第一标准，语言并没有过多的新特性支持，Java8仅支持到lambda表达式，为了使Java具有更强大的编程模型，Spring等框架使用gclib库实现了面向切面的编程模型。

二、 CGLIB 和 ASM

CGLIB 是一个强大的,高性能,高质量的Code生成类库，被广泛的用作动态代理技术。CGLIB 包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类，新的字节码可以被Java虚拟机直接加载运行。

其实动态代理并不是CGLIB的专利，早在JDK1.3版起，就引入了动态代理库，Spring AOP 编程时就可以进行选择，使用JDK提供的动态代理库，或者是引入CGLIB库。

下面举一个实例，来说明一些如何使用CGLIB库，将我们本来应该正常执行的函数调用，进行截断操作。

package com.abs.testcglib;

public class Service {
    String name;

    public Service(String name) {
        this.name = name;
    }

    public void sayHello() {
        System.out.println("Hello "+name);
    }
}

首先，我们创建一个服务类，其中有一个sayHello() 方法，我们希望将这个方法截断，以添加其余组件的一些处理功能，例如持久化组件希望在此添加一条记录一类的功能。

package com.abs.testcglib;

public class Main {
    public static void main(String[] args) {
        Service s = new Service("Sxf");
        s.sayHello();
    }
}

在Main函数中调用一下，可以看的Hello Sxf 的输出。

但我们怎么截断呢？首先就要创建一个代理类，所谓代理，就是你让这个代理类，代你调用这个类的函数。

创建一个代理类：

package com.abs.testcglib;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法名："+method.getName());
        Service a = (Service) o;
        a.name = "Wah";
        System.out.println("哈哈，我要改名");
        Object result = methodProxy.invokeSuper(o, args);
        return result;
    }
}

这个代理类的功能，就是将传统的Java直接的函数调用，包上一次外壳，因为Java本身的函数调用是系统完成的，很难由你大段他，但代理类不同，你可以明确的看的调用了哪个函数，并且可以根据这点，轻松的在函数调用前后，插入你希望插入的代码。

public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy)
这个函数大概是整个代理调用中最关键的一个函数了，o这个参数表示了该函数所在的对象，args是调用的参数，Method则是反射到的方法。最后一个则是代理的实例。
我们对函数的打断功能，则都在这个函数里实现。

当然，由于是通过代理实现，对象的构建也有所不同，所以我们自己写一个static函数作为构造函数使用。

package com.abs.testcglib;

import net.sf.cglib.proxy.Enhancer;

public class Service {
    String name;

    public Service(String name) {
        this.name = name;
    }

    public void sayHello() {
        System.out.println("Hello "+name);
    }

    public static Service getProxyInstance(CglibProxy myProxy, String name) {
        Enhancer en = new Enhancer();
        // 设置父类和回调
        en.setSuperclass(Service.class);
        en.setCallback(myProxy);
        // 调用其构造函数，需要传入对应的Class列表和参数Object列表
        return (Service) en.create(new Class[] {String.class}, new Object[] {name});
    }
}

而Main函数中也应该这样使用该对象：

package com.abs.testcglib;

public class Main {
    public static void main(String[] args) {
        Service s = new Service("Sxf");
        s.sayHello();

        Service s2 = Service.getProxyInstance(new CglibProxy(), "Sxf");
        s2.sayHello();
    }
}

我们发现，两种方式创建出的对象，使用上几乎一样，唯一不同的就是构造函数时，我们进行了部分修改，其余部分，不影响我们的对象正常传递，存储等功能。

最终效果：

三、 Spring AOP 的实现

其实看来刚才CGLIB的实现，再看著名的Spring框架，就会发现两者的实现方式几乎完全一样，只不过Spring框架多增加了一些概念和功能。

下面我们写一个Target 类，这是一个被代理的目标对象，其中有一个execute()方法，现在使用 AOP 对 execute()方法做日志输出。在执行execute()方法前，做日志输出。

public class Target {
    public void execute(String name){
        System.out.println("executeMethod is here" + name);
    }
}

通知可以拦截目标对象的 execute()方法,并执行日志输出。创建通知的代码如下:

public class LoggerExecute implements MethodInterceptor {
    public Object invoke(MethodInvocation arg0) throws Throwable {
        before();
        arg0.proceed();
        return null;
    }
    private void before() {
        System.out.println("executeMethod is exe!");
    }
}

创建代理的方法也几乎一样：

public static void main(String[] args) {
    //创建目标对象
    Target target = new Target();
    //创建代理
    ProxyFactory di=new ProxyFactory();
    di.addAdvice(new BeforeExecute());
    di.setTarget(target);
    Target proxy=(Target)di.getProxy();
    //代理执行execute()方法
    proxy.execute(" ni hao");
}

当然Spring的切入点和其配置文件关联十分紧密，用Spring框架能够将系统的更多固定参数丢到配置文件中去，或者直接使用注解也可以。