平常面试的时候,有人回问你Spring,你会说什么AOP什么的,然后他会越来越往深问,其实说到AOP那么动态代理是绕不开的,那么今天我们一起来看看这个动态代理是什么个一回事先贴一张图:
上面便是动态代理的结束以及它的实现方式,以及区别(我确实很懒....)but 上面的也挺通俗易懂,只要你不是初学者
-----------------------------------------华丽的分割线--------------------------------------------------------
接下来当然要继续贴图啦:
这张图便是动态代理大概的实现流程,我们看到.只有javaProxy是直接修改字节码的,其他的都是基于ASM来操作字节码ASM我也不太懂,然后那个javassist也是用来操作ASM的,是岛国一位工程师写的,据说dubbo就是用的这项技术.
我们看到无论是何种方式它都是基于对class字节码的修改来进行代理的.
好的这只是一个大概的了解那么我们来写代码感受感受:
整体需求就是一个普通的Service接口,
让后一个普通的实现类,ServiceImpl
最后我们来个测试的小方法:来看看动态代理的实现:
public class ProjexTest { public static void main(String[] args) { final serviceImpl impl =new serviceImpl(); UserServce servce = (UserServce)Proxy.newProxyInstance(ProjexTest.class.getClassLoader(), new Class[]{UserServce.class}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理执行前"); try { return method.invoke(impl, args); } finally { System.out.println("代理执行后"); } } }); servce.get(); }
我们还是很奇怪上面到底是什么东东?用我表达不好语言解释一下:
首先,我们new 了一个newProxyInstance()然后我们在InvocationHandler()里面的invoke方法来实现它的动态代理.
还是贴图方便一点这样我们便实现了一个简单的代理类
这里的我们get()方法就相当于客户端,掉的是userservice接口的方法,委托类就是serviceimpl 代理类就是我们传的userservice.class,这样通过接口屏蔽的底层的实现细节,这样透明化喽.
对啊是如何做到代理目标对象的呢?这个好说我们通过代理类来分析一下:
@Test public void buildProcyClass() throws IOException { byte[] bytes = ProxyGenerator.generateProxyClass("UserService$proxy", new Class[]{ UserServce.class }); String filename = String.format("%s/target/UserService$proxy.class", System.getProperty("user.dir")); File file = new File(filename); FileOutputStream outputStream = new FileOutputStream(file); outputStream.write(bytes); outputStream.flush(); outputStream.close(); }
这样我就把它代理的类输出出来了:
public final class UserService$proxy extends Proxy implements UserServce { private static Method m1; private static Method m2; private static Method m3; private static Method m0; public UserService$proxy(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } 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 String get() throws { try { return (String)super.h.invoke(this, m3, (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)).intValue(); } 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")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m3 = Class.forName("com.yqun.springboot.service.UserServce").getMethod("get"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } }
这个就是输出来的类,我们可以看到代理过来的类:
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); 里面的参数就对应着:
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 上问中这个invoke里面要的参数,
其实这样我们可以清楚的看到,代理类回事怎么一回事
我们看看他是怎么生成的:追 类 可以通过了吗看到它就是生成一个动态代理对对象
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
/*获取查询遍历已经构建好的class类也就是我们接口的代理类 * Look up or generate the designated proxy class. */ Class<?> cl = getProxyClass0(loader, intfs);
// If the proxy class defined by the given loader implementing //点进去首先会通过从load缓存里面取 // the given interfaces exists, this will simply return the cached copy;//如果有对它从字节码进行构建 // otherwise, it will create the proxy class via the ProxyClassFactory//没有的话去创建一个新的 return proxyClassCache.get(loader, interfaces);
我们看到如果它没有的话回去ProxyClassFactory类里面去实现那么我们就看看里面的方法,
-->ProxyClassFactory.apply 就是装配自动代理的过程 动态代理所用的接口
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
//存储所有动态代理所对应的接口
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*验证接口 也就是说ClassLoader 对应的接口是否已经存在是否是同一个
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
也就是说对代理的类是不service的实现类
当然里面还有许多乱七八糟的方法,但是我只看懂了这个.这里他会对字节码重组也就是修改class文件,相当于吧代码编译成字节码
在往深就是类加载器的方法了,这个便是对字节码的重新装载 也就是ClassLoad里面的
@Deprecated protected final Class<?> defineClass(byte[] b, int off, int len) throws ClassFormatError { return defineClass(null, b, off, len, null); }
的方法
总结两张图结尾:
最后一张图特别重要,也就是写了这么长时间的总计吧算是...