SpringAop篇 (1) AOP 基础之动态代理的实现

介绍

Spring AOP 主要通过 动态代理 来实现的，所以我们需要在介绍 AOP 用法之前，先来介绍下动态代理的用法以及本质。

对于动态代理的理解可以借鉴普通代理模式。我们普通的Java代理需要为一个对象建立专门的代理对象，通过调用代理对象，来实现原对象的各种功能。

而动态代理区别于普通代理方式,动态代理是在运行时产生的代理类。

普通代理的实现方式：

接口 :

public interface Subject {public void request();
}

实现类:

public class RealSubject implements Subject{@Overridepublic void request() {System.out.println("request");}
}

代理类:

public class RealProxySubject implements Subject {private Subject subject;public RealProxySubject(){this.subject = new RealSubject();}public void preRequest(){System.out.println("Preset Request");}public void afterRequest(){System.out.println("After Request");}@Overridepublic void request() {this.preRequest();subject.request();this.afterRequest();}
}

调用方式:

public static void main(String[] args) {Subject subject = new RealProxySubject();subject.request();
}

这里我们重新再看下普通代理类，来跟动态代理做下比较。首先必须要定义接口(Subject), 实现类(RealSubject)与代理类(RealProxySubject)都必须要继承接口。

关于实现类 RealSubject 要暴露main方法中，还是要在代理类中构造，这个可以根据具体的场景合理选择。

动态代理实现方式

接下来我们看下动态代理与普通代理方式的区别与联系，动态代理需要使用的 Java 的反射相关的包来实现：

代理的实现细节类需要继承 java.lang.reflect.InvocationHandler 接口, 在 invoke 方法中实现代理细节；
通过 java.lang.reflect.Proxy 类指定 ClassLoader 对象和一组 interface, 与代理的实现细节类来创建动态代理类；

我们看下动态代理的实现细节:

接口:

public interface Subject {public int request();
}

实现类:

public class RealSubject implements Subject{@Overridepublic int request() {System.out.println("hello world");return 10;}
}

代理的实现细节类 :

public class SubjectProxy implements InvocationHandler {private Subject subject;public SubjectProxy(Subject subject) {this.subject = subject;}public Subject getSubject(){return (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("Preset Action");Object result= method.invoke(subject, args);System.out.println("After Action");return result;}
}

使用方式：

public static void main(String[] args) {SubjectProxy proxy = new SubjectProxy(new RealSubject());Subject subject = proxy.getSubject();int result = subject.request();System.out.println(result);
}

说明:

从上面的例子中可以看出，动态代理的重点部分就是这个代理的实现细节类(SubjectProxy), 代理的实现细节类(SubjectProxy) 负责实现代理细节 (通过invoke方法)。并构造一个匿名的代理类(Proxy.newProxyInstance 方法)。

Proxy.newProxyInstance 通过类加载器与指定的接口，构建一个继承匿名的代理类：

public final class $Proxy0 extends Proxy implements Subject {private static Method m1;private static Method m3;private static Method m0;private static Method m2;public $Proxy0 (InvocationHandler paramInvocationHandler) {super(paramInvocationHandler);}public final boolean equals(Object paramObject) {try {return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();}catch (Error|RuntimeException localError) {throw localError;}catch (Throwable localThrowable) {throw new UndeclaredThrowableException(localThrowable);}}public final void request() {try {this.h.invoke(this, m3, null);return;}catch (Error|RuntimeException localError) {throw localError;}catch (Throwable localThrowable) {throw new UndeclaredThrowableException(localThrowable);}}public final int hashCode() {try {return ((Integer)this.h.invoke(this, m0, null)).intValue();}catch (Error|RuntimeException localError) {throw localError;}catch (Throwable localThrowable) {throw new UndeclaredThrowableException(localThrowable);}}public final String toString() {try {return (String)this.h.invoke(this, m2, null);}catch (Error|RuntimeException localError) {throw localError;}catch (Throwable localThrowable) {throw new UndeclaredThrowableException(localThrowable);}}static {try {m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });m3 = Class.forName("com.saligia.spring.aop.proxy.dynamic.Subject").getMethod("request", null);m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);return;}catch (NoSuchMethodException localNoSuchMethodException) {throw new NoSuchMethodError(localNoSuchMethodException.getMessage());}catch (ClassNotFoundException localClassNotFoundException) {throw new NoClassDefFoundError(localClassNotFoundException.getMessage());}}
}

从上面的可以看出来, 匿名类继承了 Proxy类与Subject接口，当调用了 subject 中的方法时，会转为我们在SubjectProxy重写的 invoke 方法。

所以，我们这里总结下:

Proxy.newProxyInstance 返回的对象会根据，类加载器，接口，还有代理构建一个与接口跟 InvocationHandler实现 相关的匿名代理类，对于代理类本身来说，至于接口相关，跟接口具体实现的哪个具体子类并无关系。

而产生关系来自于 InvocationHandler 实现, 他将接口方法使用反射形式传递给了子类实例的相关方法的调用。

并且对于 InvocationHandler 的 invoke方法，我们通过这个匿名代理类也可以解读

/*** @param : proxy  匿名代理类* @param : method 通过接口解析方法* @param : args   匿名代理类通过方法接受的函数参数*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

这样我们可以通过 Proxy 跟 InvocationHandler 便构造出来了我们需要的实现类的代理类。

总结:

从上所述可以看出,代理模式必须要有接口, 代理类跟实现类都是继承自同一个接口。
我们只能通过接口类型去接收匿名代理类：如上面的 Subject subject = proxy.getSubject();
匿名代理类与实现类的关系在InvocationHandler.invoke中实现。
关于invoke方法中的proxy字段一般不要调用，从上面可以看出，容易引起死循环。