浅谈动态代理

什么是动态代理？

---

以下为个人理解:

• 动态代理就是在程序运行的期间，动态地针对对象的方法进行增强操作。并且这个动作的执行者已经不是"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();

}

}