静态代理和动态代理

abstract class baseClass {
    abstract fun write()
}

class StaticClass: baseClass() {
    override fun write() {
        println("StaticClass")
    }
}

class RealClass: baseClass() {

    var baseClass: baseClass? = null

    override fun write() {
        baseClass?.write()
    }
}

fun main() {
    val staticClass = StaticClass()

    val realClass = RealClass()
    realClass.baseClass = staticClass

    realClass.write()
}

静态代理就是在编译前就已经定义好委托对象，让另一个类来实现目的方法。
这种方式和kotlin的委托相似。

interface Subject {
    fun write()
}

class DynamicClass: Subject {
    override fun write() {
        println("DynamicClass")
    }
}

class DynamicProxy(val any: Any): InvocationHandler {

    override fun invoke(proxy: Any?, method: Method?, args: Array?): Any? {
        return method?.invoke(any, *(args ?: arrayOfNulls(0)))
    }
}

fun main() {

    val realClass = DynamicClass()

    val proxy = DynamicProxy(realClass)

    val classLoader = realClass.javaClass.classLoader

    val obj: Subject = Proxy.newProxyInstance(classLoader, arrayOf(Subject::class.java), proxy) as Subject

    obj.write()
}

动态代理需要先定义一个接口类，通过反射机制动态的生成代理对象，重写InvocationHandler里面的invoke方法来实现。

调用invoke方法的时候java和kotlin是不同的，主要是因为可变参数的不同。
需要把arg 转为 *(arg)

retorfit 就是通过这种动态代理方式解析注解和接口方法 来构建okhttp请求的。

Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                  throws Throwable {
                // If the method is a method from Object then defer to normal invocation.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }