Retrofit网络请求框架之注解解析和动态代理

interface GitHubService {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String): Call<List<Repo>>
}

public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
        eagerlyValidateMethods(service);
    }
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
            new InvocationHandler() {
                private final PlatfORM platform = Platform.get();
                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable {
                    if (method.getDeclarinGClass() == Object.class) {
                        return method.invoke(this, args);
                    }
                    if (platform.isDefaultMethod(method)) {
                        return platform.invokeDefaultMethod(method, service, proxy, args);
                    }
                    ServiceMethod<Object, Object> serviceMethod =
                            (ServiceMethod<Object, Object>) loadServiceMethod(method);
                    OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
                    return serviceMethod.callAdapter.adapt(okHttpCall);
                }
            });
}

public ServiceMethod build() {
    callAdapter = createCallAdapter();
    responseType = callAdapter.responseType();
    if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
                + Utils.getRawType(responseType).getName()
                + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    responseConverter = createResponseConverter();
    RequestFactory requestFactory = createRequestFactory();
    return new ServiceMethod<>(requestFactory, callAdapter, responseConverter);
}

import java.lang.reflect.*
interface HelloWorld {
    fun sayHello()
}
class HelloWorldImpl : HelloWorld {
    override fun sayHello() {
        println("Hello, world!")
    }
}
fun main() {
    val proxy = Proxy.newProxyInstance(
        DynamicProxyExample::class.java.classLoader,
        arrayOf(HelloWorld::class.java),
        object : InvocationHandler {
            private val target: HelloWorld = HelloWorldImpl()
            override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any? {
                println("Before method execution...")
                val result = method?.invoke(target, *(args ?: emptyArray()))
                println("After method execution...")
                return result
            }
        }
    ) as HelloWorld
    proxy.sayHello()
}