Spring事务Transactional和动态代理（一）-JDK代理实现
- 2020 年 3 月 4 日
- 筆記
系列文章索引：
- Spring事务Transactional和动态代理（一）-JDK代理实现
- Spring事务Transactional和动态代理（二）-cglib动态代理
- Spring事务Transactional和动态代理（三）-事务失效的场景
什么是代理
理设计模式提供了对目标对象的间接访问方式，能力模式能够解耦合并且便于扩展目标的功能。
在现实生活这，我们消费者如果要去购买一杯牛奶的时候，并不是直接去找牛奶厂商购买，而是在便利店或者超市购买（零售商）；超市进货的时候也通常不是直接找牛奶厂商，而是找市级代理（渠道经销商），市级代理再找省级代理（代理商），省级代理从牛奶生产商（厂商）提货。
如下图，虽然通过层层代理，一杯牛奶的价格会有增加，但是用户省却了时间（用户不能跑到内蒙去买牛奶）。
静态代理
静态代理的实现比较简单，代理类通过实现与目标对象相同的接口，并在类中维护一个代理对象。通过构造器塞入目标对象，赋值给代理对象，进而执行代理对象实现的接口方法
public interface Person { void eat(); } public class Child implements Person { @Override public void eat() { System.out.println("A Child eats something"); } } public class StaticProxyDemo { public static void main(String[] args) { Person person = new Child(); person.eat(); } }代理类如下：
public class PersonProxy { private Person person; public PersonProxy(Person person){ this.person = person; } private void beforeExecute(){ System.out.println("before"); } public void execute(){ beforeExecute(); person.eat(); afterExecute(); } private void afterExecute(){ System.out.println("after"); } public static void main(String[] args) { PersonProxy personProxy = new PersonProxy(new Child()); personProxy.execute(); } } 静态代理的优点：
这样可以通过PersonProxy来操作目标对象Person，且在不修改Person对象的条件下能够对目标对象进行beforeExecute()和afterExecute()的拦截操作，这样就达到了解耦合和扩展目标对象的功能。
静态代理的缺点：
因为代理对象，需要实现与目标对象一样的接口，会导致代理类十分繁多，不易维护，同时一旦接口增加方法，则目标对象和代理类都需要维护。
动态代理的实现
JDK的动态代理是基于java.lang.reflect.Proxy实现的InvocationHandler接口
增加Proxy对象，需要实现InvocationHandler，可以看到DynamicPersonProxy类并没有实现Person接口或者继承Person接口的子类,DynamicPersonProxy类是完全与Person松耦合
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class DynamicPersonProxy implements InvocationHandler { private Object target; public DynamicPersonProxy(Object target){ this.target = target; } public <T> T getProxy(){ return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this); } private void beforeInvoke(){ System.out.println("before"); } private void afterInvoke(){ System.out.println("after"); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { beforeInvoke(); Object result = method.invoke(target,args); afterInvoke(); return result; } }测试类如下：
public class DynamicProxyTest{ public static void main(String[] args) { // System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); Person person = new Child(); DynamicPersonProxy dynamicPersonProxy = new DynamicPersonProxy(person); Person proxyPerson = (Person) dynamicPersonProxy.getProxy(); proxyPerson.eat(); } } //输出如下： before A Child eats something after动态代理的优点：
代理对象无需实现接口，接口增加方法也就无需再修改代理对象
动态代理的缺点：
目标对象一定要实现接口，否则无法使用JDK动态代理
动态代理的原理
动态代理的核心流程是：
- 为接口创建代理类的字节码文件
- 使用ClassLoader将字节码文件加载到JVM
- 创建代理类实例对象
- 执行对象的目标方法
JDK Proxy源码分析
下面从源码的角度来看一下动态代理的实现原理
核心方法Proxy.newProxyInstance源码如下：
@CallerSensitive public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { //InvocationHandler不能为空 Objects.requireNonNull(h); //clone接口 final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } //首先从缓存查找是否有代理类，没有就生成一个 Class<?> cl = getProxyClass0(loader, intfs); /* * 通过InvocationHandler调用目标类的构造函数 */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } //constructorParams是指指定代理类的构造函数类型 final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; //如果构造函数不是public修饰，修改 if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { cons.setAccessible(true); return null; } }); } return cons.newInstance(new Object[]{h}); } catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString(), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString(), t); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString(), e); } }其中查找Proxy类的源码如下：
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { //长度检查 if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } //调用了下面的WeakCache<K, P, V>.get(K key, P parameter)方法，loader作为key，interfaces作为parameter参数 //定义如下：proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) return proxyClassCache.get(loader, interfaces); } //首先当前key（也就是上面的ClassLoader）已经加载存在，就直接从缓存中返回 //如果不存在，就会通过ProxyClassFactory来创建代理对象 public V get(K key, P parameter) { Objects.requireNonNull(parameter); expungeStaleEntries(); //根据key的hash值和一个ReferenceQueue来构造 Object cacheKey = CacheKey.valueOf(key, refQueue); // 从map中取出cacheKey的值 ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey); if (valuesMap == null) { ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>()); if (oldValuesMap != null) { valuesMap = oldValuesMap; } } Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); Supplier<V> supplier = valuesMap.get(subKey); Factory factory = null; while (true) { if (supplier != null) { // supplier可能是Factory或者CacheValue<V> V value = supplier.get(); if (value != null) { return value; } } // 缓存中没有supplier，同时supplier中没有 // 懒加载的方式创建一个Factory if (factory == null) { factory = new Factory(key, parameter, subKey, valuesMap); } if (supplier == null) { supplier = valuesMap.putIfAbsent(subKey, factory); if (supplier == null) { // 安装 Factory supplier = factory; } } else { if (valuesMap.replace(subKey, supplier, factory)) { supplier = factory; } else { supplier = valuesMap.get(subKey); } } } } 再看一下上面提到的ProxyClassFactory是一个 工厂方法，是一个静态final类，实现了BiFunction接口，其中只有一个apply方法
//类定义 private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>>{ @Override public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) { Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class<?> intf : interfaces) { /* * 校验当前类加载器ClassLoader解析到的名称和定义的名称是否相同 */ 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"); } /* * 校验是否是接口类型，这也就是为什么JDK动态代理只能基于接口 */ 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; ..... /* * 生成指定Proxy代理对象的字节码 */ byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); try { //调用的native方法 return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { /* * 生成的代理类有bug */ throw new IllegalArgumentException(e.toString()); } } } Proxy代理字节码生成分析
去掉DynamicProxyTest类中的注释
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");这样就可以看到JDK生成的class文件。所生成的$Proxy0特性如下：
- 继承了Proxy，实现了目标接口Person。因为Java不允许多重继承，这就限制了：使用JDK代理不能是普通类或者抽象类，只能是接口类型
- 只有一个InvocationHandler参数的构造函数，所以代理类必须继承InvocationHandler接口
- 生成了同名的eat()方法，且调用了InvocationHandler的invoke方法
- 使用静态代码块初始化Object类的equals，toString和hashCode方法，还有Person接口的eat方法
如上示例反编译所生成的class文件内容如下：
package com.sun.proxy; import com.randy.dynamicproxy.jdk.interfaces.Person; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class $Proxy0 extends Proxy implements Person { private static Method m1; private static Method m3; private static Method m2; private static Method m0; public $Proxy0(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void eat() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m3 = Class.forName("com.randy.dynamicproxy.jdk.interfaces.Person").getMethod("eat"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
