从代理模式到Spring AOP原理
（一）简介
Spring的核心是IOC与AOP，IOC主要是依赖关系的管理，包括依赖查询和依赖注入，在之前关于bean的文章中已经对bean的生命周期做了相对多的分析，基本了解了IOC的原理。在这里我们来探讨下AOP的实现原理。
AOP（面向方面编程），也被称为面向切面编程。AOP技术利用一种称为“横切”的技术，解剖封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，这样就能减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似，比如权限认证、日志、事务处理等功能。
这些概念似乎很难懂，专业术语太多。确实，我第一次学也完全不知道他在讲什么。于是我们还是老规矩，先不看这些概念，自己去实现一个简单的AOP模块来帮助我们理解。实现AOP的技术，主要分为两大类：
采用动态代理技术，编写一个代理类的接口，实现一个真正的代理类，实现该接口，创建一个动态的代理类，实现InvocationHandler接口，并重写invoke()方法，调用Proxy.newProxyInstance()方法生成动态代理对象。
采用静态代理技术，自定义一个代理类（增强类）实现和被代理类（被增强类）相同的接口，在代理类中声明被代理类的对象，在代理类的方法中使用被代理类调用方法。
这张图可以帮助大家大概了解静态代理和动态代理的主要区别，具体的细节我会在下面的实例中讲。
（二）静态代理版AOP
首先，我们需要定义我们的核心业务类的接口。
public interface IHello {
void sayHello(String str);
}
然后，构建我们的目标类，也就是核心类。
public class Hello implements IHello{
@Override
public void sayHello(String str) {
System.out.println("hello " + str);
}
}
紧接着是代理类。代理类其实很好理解，就是一个类调用了目标类的方法，相当于一个替目标类做事的类。除了目标类的方法之外，代理类还会做一些别的工作，比如在这里我们可以让他写日志。
public class ProxyHello implements IHello{
private Hello hello;
public ProxyHello() {
super();
this.hello = new Hello();
}
@Override
public void sayHello(String str) {
Logger.start(); //添加特定的方法
hello.sayHello(str); //调用目标类方法
Logger.end(); //添加特定的方法
}
}
用来写日志的调用类，将会在代理类中调用。
public class Logger {
public static void start(){
System.out.println(new Date()+ " say hello start");
}
public static void end(){
System.out.println(new Date()+ " say hello end");
}
}
测试一下，需要日志功能时，我们就可以使用代理类，不需要日志功能时我们直接使用目标类即可。
public class Test {
public static void main(String[] args) {
IHello hello = new ProxyHello(); //需要日志功能，使用代理类
//IHello hello = new Hello(); //不需要日志功能，直接使用目标类
hello.sayHello("tomorrow");
}
}
这样我们就实现了一个最简单的AOP。但是静态代理的实现会存在一个问题：如果我们像Hello这样的类很多，那么我们就要去写很多个HelloProxy这样的类。很明显这是一件麻烦的事，也不利于后期维护。那么我们就会想办法来改进，这也就出现了动态代理的实现方式。
（三）动态代理版AOP
我们先来看一种简单的基于JDK Proxy的动态代理实现方式。首先，我们依旧先把我们的核心业务接口和目标类写好。
public interface IHello {
void sayHello(String str);
}
public class Hello implements IHello{
@Override
public void sayHello(String str) {
System.out.println("hello " + str);
}
}
注意这个日志的接口，我们传入的参数是一个方法对象
public interface ILogger {
void start(Method method);
void end(Method method);
}
日志实现类也与之前不太一样，这里我们可以手动来获取方法名，这样日志中就可以记录调用的方法的名称。
public class DLogger implements ILogger{
@Override
public void start(Method method) {
System.out.println(new Date() + method.getName() + " say hello start");
}
@Override
public void end(Method method) {
System.out.println(new Date() + method.getName() + " say hello end");
}
}
下面我们来看看这个DynaProxyHello类，很容易发现他是InvocationHandler接口的实现类。首先我们会注意到两个属性，一个是proxy，一个是target，分别代表了我们的调用对象（这个案例中指日志模块）和目标对象。其中bind方法中调用了newProxyInstance方法，他通过字符串化产生一个新的java类，再动态编译返回对象，注意是动态编译。简单来说就是他通过一些传递进来的参数，自己动态模拟写了一个java类，实例化对象之后返回给用户，这个对象就是我们的代理对象。
invoke方法中就是通过反射来调用日志方法和核心方法，我们可以看见start.invoke、method.invoke、end.invoke，因为用了反射所以看起来可能复杂一些，但实际上功能与前面的静态代理并没有什么本质区别。当我们创建了的代理类对象进行方法调用的时候，都会转化为对invoke方法的调用。
public class DynaProxyHello implements InvocationHandler{
private Object proxy; //调用对象
private Object target; //目标对象
public Object bind(Object target,Object proxy){
this.target = target;
this.proxy = proxy;
//生成代理对象
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
//反射得到调用类
Class clazz = this.proxy.getClass();
//反射得到调用类的Start方法
Method start = clazz.getDeclaredMethod("start", new Class[]{
Method.class});
//反射执行start方法
start.invoke(this.proxy, new Object[]{
method});
//执行目标类的核心方法
method.invoke(this.target, args);
//反射得到调用类的end方法
Method end = clazz.getDeclaredMethod("end", new Class[]{
Method.class});
//反射执行end方法
end.invoke(this.proxy, new Object[]{
method});
return result;
}
}
下面来测试一下。
public class Test {
public static void main(String[] args) {
IHello hello = (IHello) new DynaProxyHello().bind(new Hello(), new DLogger()); //需要日志功能，使用代理类
//IHello hello = new Hello(); //不需要日志功能，直接使用目标类
hello.sayHello("tomorrow");
}
}
我们可以发现JDK Proxy版的动态代理有一个问题，就是只能针对接口进行代理（测试类主函数的第一行 IHello hello = (IHello) new DynaProxyHello().bind(new Hello(), new DLogger()); 需要基于IHello接口），如果我们要代理一个普通对象，这个方法是无法使用的。因此我们需要寻找另一种方法。
CGLIB，一个比JDK Proxy的动态代理更加强大的代理工具，底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类，比使用反射效率更高。他可以实现普通对象（无接口）的代理，并且代码更加紧凑易读，下面我们就用CGLIB来实现与上面同样的功能。
首先我们需要导入cglib包，我这里用的是当前的最新版本3.3.0。
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
然后将之前写过的日志模块的接口和实现类写好。
public interface ILogger {
void start(Method method);
void end(Method method);
}
public class DLogger implements ILogger {
@Override
public void start(Method method) {
System.out.println(new Date() + method.getName() + " say hello start");
}
@Override
public void end(Method method) {
System.out.println(new Date() + method.getName() + " say hello end");
}
}
然后是我们的核心业务类。
public class Hello {
public void sayHello(String str) {
System.out.println("hello " + str);
}
}
紧接着，是最关键的拦截器，这是与上面JDK的动态代理最不一样的地方。这个类要实现MethodInterceptor接口，实际上实现的功能和上面的invoke方法基本一致，我们这里可以先把他当做invoke方法来理解。
public class DynaProxyHello implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
DLogger dLogger = new DLogger();
dLogger.start(method);
Object object = methodProxy.invokeSuper(o, objects);
dLogger.end(method);
return object;
}
}
然后是测试类，这个类明显比较复杂，我们来看看他干了些什么事。首先将目标类Hello设置成父类，然后设置拦截器DynaProxyHello，最后执行enhancer.create()动态生成一个代理类，并从Object强制转型成父类Hello。其中，Enhancer类是CGLib中的一个字节码增强器，它可以方便的对你想要处理的类进行扩展，我们暂时还不需要了解这么细，想弄明白的朋友可以自行Google。
public class Test {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
//继承目标类
enhancer.setSuperclass(Hello.class);
//设置回调
enhancer.setCallback(new DynaProxyHello());
//生成代理对象
Hello hello = (Hello) enhancer.create();
hello.sayHello("tomorrow");
}
}
这样一个基于CGLib的动态代理就写完了，我个人感觉这个过程比基于JDK的动态代理要简单一点，不过涉及的知识点反而更多了，需要去仔细的思考。我们可以看一下刚刚讲的两种动态代理方式的AOP实现的区别：
不卖关子了，实际上Spring AOP就是基于动态代理的。如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy去创建代理对象。而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用CGlib生成一个被代理对象的子类来作为代理。当然，我们也可以设置强制使用CGlib。
2020年7月23日