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框架能够将系统的很多其它固定參数丢到配置文件里去，或者直接使用注解也能够。