关于静态代理与动态代理，一直是比较困扰很多新人开发，但实际我们开发中，小到写的某个工具类，大到经常使用的Retrofit 其内部都使用了动态代理，所以这篇文章从基础到源码解析，以便于你更简单的理解 静态代理与 Jdk中的动态代理。
静态代理: 由我们开发者自己手动创建或者在程序运行前就已经存在的代理类，静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
动态代理: 在程序运行时，运用java反射机制动态创建而成，静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道，通常动态代理实现方式是通过实现 jdk 的 InvocationHandler 接口的 invoke 方法
代码实践
需要代理的接口
interface IBook { fun toBookName(name: String) }
静态代理
class BookImpl : IBook { override fun toBookName(name: String) { println("书名|$name") } } // TODO: 2020/11/25 静态代理最大的特点就是，对于具体的代理提前声明 class BookProxy( private val iBook: IBook, private var objStart: () -> Unit = { println("开始前的操作") }, private var objStop: () -> Unit = { println("结束时的操作") } ) : IBook { override fun toBookName(name: String) { //我们可以在具体的实现前做一些处理操作 objStart.invoke() iBook.toBookName(name) //具体的处理后做一些操作 objStop.invoke() } } fun main() { val bookProxy = BookProxy(BookImpl()) bookProxy.toBookName("Android&Petterp") }
静态代理相对简单，也有局限性，对于代理类我们需要提前声明，而且每一个代理都需要提前创建好。
动态代理
class BookImpl : IBook { override fun toBookName(name: String) { println("测试输出文本$name") } } /** 用于帮助代理的类 * BookImplHandler看起来很像一个比较奇怪的代理，实际上其只是用于帮助代理的类，我们最终生产的代理类会把调用发给它让其处理。 * 代理类本身是通过 Proxy.newProxyInstance() 方法在运行时动态创建 * */ class BookImplHandler( private val book: IBook, private var objStart: () -> Unit = { println("开始前的操作") }, private var objStop: () -> Unit = { println("结束时的操作") } ) : InvocationHandler { // TODO: 2020/11/25 // (1)在invoke方法中接收可变长参数，在Kotlin语法中，数组是array，可变长参数类型是vararg，类型不匹配。 // (2)Kotlin中数组转为可变长参数，通过前面加*符号。 // (3)如果方法没有任何参数,args将为null,并将其传播到Kotlin将导致NullPointerException. // 作为一种解决方法,使用*(args？：arrayOfNulls< Any>(0)),并在所描述的极端情况下选择正确的部分并将其扩展为零参数. override fun invoke(proxy: Any, method: Method?, args: Array<out Any>?): Any? { objStart.invoke() val invoke = method?.invoke(book, *(args ?: emptyArray())) objStop.invoke() return invoke } } fun main() { val bookImplHandler = BookImplHandler(BookImplDynamic()) val iBook = Proxy.newProxyInstance( BookImpl::class.java.classLoader, BookImpl::class.java.interfaces, bookImplHandler ) as IBook iBook.toBookName("测试的文本") }
常见的动态代理场景
Retrofit中的动态代理
使用Retrofit时，当我们使用 Retrofit.Builder().create() 时，传入了我们的接口类，其 create 方法内部就使用了动态代理，从而生成了相应的代理类。
public <T> T create(final Class<T> service) { //判断是否为接口 validateServiceInterface(service); return (T) //代理实现 Proxy.newProxyInstance( service.getClassLoader(), new Class<?>[] {service}, new InvocationHandler() { ... @Override public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable { //如果是object方法，则直接触发 if (method.getDeclaringClass() == Object.class) { return method.invoke(this, args); } ... } }); }
使用动态代理实现 onClick注入
如下所示，我们声明一个注解,其应用于方法，并加入了一个Activity的扩展函数，用于对Activity重所有使用了该注解的方法进行onclick注入， 其方法内部使用反射+动态代理,从而实现。
@Retention(AnnotationRetention.RUNTIME) @Target(AnnotationTarget.FUNCTION) annotation class InjectClick(@IdRes val ids: IntArray) fun Activity.injectClicks() { javaClass.methods.asSequence().filter { it.isAnnotationPresent(InjectClick::class.java) }.forEach { it.isAccessible = true it.getAnnotation(InjectClick::class.java).ids.forEach { id -> findViewById<View>(id).apply { val clickProxy = Proxy.newProxyInstance( javaClass.classLoader, arrayOf(View.OnClickListener::class.java) ) { _, _, _ -> it.invoke(this@injectClicks) } as View.OnClickListener setOnClickListener(clickProxy) } } } }
源码探索 Jdk 中的动态代理
动态代理的源码实现相对简单，我们先进入 Proxy.newProxyInstance 方法,一探究竟。
Proxy.newProxyInstance
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h); //先克隆一个传递过来的代理对象 final Class<?>[] intfs = interfaces.clone(); //拿到生成的代理类,内部维护了一个map Class<?> cl = getProxyClass0(loader, intfs); //获取代理类构造函数 final Constructor<?> cons = cl.getConstructor(constructorParams); //授予权限 if (!Modifier.isPublic(cl.getModifiers())) { cons.setAccessible(true); } //反射创建代理类，并传入用户自己实现的中间层接口 return cons.newInstance(new Object[]{h}); }
具体如上述描述，然后我们自己生成一个代理类，来看看内部的调用：
生成代理类
fun writeFileProxy() { //IApple是我要代理的接口 val name = IApple::class.java.name + "Proxy()" val bytes = ProxyGenerator.generateProxyClass(name, arrayOf(IApple::class.java)) val fos = FileOutputStream("$name.class") fos.write(bytes) fos.close() }
示例代码
public final class IAppleProxy() extends Proxy implements IApple { private static Method m3; public IAppleProxy__/* $FF was: IAppleProxy()*/(InvocationHandler var1) throws { super(var1); } public final void count() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { m3 = Class.forName("com.android.readbook.proxy.IApple").getMethod("count") } }
生成的代理类如上所示，其实现了我们的接口，并且代理了相应的所有方法，这里做了一部分删减。
观察代理类具体方法的话，其具体实现里，通过InvocationHandler对象，也就是我们自己实现的辅助了，并调用其invoke方法, 以接口回调的方式回调到我们具体的实现处。整个过程比较容易理解，也并没有什么太高深的难度。
总结
关于jdk中的动态代理，当我们调用 Proxy.newProxyInstance 时，传入了一个当前类的classLoader以及要代理的接口数组及实现了InvocationHandler 接口 的辅助类对象，其会在运行时在内存中生成一个代理类，这个代理类实现了我们的接口并接收 一个我们外部传入的 InvocationHandler 辅助类对象，并在具体的方法实现位置通过调用辅助类的 invoke 方法，从而实现我们的接口方法代理。
