最近接了个大项目，哈哈哈~ 文章终于出来啦~ 还好没胎死腹中。最近的感悟就是，做好小事，才有机会做大事，承担大项目！
最近在学 Kotlin 基础，发现动态代理这块之前还是没搞明白，所以就学了下 Kotlin 中的代理模式写法，发现东西有点多，遂独自成文，欢迎大家拍砖！

引子

动态代理主要是用来干什么的？通俗一点，就是你在调用其他类的一些方法时，想加入你自己的一些处理逻辑。比如说，统计这些方法的执行时长等，这也是面向切面编程的思想。

代理模式

动态代理，源自于设计模式中常见的一种模式：代理模式。在 Java 中就是为一个对象 A 的一个方法 B 提供一个代理对象，这个代理对象可以完全控制 A 对象的 B 方法实际的执行内容。四个关键词：1）代理对象；2）被代理对象；3）被代理行为；4）对行为的完全控制。

这样说还是太抽象，举个实际的例子。假如我们需要通过房屋中介租房，就是一个简单的代理模式。这里面有三种角色：1）房东——被代理对象；2）房屋中介——代理对象；3）租客——使用方或调用者。房东把全部的租房事项全部交给中介打理，那么中介就具有对租房行为的完全控制，租客只能跟中介打交道。

看看上面的四个关键词，中介对应 代理对象；房东对应 被代理对象；租房相关事项对应 被代理行为，比如找租客、约看房时间、看房、签约等；中介可以完全控制对租房事项的行为对应 对行为的完全控制，比如中介可以加价，提供保洁服务等。

代理模式的基本要素

代理对象与被代理对象需要实现相同的接口。即对于出租房屋来说，就是出租房屋的相关事项，房东和中介都必须完成的出租流程手续。
代理对象中有被代理对象的引用，这样外部调用者在调用代理对象的方法时，代理对象就会在内部交给被代理对象去实际执行。即，中介可以代替房东去出租房屋，最终决定权还是在房东手里。
外部调用者是直接使用接口进行调用的，对被代理对象的信息有一定的保护作用。即，租客只能通过出租房屋的流程手续与中介进行沟通，并不知道房东的个人信息。

租房代码实例 - Java 版

Talk is cheap，Show me your Code! 我们具体来看看代码怎么表示。首先是租房的一些流程，也就是被代理的行为，这里为方便只写了三个步骤。通常用抽象类或接口的形式表示：

// code 1
interface IRentHouse {
    // 带领租客看房
    void visitHouse();

    // 讨价还价
    void argueRent(int rent);
    
    // 签合同
    void signAgreement();
}

其次，房东的实现，也就是被代理对象的行为，房东的权利。

// code 2
class HouseOwner implements IRentHouse{
    @Override
    public void visitHouse() {
        System.out.println("HouseOwner 带领看房，介绍房屋特点");
    }

    @Override
    public void argueRent(int rent) {
        System.out.println("HouseOwner 提出租金为：" + rent);
    }

    @Override
    public void signAgreement() {
        System.out.println("HouseOwner 签合同");
    }
}

接下来就是房屋中介的实现，因为中介得到了房东的授权，所以他可以有房东的所有权利，他代理房东去操作出租房屋的相关事项。因此，中介会先征求房东的同意，拿到授权，在代码中的表现就是持有房东的引用。

// code 3
public class HouseAgent implements IRentHouse{
    IRentHouse mHouseOwner;    // 中介持有房东的权利

    public HouseAgent(IRentHouse houseOwner) {
        mHouseOwner = houseOwner;
    }

    @Override
    public void visitHouse() {
        mHouseOwner.visitHouse();
    }

    @Override
    public void argueRent(int rent) {
        mHouseOwner.argueRent(rent);
    }

    @Override
    public void signAgreement() {
        mHouseOwner.signAgreement();
    }
}

在 main 方法中就可以如下调用了：

// code 4
HouseAgent agent = new HouseAgent(new HouseOwner());    // 传入房东对象，拿到授权
agent.visitHouse();
agent.argueRent(300);
agent.signAgreement();

这其实就是一个静态代理的例子。为啥是“静态”？因为这里的代理方法是写死的，如果 HouseOwner 对象新增方法，那么在 HouseAgent 和接口中都得新增代码，不够灵活。

那么代理模式有什么作用？看起来好像就是代理类对被代理类做了一层封装而已，其实这层封装在一定程度上保护了被代理类的信息，使用者不用关心内部的具体实现。此外，代理类可以根据自身特点和客户需求进行功能扩展，在保证 HouseOwner 类的核心方法正确执行的情况下，扩展其他的行为。例如：租户刚毕业社会经验不足，遇到了一个黑心中介，需要在你看房前给小费：

// code 5
public class HouseAgent implements IRentHouse{
    IRentHouse mHouseOwner;    // 中介持有房东的权利
    int mTip = 0;    // 小费

    public HouseAgent(IRentHouse houseOwner) {
        mHouseOwner = houseOwner;
    }

    @Override
    public void visitHouse() {
        if (mTip > 10) {
            mHouseOwner.visitHouse();
        } else {
            System.out.println("小费不够，暂不能看房");
        }
    }

    @Override
    public void argueRent(int rent) {
        mHouseOwner.argueRent(rent);
    }

    @Override
    public void signAgreement() {
        mHouseOwner.signAgreement();
    }

    public void giveTip(int tip) {
        mTip = tip;
    }
}

租房代码实例 - Kotlin 版

上面静态代理的 Java 代码写起来虽然容易，但是套路都一样，显得繁琐。Kotlin 代码中，使用 by 关键字就可以了，非常方便，还是上面的例子，Kotlin 代码为：

// code 6
interface IRentHouse {
    // 带领租客看房
    fun visitHouse()

    // 讨价还价
    fun argueRent(rent: Int)

    // 签合同
    fun signAgreement()
}

class HouseOwner: IRentHouse {
    override fun visitHouse() {
        println("带领看房，介绍房屋特点")
    }

    override fun argueRent(rent: Int) {
        println("提出租金为：$rent")
    }

    override fun signAgreement() {
        println("签合同")
    }
}

class HouseAgent(houseOwner: IRentHouse): IRentHouse by houseOwner {}

// 调用的代码如下
HouseAgent(HouseOwner()).visitHouse()
HouseAgent(HouseOwner()).argueRent(500)
HouseAgent(HouseOwner()).signAgreement()

一个 by 关键字，就避免写很多重复的代码了。如果代理类要在原有的基础上添加自己的方法或功能，只需要在代理类中重写被代理对象中的方法。还是拿上面的例子说明：

// code 7
class HouseAgent(houseOwner: IRentHouse): IRentHouse by houseOwner {
    var mTip = 0
    private val mHouseOwner = houseOwner

    fun giveTip(tip: Int){
        mTip = tip
    }

    override fun visitHouse() {
        if (mTip > 10) {
            mHouseOwner.visitHouse()
        } else {
            println("小费不够，暂不能看房")
        }
    }
}

所以，静态代理就是把代理关系的代码是写死的，若被代理对象添加了新的方法，那么代理类和接口都需要改动。当然如果是用 Kotlin 写，那么只需要对接口进行改动。但是，如果我们想要切面编程，在每个被代理对象的方法中添加自己的处理，比如，我需要知道每个方法步骤的执行用时，那么就得在每个方法调用前后记录时间戳，这就很繁琐了。而且每新增方法都得重复写相同的代码，这种情况下，就需要使用动态代理。

Java 动态代理实现

创建 Java 的动态代理需要使用 Proxy 类：

// code 8
java.lang.reflect.Proxy

调用它的 newProxyInstance 方法，就可以为某类创建一个代理类。例如给 Map 创建一个代理类：

// code 9
Map mapProxy = (Map) Proxy.newProxyInstance(
        HashMap.class.getClassLoader(),
        new Class[]{Map.class},
        new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                return null;
            }
        }
);

可以分析下这个方法，方法签名为：

// code 10
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

ClassLoader 类型的 loader 对象：被代理类的类加载器；
Class 数组的 interfaces 对象：被代理的接口，对应于之前关键词中的被代理的行为，这里传入的是接口而不是某个具体的类，所以表示行为；
InvocationHandler 接口对象 h：代理的具体的行为，对应之前关键词中的对行为的完全控制，这也是 Java 动态代理的核心；
返回的 Object 对象：对应之前关键词中的代理对象。

所以，要实现一个动态代理大概需要下面几个步骤：

一、定义要被代理的行为例如 code1 就是定义的要被代理的行为。

二、定义被代理的对象就是实现了接口的类，例如实现了租房流程的房东，详见 code2。

三、建立代理关系这个是代理的核心，需要一个实现了 InvocationHandler 接口的类：

// code 11
public class AgentHandler implements InvocationHandler {

    private Object target;
    public AgentHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法执行前");
        Object result = method.invoke(target, args);
        System.out.println("方法执行后");
        return result;
    }
}

接口中的 invoke 方法比较重要。方法体中的 Object 类型的 proxy 是最终生成的代理对象；Method 类型的 method 是被代理的方法；Object[] 数组类型的 args 是被代理方法执行所需要的参数。target 对象就是传入的代理类。在这个类中，可以在 invoke 方法前后插入我们需要执行的代码，这样做可以使得被代理类对象在执行任何方法时，都会执行我们插入的代码。例如，我们可以在 invoke 方法前后记录下时间戳，这样就可以得出被代理类对象执行的每一个方法的执行时长。

然后代理类利用 InvocationHandler 进行代理：

// code 12
public class HouseAgentSmart {
    private IRentHouse mHouseOwner;    // 房东，被代理类对象
    public HouseAgentSmart(IRentHouse houseOwner) {
        mHouseOwner = houseOwner;
        mHouseOwner = (IRentHouse) Proxy.newProxyInstance(
                houseOwner.getClass().getClassLoader(),
                new Class[]{IRentHouse.class},
                new AgentHandler(mHouseOwner)    // 将被代理对象传入
        );
    }

    public IRentHouse getAccess() {    // 用于返回代理对象
        return mHouseOwner;
    }
}

四、执行者调用

// code 13
IRentHouse smartAgent = new HouseAgentSmart(new HouseOwner()).getAccess();
        smartAgent.visitHouse();
        smartAgent.argueRent(400);
        smartAgent.signAgreement();

Kotlin 动态代理实现

上面是动态代理的 Java 实现，那么如何用 Kotlin 实现？其实是一样的，只不过是编程语言的语法不同

// code 14
// IRentHouseKT.kt    1、首先还是定义接口
interface IRentHouseKT {
    // 带领租客看房
    fun visitHouse()

    // 讨价还价
    fun argueRent(rent : Int)

    // 签合同
    fun signAgreement()
}

// HouseOwnerKT.kt    2、然后是被代理类，实现接口
class HouseOwnerKT : IRentHouseKT {
    override fun visitHouse() {
        println("HouseOwner 带领看房，介绍房屋特点")
    }

    override fun argueRent(rent: Int) {
        println("HouseOwner 提出租金为：$rent")
    }

    override fun signAgreement() {
        println("HouseOwner 签合同")
    }
}

// AgentHandlerKT.kt    3、建立代理关系
class AgentHandlerKT : InvocationHandler {

    private var mTarget : Any? = null
    constructor(target : Any?) {
        this.mTarget = target
    }

    override fun invoke(proxy: Any?, method: Method, args: Array<out Any>?): Any? {
        println("方法执行前")
        // 因为传来的参数 args 是不确定的，所以用 *args.orEmpty() 传参
        val result = method.invoke(mTarget, *args.orEmpty())
        println("方法执行后")
        return result
    }
}

// HouseAgentSmartKT.kt    4、代理类，通过 AgentHandlerKT 得到代理关系
class HouseAgentSmartKT {
    var mHouseOwner : IRentHouseKT? = null

    constructor(houseOwner : IRentHouseKT) {
        mHouseOwner = houseOwner
        mHouseOwner = Proxy.newProxyInstance(
                houseOwner.javaClass.classLoader,
                arrayOf(IRentHouseKT::class.java),
                AgentHandlerKT(mHouseOwner)
        ) as IRentHouseKT
    }
}

// 调用方进行调用
val smartAgent = HouseAgentSmartKT(HouseOwnerKT()).mHouseOwner
smartAgent?.visitHouse()
smartAgent?.argueRent(500)
smartAgent?.signAgreement()

看到这里就有人要问了，咦？之前不是用 by 关键字就可以在 kotlin 中进行代理吗？为啥还需要像 Java 一样用 Proxy.newProxyInstance() 方法写代理的模式？这两种方式有什么区别？

首先，这两种方式都可以在 Kotlin 中实现代理模式，但适用的场景有所不同。 1、by 关键字实现的代理模式。使用起来更加方便，代理的粒度更小，可以根据代理类自身需要对某些被代理类中的方法进行重写； 2、Proxy.newProxyInstance() 方法实现的代理模式。实现比较繁琐，代理的粒度大，一旦代理，就是代理所有的方法。可以在原方法前后插入自己想要执行的代码，适用于埋点记录 log 日志、记录方法执行用时等。

参考文献

还没看够？欢迎来逛逛我的公众号。搜索：修之竹 也欢迎知乎关注 修之竹~

ps. 赠人玫瑰，手留余香。欢迎转发分享加关注，你的认可是我继续创作的精神源泉。

Kotlin 学习笔记（三）—— Kotlin 的动态代理你会写吗？

引子