美文网首页
kotlin代理模式

kotlin代理模式

作者: 请输入妮称 | 来源:发表于2018-08-12 10:10 被阅读0次

    koltin的特性大多不是空穴来风,而是为了解决一些固有问题。

    kotlin代理模式官方文档地址:http://kotlinlang.org/docs/reference/delegation.html

    一.代理模式

    代理是实现代码复用的一种方法。
    在面向对象的语言中,代理模式是通过组合的方式来达到和继承一样的效果的。

    代理模式定义:给某个对象提供一个代理对象,并由代理对象控制对于原对象的访问,即客户不直接操控原对象,而是通过代理对象间接地操控原对象。

    下面是代理模式UML图:


    代理模式三要素:1.RealSubject 原对象 2.Proxy 代理对象 3.Subject 接口

    RealSubject和Proxy都实现了Subject接口,这样两者就具有了公共方法Request。

    通过执行Proxy中的Request方法,间接的执行RealSubject中的Request方法。

    先来个🌰了解一下如何实现:

    interface Subject {
        void request();
    }
    class RealSubject implements Subject{
    
        @Override
        public void request() {
            System.out.println("RealSubject");
        }
    }
    class Proxy implements Subject{
        private RealSubject realSubject;
    
        public Proxy(RealSubject realSubject) {
            this.realSubject = realSubject;
        }
    
        @Override
        public void request() {
            System.out.println("Proxy start");
            realSubject.request();
            System.out.println("Proxy end");
        }
    }
    public static void main(String[] args){
        RealSubject realSubject = new RealSubject();
        Proxy proxy=new Proxy(realSubject);
        proxy.request();
    }
    
    

    以上代码就是代理模式的实现原理。

    通过代理模式:
    功能1. 我们可以复用RealSubject类的代码。
    功能2. 在执行RealSubject的request方法执行之前和执行之后,插入一段代码(比如打印出来request方法的执行时间)。

    对于功能1 接下来让我们思考一个问题:
    假如Subject接口声明了2个方法。而我们需要复用RealSubject其中的1个方法:

    interface Subject {
        void request1();
        void request2();
    }
    class RealSubject implements Subject{
        @Override
        public void request1() {
            System.out.println("RealSubject request1");
        }
    
        @Override
        public void request2() {
            System.out.println("RealSubject request2");
        }
    }
    class Proxy implements Subject{
        private RealSubject realSubject;
    
        public Proxy(RealSubject realSubject) {
            this.realSubject = realSubject;
        }
    
        @Override
        public void request1() {
            realSubject.request1();
        }
    
        @Override
        public void request2() {
            System.out.println("Proxy request2");
        }
    }
    

    我们需要手动书写Proxy类,然后重载request1和request2方法,我们可以很快的把代码敲完。

    如果Subject接口声明了100个方法,而我们想复用RealSubject类中的90个方法呢,这敲代码花费的时间不可忽视。

    kotlin成功的解决了这个问题。

    二.kotlin代理模式的实现

    kotlin实现代理模式非常简单,看一个官网的🌰:

    interface Base {
        fun print()
    }
    
    class BaseImpl(val x: Int) : Base {
        override fun print() { print(x) }
    }
    
    class Derived(b: Base) : Base by b
    
    fun main(args: Array<String>) {
        val b = BaseImpl(10)
        Derived(b).print()
    }
    

    运行结果是:10

    转为java代码看一下庐山真面目:

    // Base.java
    import kotlin.Metadata;
    
    public interface Base {
       void print();
    }
    // Derived.java
    import kotlin.Metadata;
    import kotlin.jvm.internal.Intrinsics;
    import org.jetbrains.annotations.NotNull;
    
    public final class Derived implements Base {
       private final Base $$delegate_0;
    
       public Derived(@NotNull Base b) {
          Intrinsics.checkParameterIsNotNull(b, "b");
          super();
          this.$$delegate_0 = b;
       }
    
       public void print() {
          this.$$delegate_0.print();
       }
    }
    // TestKt.java
    import kotlin.Metadata;
    import kotlin.jvm.internal.Intrinsics;
    import org.jetbrains.annotations.NotNull;
    
    public final class TestKt {
       public static final void main(@NotNull String[] args) {
          Intrinsics.checkParameterIsNotNull(args, "args");
          BaseImpl b = new BaseImpl(10);
          (new Derived((Base)b)).print();
       }
    }
    // BaseImpl.java
    import kotlin.Metadata;
    
    public final class BaseImpl implements Base {
       private final int x;
    
       public void print() {
          int var1 = this.x;
          System.out.print(var1);
       }
    
       public final int getX() {
          return this.x;
       }
    
       public BaseImpl(int x) {
          this.x = x;
       }
    }
    
    

    其实就是在编译期自动生成了Derived类,解放了双手。

    我们可以按照需求复写print()方法

    interface Base {
        fun printMessage()
        fun printMessageLine()
    }
    
    class BaseImpl(val x: Int) : Base {
        override fun printMessage() { print(x) }
        override fun printMessageLine() { println(x) }
    }
    
    class Derived(b: Base) : Base by b {
        override fun printMessage() { print("abc") }
    }
    
    fun main(args: Array<String>) {
        val b = BaseImpl(10)
        Derived(b).printMessage()
        Derived(b).printMessageLine()
    }
    

    输出:abc10

    Derived除了可以实现Base接口,还可以继承其他父类,方法名字遇到冲突怎么办

    比如Derived继承了父类Parent,而父类同样拥有print方法:

    interface Base {
        fun print()
    }
    
    class BaseImpl(val x: Int) : Base {
        override fun print() {
            print(x)
        }
    }
    
    open class Parent {
        open fun print() {
            println("Parent print")
        }
    }
    
    class Derived(b: Base) : Parent(),Base by b
    
    fun main(args: Array<String>) {
        val b = BaseImpl(10)
        Derived(b).print()
    }
    

    输出:10
    可以看到父类print方法会被覆盖。

    三.kotlin代理模式的总结

    1.只能实现对接口方法的代理,即Base类不能为抽象类。
    2.不方便对所有的代理方法进行统一处理。比如说在执行每个方法前都执行相同的逻辑,而java动态代理可以方便的实现这个功能。
    3.方法名称有冲突时,代理类方法优先级较高。
    4.编译期自动生成代理模式。不会影响运行效率。

    四.继承和代理的选择

    如果仅仅是代码复用和方法重写,继承能达到和代理一样的效果。

    继承和代理的使用都存在条件限制:

    如果使用继承的话,父类必须为可继承的,并且想要覆盖的方法也必须为可重写的,即java中类和方法都不能存在final修饰符,kotlin中明确使用open修饰符。

    使用代理的话,两者需要存在公共接口,比如上面例子中类DerivedParent都需要实现Base接口。

    由于kotlin、java存在单继承的约束(每个类只能存在一个父类),在使用继承或者代理均可的情况下,推荐使用代理。

    相关文章

      网友评论

          本文标题:kotlin代理模式

          本文链接:https://www.haomeiwen.com/subject/olfjbftx.html