标签：row 事前 ror chm sub .class sim 动态代理 运行
昨天面试碰到了面试官问spring的时候，问完ioc，然后下个问题我以为是aop，后来才听清是动态代理，感觉回答的不是太好，也是好久不接触
1.静态代理
代理模式也就委托模式。
三个角色：
1. Subject抽象主题角色：接口
2. RealSubject具体主题角色：接口的实现类，业务逻辑的具体执行者
3. Proxy代理主题角色：也叫做委托类，代理类。它负责对真实角色的应用，负责真实角色前后前后做预处理和善后处理。
在这里面Subject是一个借口，里面有一个Request（）方法，RealSubject类实现了Subject这个接口，并且实现了request（）方法，而在Proxy也实现了Subject接口，proxy里面还有一个变量Subject，可以通过构造函数将RealSubject注入，在实现request方法时，其实是调用的是Realsubject里面的request方法，在调用request（）方法前后可以调用一些其他的方法。
下面是具体的代码
Subject.java
public interface Subject { //定义一个方法 public void request(); }
RealSubject.java
public class RealSubject implements Subject { @Override public void request() { //业务逻辑处理 } }
Proxy.java
public class Proxy implements Subject { private Subject subject = null; public Proxy(Subject subject){ this.subject = subject; } @Override public void request() { before(); subject.request(); after(); } public void before(){ //do something } public void after(){ //do something } }
代理模式的使用场景
为什么要使用代理呢？想想现实世界吧，打官司为什么要找个律师？因为你不想参与中间过程的是是非非，只要完成自己的答辩就行了，其他的比如事前调查、事后调查都由律师搞定，这就是为了减轻你的负担。代理模式的使用场景非常多，可以看见Spring aop，这是非常典型的动态代理
二：动态代理
动态代理是在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。相对来说，自己写代理类的方式就叫静态代理
划重点，在运行阶段指定哪一个对象
具体代码，逻辑待会再说
抽象主题
public interface Subject { /** * //业务操作 * @param str */ void doSomething(String str); /** * 吃 * */ void eat(String str); }
真实主题
public class RealSubject implements Subject { @Override public void doSomething(String str) { System.out.println("do something!---->" + str); } @Override public void eat(String str) { System.out.println("今天晚上吃"+str); } }
动态代理的handler类
public class MyInvocationHandler implements InvocationHandler { /** * 被代理的对象 */ private Object target; public MyInvocationHandler(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //log Before System.out.println("log before:"+"method: "+method.getName()+ "return :"+method.getReturnType().getSimpleName()); Object result = method.invoke(target,args); System.out.println("log after: "+new Date(System.currentTimeMillis())); return result; } }
动态代理类
public class DynamicProxy<T> { public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler){ //返回目标，并返回结果 return (T) Proxy.newProxyInstance(loader,interfaces,handler); } }
动态代理的场景类
public class Client { public static void main(String[] args) throws IOException { //定义一个代理类 Subject subject = new RealSubject(); //定义一个Handler InvocationHandler handler = new MyInvocationHandler(subject); //定义主题的代理 Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),handler); //代理的行为 System.out.println(proxy.getClass().getCanonicalName()); proxy.doSomething("finish"); proxy.eat("香锅里辣家的麻辣香锅"); //此处可以将 byte[] proxyClass = ProxyGenerator.generateProxyClass(proxy.getClass() .getSimpleName(), proxy.getClass().getInterfaces()); //将字节码文件保存到D盘，文件名为$Proxy0.class FileOutputStream outputStream = new FileOutputStream(new File( "d:\\$Proxy0.class")); outputStream.write(proxyClass); outputStream.flush(); outputStream.close(); } }
分析过程：
Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),handler);
在我们使用proxy.doSomthing(args);
proxy.eat(args);*
***我们可以想象出，DynamicProxy.newProxyInstance（args）这个方法返回了一个proxy对象***
我们可以看到是调用了这个方法
newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
@CallerSensitive public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h); final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } /* * Look up or generate the designated proxy class. */ Class<?> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } 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; } }); } 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); } }最后这个方法会在运行中生成一个
类，名字叫：com.sun.proxy.$Proxy0
而我们并没有找到这个类，可以通过
ProxyGenerator.generateProxyClass
将这个运行中生成的类打印出来，，我们来看看，这个类是什么样子的
$Proxy0.class,反编译
public final class $Proxy0 extends Proxy implements Subject { private static Method m1; private static Method m2; private static Method m3; private static Method m4; 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 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 void doSomething(String var1) throws { try { super.h.invoke(this, m3, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void eat(String var1) throws { try { super.h.invoke(this, m4, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } 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")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m3 = Class.forName("com.husky.dynamicproxy.Subject").getMethod("doSomething", Class.forName("java.lang.String")); m4 = Class.forName("com.husky.dynamicproxy.Subject").getMethod("eat", Class.forName("java.lang.String")); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
首先$Proxy0这个类extends Proxy implements Subject
有一个静态代码块，会反射生成Method类，也就是给 $Proxy这个类的变量赋值
举例我在调用proxy.doSomething()这个方法时
我们其实是调用
public final void doSomething(String var1) throws { try { super.h.invoke(this, m3, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } }
调用的是super.h.invoke(this, m3, new Object[]{var1});
这个h也就是实现InvocationHandler接口的MyInvocationHandler类。将这个$Proxy0，m3， new Object[]{var1}这些变量传过去
具体代码：https://github.com/pompeii666/proxy
标签：row 事前 ror chm sub .class sim 动态代理 运行
原文地址：https://www.cnblogs.com/huskyui/p/10165003.html
