kotlin中by关键字有啥用
前言
在kotlin中,by
关键字代表着代理,也常常被称之为委托。如果了解学过java设计模式的同学应该听说过有个设计模式叫做代理(委托)设计模式。在理解kotlin中的by关键字之前,我们不妨先复习一下代理模式。
什么是代理模式
-
代理模式就是为其他对象提供一种代理以控制对这个对象的访问。
下面是一个简单的代理模式demopackage 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
关键字就写到这了,原谅我想到哪写到哪的低水平文笔,希望能给你帮助_!