前言

在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關鍵字就寫到這了，原諒我想到哪寫到哪的低水平文筆，希望能給你幫助^_!

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

kotlin中by關鍵字有啥用

kotlin中by關鍵字有啥用

前言

什么是代理模式

koltin中的關鍵字by

接口代理

屬性代理

思考：為啥得補充`getS()`這個方法呢

上面的小例子與`by lazy`式聲明變量對比如何

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

kotlin中by關鍵字有啥用

前言

什么是代理模式

koltin中的關鍵字by

接口代理

屬性代理

思考：為啥得補充getS()這個方法呢

上面的小例子與by lazy式聲明變量對比如何

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

思考：為啥得補充`getS()`這個方法呢

上面的小例子與`by lazy`式聲明變量對比如何