动态代理机制InvocationHandler（kotlin）

动态代理是JVM在运行期创建class字节码并加载的过程
动态代理机制（Dynamic Proxy）：可以在运行期动态创建某个interface的实例

创建A接口，但不创建实现类，直接通过JDK提供的Proxy。newProxyInstance()创建一个A接口对象。这种没有实现类但是在运行期动态创建了一个接口对象的方式称作动态代理。

代码实现：

//定义接口
interface StudentInterface {

    fun name(name : String)

    fun age(age : Int)

}

//实现
private fun proxyTest() {
        //通过InvocationHandler 接口中的 invoke 方法进行业务的调用和增强等处理，InvocationHandler是一个拦截器类
        val handler = InvocationHandler { proxy, method, args ->
            if (method.name == "name") {
                Log.i(TAG, "invoke: " + args[0])
            }
            null
        }
  
        //通过Proxy.nexProxyInstance()创建对应的实例对象
        val student: StudentInterface = Proxy.newProxyInstance(
            StudentInterface::class.java.classLoader,
            arrayOf(StudentInterface::class.java),
            handler
        ) as StudentInterface
        student.name("chou")
    }

代码封装后：

class StudentProxy(private val objStudent: Any) : InvocationHandler {

    fun getProxyInstance(): Any = Proxy.newProxyInstance(
        objStudent::class.java.classLoader,
        objStudent::class.java.interfaces,
        this
    )

    override fun invoke(proxy: Any?, method: Method?, args: Array<Any?>): Any?{
        if (method?.name == "name") {
            //拦截处理增强业务
            Log.i(MainActivity.TAG, "StudentProxy invoke: " + (args[0] ?: "null"))

        }
        //调用自身
        return method?.invoke(objStudent, *args)
    }
}


        //调用
        val university = UniversityStudent()
        val studentProxy = StudentProxy(university)
        val universityStudent : StudentInterface = studentProxy.getProxyInstance() as StudentInterface
        universityStudent.name("bigeye")

静态代理与动态代理区别：静态代理 创建代理类，实现对应的接口并通过构造传入需要被代理的实例，实现接口里的方法，处理需要增强的业务并在相应方法中调用被代理类的方法。