前言

在kotlin中，by关键字代表着代理，也常常被称之为委托。如果了解学过java设计模式的同学应该听说过有个设计模式叫做代理(委托)设计模式。在理解kotlin中的by关键字之前，我们不妨先复习一下代理模式。

什么是代理模式

• 代理模式就是为其他对象提供一种代理以控制对这个对象的访问。
  下面是一个简单的代理模式demo

  package delegate;
  
  interface DelegateApiJava {
      void doSomething();
  }
  
  class ImplJava implements DelegateApiJava {
  
      private DelegateApiJava delegateApiJava;
  
      public ImplJava(DelegateApiJava delegateApiJava) {
          this.delegateApiJava = delegateApiJava;
      }
  
      @Override  
      public void doSomething() {
          if (this.delegateApiJava != null) {
              System.out.println("before");
              delegateApiJava.doSomething();
              System.out.println("after");
          }
      }
  }
  
  public class Demo {
      public static void main(String[] args) {
          ImplJava implJava = new ImplJava(new DelegateApiJava() {
              @Override
              public void doSomething() {
                  System.out.println("doSomething");
              }
          });
  
          implJava.doSomething();
      }
  }
  
  // 输出（before和after就是自己的逻辑，doSomething就是代理对象的实现）
  before
  doSomething
  after
  

可以发现，代理模式的本质就是，在实现类中，用代理对象的方法代替实现类中的方法，并适当增加一些自己的逻辑。

koltin中的关键字by

在kotlin中，by关键字主要有两种用途，一种是接口代理，另一种是属性代理。

接口代理

下面展示一个简单的接口代理使用方法

package delegate

interface Api {
    fun eat()
    fun play()
}

class ApiImpl(api: Api) : Api by api

为了弄明白by关键字到底做了啥，我们可以点击 View ->Tool Windows -> kotlin bytecode 查看字节码，看不懂的话点一下Decompile，可以看到反编译之后的java版本源码下面是这段代码对应的反编译代码。

// ApiImpl.java
package delegate;

import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

@Metadata(
   mv = {1, 1, 16},
   bv = {1, 0, 3},
   k = 1,
   d1 = {"\u0000\u0014\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0010\u0002\n\u0002\b\u0002\u0018\u00002\u00020\u0001B\r\u0012\u0006\u0010\u0002\u001a\u00020\u0001¢\u0006\u0002\u0010\u0003J\t\u0010\u0004\u001a\u00020\u0005H\u0096\u0001J\t\u0010\u0006\u001a\u00020\u0005H\u0096\u0001¨\u0006\u0007"},
   d2 = {"Ldelegate/ApiImpl;", "Ldelegate/Api;", "api", "(Ldelegate/Api;)V", "eat", "", "play", "qi.main"}
)
public final class ApiImpl implements Api {
   // $FF: synthetic field
   private final Api $$delegate_0;

   public ApiImpl(@NotNull Api api) {
      Intrinsics.checkParameterIsNotNull(api, "api");
      super();
      this.$$delegate_0 = api;
   }

   public void eat() {
      this.$$delegate_0.eat();
   }

   public void play() {
      this.$$delegate_0.play();
   }
}
// Api.java
package delegate;

import kotlin.Metadata;

@Metadata(
   mv = {1, 1, 16},
   bv = {1, 0, 3},
   k = 1,
   d1 = {"\u0000\u0012\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0000\n\u0002\u0010\u0002\n\u0002\b\u0002\bf\u0018\u00002\u00020\u0001J\b\u0010\u0002\u001a\u00020\u0003H&J\b\u0010\u0004\u001a\u00020\u0003H&¨\u0006\u0005"},
   d2 = {"Ldelegate/Api;", "", "eat", "", "play", "qi.main"}
)
public interface Api {
   void eat();

   void play();
}

对比一看，这不就是设计模式中的代理模式吗，是的，在kotlin中，通过by关键字，我们可以轻松实现代理模式，帮我们简化了大量代码，下面看一下属性代理又是怎么使用的。

属性代理

属性代理，顾名思义，就是对kotlin中属性的get和set方法的代理。
属性代理不需要实现任何方法，但是他们得提供一个getValue方法（如果是var，还得提供一个setValue方法）。下面是一个简单的demo

package delegate

import kotlin.reflect.KProperty

class M {
    val s: String by MyDelegate { "Hello" }
}

class MyDelegate<T>(val init: () -> T) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return init()
    }
}

老规矩，使用show kotlin bytecode查看这段代码到底干了啥

public final class M {
   // $FF: synthetic field
   static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(M.class), "s", "getS()Ljava/lang/String;"))};
   @NotNull
   private final MyDelegate s$delegate;

   @NotNull
   public final String getS() {
      return (String)this.s$delegate.getValue(this, $$delegatedProperties[0]);
   }

   public M() {
      this.s$delegate = new MyDelegate((Function0)null.INSTANCE);
   }
}
// MyDelegate.java
package delegate;

public final class MyDelegate {
   @NotNull
   private final Function0 init;

   public final Object getValue(@Nullable Object thisRef, @NotNull KProperty property) {
      Intrinsics.checkParameterIsNotNull(property, "property");
      return this.init.invoke();
   }

   @NotNull
   public final Function0 getInit() {
      return this.init;
   }

   public MyDelegate(@NotNull Function0 init) {
      Intrinsics.checkParameterIsNotNull(init, "init");
      super();
      this.init = init;
   }
}

通过对比，可以清楚的发现，在M类中，通过by关键字给M类的属性生成了一个KProperty的数组，当然，声明为数组是为了支持多个属性代理。在本实例中只给了一个by关键字的属性代理，所以这个数组的元素只有一个，表示了被代理对象s的属性，然后就是十分类似接口代理的方法补充了，为s补充get方法。

思考：为啥得补充getS()这个方法呢

• koltin通过编译，能够自动帮我们实现类中属性的get和set方法，帮我们省去了很多事情。但我们在kotlin中没有写get/set方法并不代表字节码中没有这俩方法，所以反编译的结果中有这个方法，而这个方法则需要调用我们自己写的getValue方法了，这也是为什么属性代理一定得提供getValue方法的原因了，
• 是否需要实现setValue取决于属性是否是用var声明的。

上面的小例子与by lazy式声明变量对比如何

kotlin代码：

package delegate

class M {
    val s by lazy { "hello" }
}

反编译的java代码：

public final class M {
   // $FF: synthetic field
   static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(M.class), "s", "getS()Ljava/lang/String;"))};
   @NotNull
   private final Lazy s$delegate;

   @NotNull
   public final String getS() {
      Lazy var1 = this.s$delegate;
      KProperty var3 = $$delegatedProperties[0];
      boolean var4 = false;
      return (String)var1.getValue();
   }

   public M() {
      this.s$delegate = LazyKt.lazy((Function0)null.INSTANCE);
   }
}

对比可以发现，仅仅是初始化s$delegate的方法不同而已，这个方法我们可以查看源码如下：

internal object UNINITIALIZED_VALUE

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    // final field is required to enable safe publication of constructed instance
    private val lock = lock ?: this

    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }

            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

    private fun writeReplace(): Any = InitializedLazyImpl(value)
}

为啥没有看到getValue方法呢，不是说好了属性代理必须实现getValue吗？我当时看到这个类的时候也纳闷了一会儿，还一度把对象的get方法当成了getValue方法，就是下面那个：

override val value: T
    get()

后来转念一想，这方法参数也不对啊，这个getValue没有入参啊，而我们要的getValue是有两个入参的呢！
其实getValue是一扩展函数的方式给出的，源代码如下。

/**
 * An extension to delegate a read-only property of type [T] to an instance of [Lazy].
 *
 * This extension allows to use instances of Lazy for property delegation:
 * `val property: String by lazy { initializer }`
 */
@kotlin.internal.InlineOnly
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

总结一下lazy干了啥把。

• 1.lazy{"Hello"}是一个实现了Lazy接口的对象，所以有支持属性代理的getValue方法
• 2.实现方式默认同步，即同一时间只允许一个线程修改value的值
• 3.懒加载，即有初始化且仅在第一次加载时初始化，上诉源码可以看到这点

kotlin用短短一行代码就解决了java中变量生命的安全性问题，是不是更爱这门语言了呢！

kotlin中的by关键字就写到这了，原谅我想到哪写到哪的低水平文笔，希望能给你帮助^_!