代理模式 Proxy Pattern 【kotlin版代码参考】

代理模式 Proxy Pattern 【kotlin版代码参考】

第一种：静态代理

interface TrainStation {

    fun sellTickets()
}

class GuangzhouTrainStation : TrainStation {

    companion object {
        const val TAG = "GuangzhouTrainStation"
    }

    override fun sellTickets() {
        Log.e(TAG, "广州火车站卖票了 ")
    }
}

class ProxyPoint : TrainStation {

   private val guangzhouTrainStation: GuangzhouTrainStation = GuangzhouTrainStation()

    companion object {
        const val TAG = "ProxyPoint"
    }

    override fun sellTickets() {
        Log.e(TAG, "广州火车站卖票了 ")
        guangzhouTrainStation.sellTickets()
    }
}

        val proxyPoint = ProxyPoint()
        proxyPoint.sellTickets()

静态代理的优点

实现简单，容易理解，只要确保目标对象和代理对象实现共同的接口或继承相同的父类就可以在不修改目标对象的前提下进行扩展

缺点

也比较明显，那就是代理类和目标类必须有共同接口(父类)，并且需要为每一个目标类维护一个代理类，当需要代理的类很多时会创建出大量代理类。一旦接口或父类的方法有变动，目标对象和代理对象都需要作出调整

第二种：动态代理

interface TrainStation {
    fun sellTickets()
}

class GuangzhouTrainStation : TrainStation {
    companion object {
        const val TAG = "GuangzhouTrainStation"
    }

    override fun sellTickets() {
        Log.e(TAG, "广州火车站卖票了")
    }
}

class ProxyPoint : InvocationHandler {
    private var trainStation: TrainStation? = null

    fun getProxyObject(trainStation: TrainStation?): TrainStation {
        this.trainStation = trainStation
        val clazz: Class<out TrainStation?> = trainStation!!.javaClass
        return Proxy.newProxyInstance(clazz.classLoader, clazz.interfaces, this) as TrainStation
    }

    @Throws(Throwable::class)
    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any? {
        return method!!.invoke(trainStation, *(args ?: emptyArray()))
    }
}

        val proxy = ProxyPoint()
        val guangzhouTrainStation: TrainStation = proxy.getProxyObject(GuangzhouTrainStation())
        guangzhouTrainStation.sellTickets()

优点：

使用简单、维护成本低。
Java原生支持，不需要任何依赖。
解决了静态代理存在的多数问题。

缺点：

由于使用反射，性能会比较差。
只支持接口实现，不支持继承， 不满足所有业务场景。