在上边一篇文章中我们介绍了 Spring AOP 的基本概念，今天我们就来学习一下与 AOP 实现相关的修饰者模式和 Java Proxy 相关的原理，为之后源码分析打下基础。
修饰者模式
Java 设计模式中的修饰者模式能动态地给目标对象增加额外的职责(Responsibility)。它使用组合(object composition)，即将目标对象作为修饰者对象(代理)的成员变量，由修饰者对象决定调用目标对象的时机和调用前后所要增强的行为。
装饰模式包含如下组成部分：
Component: 抽象构件，也就是目标对象所实现的接口，有 operation 函数；
ConcreteComponent: 具体构件，也就是目标对象的类 Decorator: 抽象装饰类，也实现了抽象构件接口，也就是目标类和装饰类都实现了相同的接口
ConcreteDecorator: 具体装饰类，其中 addBeavior 函数就是增强的行为，装饰类可以自己决定 addBeavior 函数和目标对象函数 operation 函数的调用时机。
修饰者模式的类图 修饰者模式调用的时序图如下图所示。
程序首先创建目标对象，然后创建修饰者对象，并将目标对象传入作为其成员变量。当程序调用修饰者对象的 operation 函数时，修饰者对象会先调用目标对象的 operation 函数，然后再调用自己的 addBehavior 函数。这就是类似于 AOP 的后置增强器，在目标对象的行为之后添加新的行为。
Spring AOP 的实现原理和修饰者模式类似。在上一篇文章中说到 AOP 的动态代理有两种实现方式，分别是 JDK Proxy 和 cglib。
如下图所示，JDK Proxy 的类结构和上文中修饰者的类图结构类似，都是代理对象和目标对象都实现相同的接口，代理对象持有目标对象和切面对象，并且决定目标函数和切面增强函数的调用时机。 而 cglib 的实现略有不同，它没有实现实现相同接口，而是代理对象继承目标对象类。
本文后续就讲解一下 JDK Proxy 的相关源码分析。
JDK Proxy
JDK 提供了 Proxy 类来实现动态代理的，可通过它的 newProxyInstance 函数来获得代理对象。JDK 还提供了 InvocationHandler 类，代理对象的函数被调用时，会调用它的 invoke 函数，程序员可以在其中实现所需的逻辑。
JDK Proxy 的基本语法如下所示。先构造一个 InvocationHandler 的实现类，然后调用 Proxy 的 newProxyInstance 函数生成代理对象，传入类加载器，目标对象的接口和自定义的 InvocationHandler 实例。
public class CustomInvocationHandler implements InvocationHandler { private Object target;
public CustomInvocationHandler(Object target) { this.target = target; }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before invocation"); Object retVal = method.invoke(target, args); System.out.println("After invocation"); return retVal; }}
CustomInvocationHandler customInvocationHandler = new CustomInvocationHandler( helloWord);//通过Proxy.newProxyInstance生成代理对象ProxyTest proxy = (ProxyTest) Proxy.newProxyInstance( ProxyTest.class.getClassLoader(), proxyObj.getClass().getInterfaces(), customInvocationHandler);
复制代码
生成代理对象
我们首先来看一下 Proxy 的 newProxyInstance 函数。newProxyInstance 函数的逻辑大致如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException{
final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } // 1 动态生成代理对象的类 Class<?> cl = getProxyClass0(loader, intfs);
// ... 代码省略，下边代码其实是在try catch中的 if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } // 2 获取代理类的构造函数 final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { cons.setAccessible(true); return null; } }); } // 3调用构造函数，传入InvocationHandler对象 return cons.newInstance(new Object[]{h});}
复制代码
getProxyClass0 函数的源码如下所示，通过代理类缓存获取代理类信息，如果不存在则会生成代理类。
// 生成代理类private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); }
// 如果已经有Proxy类的缓存则直接返回，否则要进行创建 return proxyClassCache.get(loader, interfaces);}
复制代码
生成代理类
JDK Proxy 通过 ProxyClassFactory 生成代理类。其 apply 函数大致逻辑如下：
校验接口是否符合规范
生成代理类的名称和包名
生成代理类字节码
根据字节码生成代理类 Class
// 生成代理类的工厂类private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>>{ // 所有代理类名的前缀 private static final String proxyClassNamePrefix = "$Proxy";
// 生成唯一类名的原子Long对象 private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class<?> intf : interfaces) { // 通过loader找到接口对应的类信息。 Class<?> interfaceClass = null; try { interfaceClass = Class.forName(intf.getName(), false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } // 判断找出来的类确实是一个接口 if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } // 判断接口是否重复 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } // 代理类的包路径 String proxyPkg = null; int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
// 记录非公开的代理接口，以便于生成的代理类和原来的类在同一个路径下。 for (Class<?> intf : interfaces) { int flags = intf.getModifiers(); if (!Modifier.isPublic(flags)) { accessFlags = Modifier.FINAL; String name = intf.getName(); int n = name.lastIndexOf('.'); String pkg = ((n == -1) ? "" : name.substring(0, n + 1)); if (proxyPkg == null) { proxyPkg = pkg; } else if (!pkg.equals(proxyPkg)) { throw new IllegalArgumentException( "non-public interfaces from different packages"); } } } // 如果没有非公开的Proxy接口，使用com.sun.proxy报名 if (proxyPkg == null) { proxyPkg = ReflectUtil.PROXY_PACKAGE + "."; }
long num = nextUniqueNumber.getAndIncrement(); // 默认情况下，代理类的完全限定名为：com.sun.proxy.$Proxy0，$Proxy1……依次递增 String proxyName = proxyPkg + proxyClassNamePrefix + num;
// 生成代理类字节码 byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); try { // 根据字节码返回相应的Class实例 return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { throw new IllegalArgumentException(e.toString()); } }}
复制代码
其中关于字节码生成的部分逻辑我们就暂时不深入介绍了，感兴趣的同学可以自行研究。
$Proxy 反编译
我们来看一下生成的代理类的反编译代码。代理类实现了 Object 的基础函数，比如 toString、hasCode 和 equals，也实现了目标接口中定义的函数，比如说 ProxyTest 接口的 test 函数。
$Proxy 中函数的实现都是直接调用了 InvocationHandler 的 invoke 函数。
public final class $Proxy0 extends Proxy implements ProxyTest // 会实现目标接口，但是由于集成了Proxy，所以无法再集成其他类{ private static Method m1; private static Method m0; private static Method m3; private static Method m2; // 构造函数要传入一个InvocationHandler对象 public $Proxy0(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } // equal函数 public final boolean equals(Object paramObject) throws { try { return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue(); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); }
public final int hashCode() throws { try { return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } // test函数，也就是ProxyTest接口中定义的函数 public final void test(String paramString) throws { try { // 调用InvocationHandler的invoke函数 this.h.invoke(this, m3, new Object[] { paramString }); return; } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); }
public final String toString() throws { try { return (String)this.h.invoke(this, m2, null); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } // 获取各个函数的Method对象 static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); m3 = Class.forName("com.proxy.test2.HelloTest").getMethod("say", new Class[] { Class.forName("java.lang.String") }); 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()); }}
复制代码
后记
下一篇文章就是 AOP 的源码分析了，希望大家继续关注。
评论