亲宝软件园·资讯

展开

Spring事务Transactional和动态代理(一)-JDK代理实现

骑着龙的羊 人气:0
系列文章索引: 1. [Spring事务Transactional和动态代理(一)-JDK代理实现](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy) 2. [Spring事务Transactional和动态代理(二)-cglib动态代理](Spring事务Transactional和动态代理(一)-JDK代理实现) 3. [Spring事务Transactional和动态代理(三)-事务失效的场景](http://www.itrensheng.com/archives/spring_transactional_uneffect) ### 什么是代理 理设计模式提供了对目标对象的间接访问方式,能力模式能够解耦合并且便于扩展目标的功能。 在现实生活这,我们消费者如果要去购买一杯牛奶的时候,并不是直接去找牛奶厂商购买,而是在便利店或者超市购买(零售商);超市进货的时候也通常不是直接找牛奶厂商,而是找市级代理(渠道经销商),市级代理再找省级代理(代理商),省级代理从牛奶生产商(厂商)提货。 如下图,虽然通过层层代理,一杯牛奶的价格会有增加,但是用户省却了时间(用户不能跑到内蒙去买牛奶)。 ![](https://img2020.cnblogs.com/blog/314515/202003/314515-20200304191610659-935864743.png) ### 静态代理 静态代理的实现比较简单,代理类通过实现与目标对象相同的接口,并在类中维护一个代理对象。通过构造器塞入目标对象,赋值给代理对象,进而执行代理对象实现的接口方法 ```java 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(); } } ``` 代理类如下: ```java 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松耦合 ```java 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 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; } } ``` 测试类如下: ```java 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动态代理** ### 动态代理的原理 动态代理的核心流程是: 1. 为接口创建代理类的字节码文件 2. 使用ClassLoader将字节码文件加载到JVM 3. 创建代理类实例对象 4. 执行对象的目标方法 #### JDK Proxy源码分析 下面从源码的角度来看一下动态代理的实现原理 核心方法Proxy.newProxyInstance源码如下: ```java @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() { 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类的源码如下: ```java private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { //长度检查 if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } //调用了下面的WeakCache.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> valuesMap = map.get(cacheKey); if (valuesMap == null) { ConcurrentMap> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>()); if (oldValuesMap != null) { valuesMap = oldValuesMap; } } Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); Supplier supplier = valuesMap.get(subKey); Factory factory = null; while (true) { if (supplier != null) { // supplier可能是Factory或者CacheValue 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方法 ```java //类定义 private static final class ProxyClassFactory implements BiFunction[], Class<?>>{ @Override public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) { Map, 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类中的注释 ```java System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); ``` 这样就可以看到JDK生成的class文件。所生成的$Proxy0特性如下: 1. 继承了Proxy,实现了目标接口Person。因为Java不允许多重继承,这就限制了:使用JDK代理不能是普通类或者抽象类,只能是接口类型 2. 只有一个InvocationHandler参数的构造函数,所以代理类必须继承InvocationHandler接口 3. 生成了同名的eat()方法,且调用了InvocationHandler的invoke方法 4. 使用静态代码块初始化Object类的equals,toString和hashCode方法,还有Person接口的eat方法 如上示例反编译所生成的class文件内容如下: ```java 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()); } } } ```

加载全部内容

相关教程
猜你喜欢
用户评论