Java动态代理
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>本文仅限于jdk代理，或者说是基于接口的动态代理>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Java的动态代理与两个重要的类，或者说方法有关。
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h);
InvocationHandler.invoke(Object proxy, Method method, Object[] args);
举个例子，我们有一个接口Singer，有几个方法，如songList()，name()，style()等。
public interface Singer { void songList(); void name(); void style(); }
这个会有很多的实现类，如JayChou啊，JackyCheung啊等等。
像这种，存在实现类的接口，动态代理比较简单。就是创建一个InvocationHandler的实现类，让他存在一个Object属性，并且存在一个构造函数，设定这个object为具体的实现类即可。
public class SingerProxy implements InvocationHandler { private Object target; public SingerProxy(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before... something todo..."); Object invoke = method.invoke(target, args); System.out.println("After... something todo..."); return invoke; } }
测试方法：
public class Main { public static void main(String[] args) { Singer singer = new JackeyCheung(); Singer proxy = (Singer) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), singer.getClass().getInterfaces(), new SingerProxy(singer)); proxy.name(); proxy.style(); proxy.songList(); } }
InvocationHandler是一个接口，他的实现类（SingerProxy）是具体的对象的代理实现者。
他只有一个方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
proxy：在其上调用方法的代理实例
method：被代理的方法
args：被代理的方法的参数们
第二和第三个参数比较容易理解，一般调用method.invoke(target, args)就可以了。但是这个proxy参数比较费解。
实际上，他是一个类似于$Proxy0这种类的一个实例。
如果在Main中的main方法中追加一段如下的代码
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
会在项目目录下生成一个字节码文件如下所示：
public final class $Proxy0 extends Proxy implements Singer { private static Method m1; private static Method m5; private static Method m2; private static Method m3; private static Method m0; private static Method m4; 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 name() throws { try { super.h.invoke(this, m5, (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 void style() throws { try { 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); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void songList() throws { try { super.h.invoke(this, m4, (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")); m5 = Class.forName("dynamic.singer.Singer").getMethod("name"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m3 = Class.forName("dynamic.singer.Singer").getMethod("style"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); m4 = Class.forName("dynamic.singer.Singer").getMethod("songList"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
这个$Proxy0就是这个类的名称，这里也能看出jdk动态代理只能代理接口，因为这个类已经有一个Proxy父类，并且java不支持多继承。
这个类中的super.h就是我们自己定义个InvocationHandler的实现类。也就是去调用我们实现的invoke方法。
这里注意几个点，$Proxy0这个类把Object的toString, equals, hashcode三个方法也给代理了，toString这个方法我们最好让InvocationHandler的实现类单独实现一下，不然可能会出现堆栈溢出。
我们知道invoke方法的第一个参数是$Proxy0的一个实例了。有的时候，我们会在invoke中使用this，这个this指代的肯定是InvocationHandler的实现对象了。
那么proxy参数到底有什么用呢？
当方法没有返回值的时候，确实没有什么用途，invoke方法返回null都可以。如果存在返回值，且进行连续调用时。一个方法的调用返回自身，StringBuilder的append这种，但是StringBuilder不是一个接口所以不适用，我们可以自己制造一个SBuilder。
public interface SBuilder { SBuilder append(String s); }
这种时候，可以将proxy直接返回，方便下一次调用。实际上，不连续调用就可以了。
还有另外一种情况，就是只存在接口，没有实现类时，也可以实现动态代理。比较知名的应该就是mybatis了，只存在一个Mapper接口，还有一个对应的mapper.xml文件。
他的内部原理也是动态代理。
他是能够通过分析mapper文件，获取到mapper的方法，参数，返回值的，如果和Mapper接口中的匹配的话，就可以去调用method.invoke();
具体可以查看mybatis的MapperProxy类的invoke方法。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { if (Object.class.equals(method.getDeclaringClass())) {// Object的方法的话，toString, equals, hashcode直接调用mapperProxy的 return method.invoke(this, args); } if (this.isDefaultMethod(method)) {// 如果存在具体的实现，走default方法 return this.invokeDefaultMethod(proxy, method, args); } } catch (Throwable var5) { throw ExceptionUtil.unwrapThrowable(var5); } MapperMethod mapperMethod = this.cachedMapperMethod(method); return mapperMethod.execute(this.sqlSession, args); }
最后这块就是将每一个method都缓存一下，供后期调用。
mapperMethod的execute就是具体的实现了。内容不重要，不是动态代理的范畴，实现方式很巧妙。
public Object execute(SqlSession sqlSession, Object[] args) { Object result; switch (command.getType()) { case INSERT: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.insert(command.getName(), param)); break; } case UPDATE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.update(command.getName(), param)); break; } case DELETE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.delete(command.getName(), param)); break; } case SELECT: if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args); result = null; } else if (method.returnsMany()) { result = executeForMany(sqlSession, args); } else if (method.returnsMap()) { result = executeForMap(sqlSession, args); } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } else { Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param); } break; case FLUSH: result = sqlSession.flushStatements(); break; default: throw new BindingException("Unknown execution method for: " + command.getName()); } if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")."); } return result; }
动态代理是一个很重要的比较复杂的java内容，架构设计跟面试时，使用频率比较高。
