浅谈动态代理
什么是动态代理？
以下为个人理解:
动态代理就是在程序运行的期间，动态地针对对象的方法进行增强操作。并且这个动作的执行者已经不是"this"对象了，而是我们创建的代理对象，这个代理对象就是类似中间人的角色，帮助我们为目标方法嵌入一些其他的逻辑进去。
jdk动态代理的原理
jdk自带的动态代理的工作原理是利用反射的newInstance，创建一个代理对象(proxy)，获取到目标接口的方法，然后我们就可以在Invoke之前或之后做操作。它抽取出了一个invokeHandler，里面就有目标method。
试想一下，当我们拥有了class对象，增强逻辑(invokeHandler)，也就是增强的目标方法之后，我们自己利用反射（不利用Proxy）也可以很容易写出我们自己的动态代理。但是问题就在于，我们只有明确了目标类之后，通过自己编写Proxy类，实现目标接口，往里面塞invoktionHandler, 最后New出来这个实实在在的对象。而jdk提供的动态代理，却可以在并不知情的情况下，帮我们做这一系列的动作。
jdk生成代理类时，并没有经历源码阶段，编译阶段，而是直接到字节码阶段，它生成的代理类是看不到的，因为它直接就是字节码文件了。 它帮我们继承了Proxy类，并且还动态的帮助我们继承了目标接口。也就是说，它帮我们写代码了。里面用到的技术，是ASM技术，它可以直接生成我们想要的字节码。
jdk方法反射调用优化:
invoke() 利用反射进行本地调用，效率低下，它在调用了一定的次数(16)之后会生成实例化对象，变成正常调用。
InvocationHandler接口
publicinterfaceInvocationHandler {
publicObjectinvoke(Objectproxy, Methodmethod, Object[] args)throwsThrowable;
}
源码
@CallerSensitive
publicstaticObjectnewProxyInstance(ClassLoaderloader,
Class<?>[] interfaces,
InvocationHandlerh)
throwsIllegalArgumentException
{
Objects.requireNonNull(h);
finalClass<?>[] intfs=interfaces.clone();
finalSecurityManagersm=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);
}
finalConstructor<?>cons=cl.getConstructor(constructorParams);
finalInvocationHandlerih=h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(newPrivilegedAction<Void>() {
publicVoidrun() {
cons.setAccessible(true);
returnnull;
}
});
}
returncons.newInstance(newObject[]{h});
} catch (IllegalAccessException|InstantiationExceptione) {
thrownewInternalError(e.toString(), e);
} catch (InvocationTargetExceptione) {
Throwablet=e.getCause();
if (tinstanceofRuntimeException) {
throw (RuntimeException) t;
} else {
thrownewInternalError(t.toString(), t);
}
} catch (NoSuchMethodExceptione) {
thrownewInternalError(e.toString(), e);
}
}
cglib动态代理的原理
cglib动态代理的原理跟jdk的类似，只不过它是基于父类继承，也就是不需要实现接口就可以做增强。它的内部并不是InvoktionHandler,而是方法拦截器 MethodInterceptor 。
前面的jdk动态代理，它是利用ASM技术帮我们动态编写了一个proxy对象，其中继承了Proxy父类，实现了目标接口，而cglib则是利用ASM直接帮助我们继承了目标类，不需要接口。
并且有所区别的是，它不仅仅通过反射拿到method,还拿到了MethodProxy。
MethodInterceptor接口 继承了Callback接口，它的拦截方法里面有一个特殊的参数 MethodProxy,这玩意可以不通过反射调用方法，通过invokeSuper() 方法可以直接正常调用。
MethodProxy是怎么做到正常调用的？
其实就是我们前面提到的，继承了Proxy父类之后，就得到了父类的原始方法，当我调用invokeSuper的时候，直接调用的就是父类的原始方法。
MethodInterceptor
publicinterfaceMethodInterceptorextendsCallback {
Objectintercept(Objectvar1, Methodvar2, Object[] var3, MethodProxyvar4) throwsThrowable;
}
MethodProxy
invoke() 无反射调用
invokeSuper() 无反射调用
publicObjectinvoke(Objectobj, Object[] args) throwsThrowable {
try {
this.init();
MethodProxy.FastClassInfofci=this.fastClassInfo;
returnfci.f1.invoke(fci.i1, obj, args);
} catch (InvocationTargetExceptionvar4) {
throwvar4.getTargetException();
} catch (IllegalArgumentExceptionvar5) {
if (this.fastClassInfo.i1<0) {
thrownewIllegalArgumentException("Protected method: "+this.sig1);
} else {
throwvar5;
}
}
}
publicObjectinvokeSuper(Objectobj, Object[] args) throwsThrowable {
try {
this.init();
MethodProxy.FastClassInfofci=this.fastClassInfo;
returnfci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetExceptionvar4) {
throwvar4.getTargetException();
}
}