Kotlin 通过委托实现接口方法

2025-01-15

委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。Kotlin 直接支持委托模式，更加优雅，简洁，在 Kotlin 中，通过关键字 by 实现委托。

通过委托方式实现接口的方法，实际上是通过动态代理的方式创建一个接口的实现类对象，并委托给要实现这个接口的类，减少接口不需要的方法的重写。

1. 类委托

类的委托即一个类中定义的方法实际是调用另一个类的对象的方法来实现的。以下实例中派生类 Leader 继承了接口 Work 所有方法，并且委托一个传入的 Clerk 类的对象来执行这些方法。

// 创建接口
interface Work {
    fun work()
}

// 实现此接口的被委托的类
class Clerk : Work {
    override fun work() { println("Clerk is working") }
}

// 通过关键字 by 建立委托类
class Leader(clerk: Clerk) : Work by clerk

fun main(args: Array<String>) {
    val clerk = Clerk()
    Leader(clerk).work()
}

------------------------------------

输出：Clerk is working

在 Leader 的声明中，by 关键字表示，将 clerk 保存在 Leader 的对象实例内部，而且编译器将会生成继承自 Work 接口的所有方法, 并将调用转发给 clerk。

2. 动态代理

动态代理允许你在运行时动态地创建代理对象，从而在方法调用前后执行额外的操作。其核心思想是创建一个代理对象来代替原始对象。这个代理对象实现了与原始对象相同的接口，但它可以拦截对原始对象方法的调用，并在调用前后执行自定义的逻辑。与静态代理不同，动态代理不需要在编译时就确定代理类，而是在运行时动态生成。

interface Calculate {
    fun add(num1: Int, num2: Int): Int
}

class Calculator : Calculate {
    override fun add(num1: Int, num2: Int): Int {
        return num1 + num2
    }
}

// 动态代理，目标对象是活动的，不是固定的，需要传入进来
class InvocationHandlerProxy(private val target: Any) : InvocationHandler {

    // 通过 newProxyInstance() 方法创建代理对象
    fun getProxy(): Any? {
        // 参数：类加载器、代理需要实现的接口、调用处理器
        return Proxy.newProxyInstance(target.javaClass.classLoader, target.javaClass.interfaces, this)
    }

    @Throws(Throwable::class)
    override fun invoke(proxy: Any, method: Method, args: Array<Any>): Any? {
        println("代理对象前置代码")
        val invoke = method.invoke(target, *args)
        println("代理对象后置代码")
        return invoke
    }
}

fun main(args: Array<String>) {
    // 1、创建被代理对象
    val calculator = Calculator()
    
    // 2、创建 InvocationHandler 对象，传入被代理对象
    val invocationHandler = InvocationHandlerProxy(calculator)
    
    // 3、获取代理对象，强转后只能是接口类型不能是实现类
    val proxy = invocationHandler.getProxy() as Calculate

    // 4、通过代理对象调用目标对象方法
    proxy.add(2, 3)
}

3. 接口实现

对类委托和动态代理有了一定的了解后，就可以通过这些技术从编码层面将接口不需要的方法去掉了。当实现非 SAM 接口时，需要实现多个方法。大多数情况下，部分方法是开发者用不到的，但仍然需要空实现。例如，为 EditText 添加 TextWatcher 监听。

val edit = findViewById<EditText>(R.id.edit)
edit.addTextChangedListener(object : TextWatcher {
    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {

    }

    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {

    }

    override fun afterTextChanged(s: Editable?) {

    }
})

上面的代码实现了监听器的全部方法，但是通过 Kotlin 的委托机制，可以将接口实现委托给方法进行实现，代码如下：

inline fun <reified T : Any> interfaceDelegate(): T {
    val javaClass = T::class.java
    val noDelegate = InvocationHandler { _, _, _ -> }
    return Proxy.newProxyInstance(javaClass.classLoader, arrayOf(javaClass), noDelegate) as T
}

在调用处用委托处理，通过这种方式可以自由选择需要实现的方法，而不是实现接口的所有方法。

val edit = findViewById<EditText>(R.id.edit)
edit.addTextChangedListener(object : TextWatcher by interfaceDelegate() {
    override fun afterTextChanged(s: Editable?) {

    }
})

通过 KotlinByteCode 可以查看对应的 Java 实现，代码中可以看到通过动态代理的方式生成了一个 TextWatcher 对象 delegate_0，并委托此对象完成方法的实现。

EditText edit = (EditText)this.findViewById(2131230891);
edit.addTextChangedListener((TextWatcher)(new TextWatcher(this) {
   private final TextWatcher $$delegate_0;

   {
      int $i$f$interfaceDelegate = false;
      Class javaClass$iv = TextWatcher.class;
      InvocationHandler noDelegate$iv = (InvocationHandler)null.INSTANCE;
      ClassLoader var10001 = javaClass$iv.getClassLoader();
      Class[] var6 = new Class[]{javaClass$iv};
      Object var7 = Proxy.newProxyInstance(var10001, var6, noDelegate$iv);
      if (var7 == null) {
         throw new NullPointerException("null cannot be cast to non-null type android.text.TextWatcher");
      } else {
         this.$$delegate_0 = (TextWatcher)var7;
      }
   }

   public void beforeTextChanged(CharSequence s, int start, int count, int after) {
      this.$$delegate_0.beforeTextChanged(s, start, count, after);
   }

   public void onTextChanged(CharSequence s, int start, int before, int count) {
      this.$$delegate_0.onTextChanged(s, start, before, count);
   }

   public void afterTextChanged(Editable s) {
   }
}));

✦ 说明：KotlinByteCode 查看路径**「Android Studio → Tools → Kotlin → Show Kotlin Bytecode」**