深坑，谨慎用动态代理对象作为监听器-CSDN博客

大家好，三月已到，正是退税、赏桃花、看掘金的好日子，这次给大家分享下使用动态代理对象作为监听器注入中埋藏的隐患，发生在一个业务场景中，且听我一一道来。

前情回顾

假设当前有一个需求，我们需要动态监听一个人一天内执行的一些动作，作为上层应用，咱们肯定是不care具体怎么实现人动作的监测，只需要找个能干活的三方的SDK，该SDK暴漏监听的方法给上层应用，上层应用只用注册个监听器给SDK就行，当人动作发生的时候，就由SDK通过传入的监听器来通知上层应用。

SDK中定义人动作的接口如下：

interface PersonAction {


    /**
     * 起床
     */
    fun getUp()


    /**
     * 吃饭
     */
    fun eat()


    /**
     * 上厕所
     */
    fun goToilet()


    /**
     * 打球
     */
    fun playBall()


    /**
     * 做家庭作业
     */
    fun doHomeWork()


    /**
     * 购物
     */
    fun buyGoods()


    /**
     * 开车
     */
    fun driveCar()


    /**
     * 睡觉
     */
    fun sleep()
}

然后SDK提供一个注入监听器的方法，并且管理上层应用注册的监听器集合，比如增删改查，以及在特定时机通知监听器人动作的执行：

object PersonActionManager {


    private val mActions: MutableList<PersonAction> = mutableListOf()


    fun registerPersonAction(personAction: PersonAction?) {
        if (personAction == null || mActions.contains(personAction)) {
            return
        }


        mActions.add(personAction)
    }
    
    fun removePersonAction(personAction: PersonAction?) {
        if (personAction == null || !mActions.contains(personAction)) {
            return
        }


        mActions.remove(personAction)
    }


    /**
     * 通知人起床了
     */
    fun dispatchPersonActionGetUp() {
        if (mActions.isEmpty()) {
            return
        }
        mActions.forEach { 
            it.getUp()
        }
        
    }


    /**
     * 通知人吃饭了
     */
    fun dispatchPersonActionEat() {
        if (mActions.isEmpty()) {
            return
        }
        mActions.forEach { 
            it.eat()
        }
    }


    //此处省略人其他动作执行的通知
}

如果咱们上层应用要监听人动作的执行，只需要调用SDK的方法注入一个监听器即可：

class App {


    /**
     * 上层应用借助SDK监听人动作的执行
     */
    fun listener() {
        PersonActionManager.registerPersonAction(object : PersonAction {
            override fun getUp() {
            }


            override fun eat() {
            }


            override fun goToilet() {
            }


            override fun playBall() {
            }


            override fun doHomeWork() {
            }


            override fun buyGoods() {
            }


            override fun driveCar() {
            }


            override fun sleep() {
            }
        })
    }
}

可以看到，这样写有一个弊端：如果我应用中有多个地方都需要监听人动作的执行，那就会往SDK注入多个监听器，由于这个SDK是面向很多应用的，每个应用都这么搞，那SDK中监听器队列集合就会无限膨胀了，毕竟不是每个应用都会及时反注册监听器或者干脆就不反注册，随着时间长了，该SDK就会面临三个困境了：

存在应用层忘记移除的监听器仍保存在SDK监听集合中，浪费资源，并且存在内存泄漏的风险，毕竟注入监听器是个匿名内部类，会持有外部类的使用；
集合大小不断的增加，可能集合内容会发生多次内存拷贝进行扩容，影响性能；等达到一定大小后，还会拖慢对集合的增删改查效率等；
不方便对应用侧注入的监听器进行统一管理，比如做通用埋点等

这个时候比较负责任的应用层避免上述问题的发生，就采取了一个方法：

在应用侧增加一层监听器集合管理，并且保证应用只会向该SDK注入一个监听器，当应用某些地方需要监听人动作执行时，将这个监听器注入到应用侧的监听器集合，然后通过前面只注入SDK一个的监听器来通知整个应用侧的监听器集合，具体请看下面代码：

/**
 * 应用侧人动作监听集合管理类
 */
object AppPersonActionManager {
    private val mAppActions: MutableList<PersonAction> = mutableListOf()


    private var mProxy: PersonAction? = null


    fun registerPersonAction(personAction: PersonAction?) {
        if (personAction == null || mAppActions.contains(personAction)) {
            return
        }


        mAppActions.add(personAction)


        //保证只向SDK注入一次监听器
        if (mAppActions.size == 1) {
            PersonActionManager.registerPersonAction(createPersonActionProxy().apply {
                mProxy = this
            })
        }
    }


    fun removePersonAction(personAction: PersonAction?) {
        if (personAction == null || !mAppActions.contains(personAction)) {
            return
        }


        mAppActions.remove(personAction)


        if (mAppActions.size == 0) {
            PersonActionManager.removePersonAction(mProxy)
        }
    }


    private fun createPersonActionProxy(): PersonAction {
        val proxy =
            Proxy.newProxyInstance(AppPersonActionManager::class.java.classLoader, arrayOf(PersonAction::class.java),
                object : InvocationHandler {
                    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any? {


                        var result: Any? = null
                        mAppActions.forEach {
                            result = method?.invoke(it, args)
                        }


                        println("Proxy#Method: ${method?.name}, result = $result")


                        return result
                    }


                }) as PersonAction
        return proxy
    }
}

上面的AppPersonActionManager就是应用侧核心的管理类，下面对每个方法进行解释：