目录
类委托
类委托有点类似于Java中的代理模式
interface Base{
fun text()
}
//被委托的类(真实的类)
class BaseImpl(val x:String): Base {
override fun text() {
println(x)
}
}
//委托类
class Devices(b:Base):Base by b
fun main(){
var b = BaseImpl("真实的类")
Devices(b).text()
}
输出
委托类（代理类）持有真实类的对象，然后委托类（代理类）调用真实类的同名方法，最终真正实现的是方法的是真实类，这其实就是代理模式
kotlin中的委托借助于by关键字，by关键字后面就是被委托类
反编译成java代码
public final class BaseImpl implements Base {
@NotNull
private final String x;
public BaseImpl(@NotNull String x) {
Intrinsics.checkNotNullParameter(x, "x");
super();
this.x = x;
}
@NotNull
public final String getX() {
return this.x;
}
public void text() {
String var1 = this.x;
System.out.println(var1);
}
}
// Devices.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
@Metadata(
mv = {1, 9, 0},
k = 1,
xi = 48,
d1 = {"\u0000\u0012\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0010\u0002\n\u0000\u0018\u00002\u00020\u0001B\r\u0012\u0006\u0010\u0002\u001a\u00020\u0001¢\u0006\u0002\u0010\u0003J\t\u0010\u0004\u001a\u00020\u0005H\u0096\u0001¨\u0006\u0006"},
d2 = {"Lcom/example/memoryoptimizing/delegate/Devices;", "Lcom/example/memoryoptimizing/delegate/Base;", "b", "(Lcom/example/memoryoptimizing/delegate/Base;)V", "text", "", "app_debug"}
)
public final class Devices implements Base {
// $FF: synthetic field
private final Base $$delegate_0;
public Devices(@NotNull Base b) {
Intrinsics.checkNotNullParameter(b, "b");
super();
this.$$delegate_0 = b;
}
public void text() {
this.$$delegate_0.text();
}
}
// BaseImplKt.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
@Metadata(
mv = {1, 9, 0},
k = 2,
xi = 48,
d1 = {"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
d2 = {"main", "", "app_debug"}
)
public final class BaseImplKt {
public static final void main() {
BaseImpl b = new BaseImpl("真实的类");
(new Devices((Base)b)).text();
}
// $FF: synthetic method
public static void main(String[] args) {
main();
}
}
可以看到，Devices持有BaseImpl对象，重写text方法，text方法内部调用的是BaseImpl.text()
属性委托
属性委托和类委托一样，属性委托其实是对属性的set/get方法的委托，把set/get方法委托给setValue/getValue方法，因此被委托类(真实类)需要提供setValue/getValue方法，val属性只需要提供setValue方法
属性委托语法：
val/var <属性名>:<类型> by <表达式>
class B{
//委托属性
var a : String by Text()
}
class Text {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "属性拥有者 = $thisRef ,属性的名字 = ‘${property.name}’ 属性的值"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("属性的值 = $value 属性的名字 = '${property.name}' 属性拥有者 = $thisRef")
}
}
fun main(){
var b = B()
println(b.a)
b.a = "ahaha"
}
输出
属性a委托给了Text，而且Text类中有setValue和getValue，所有当我们调用属性a的set/get方法时候，会委托到Text的setValue/getValue。
thisRef:属性的拥有者
property：对属性的描述，是KProperty<*>类型或者父类
value：属性的值
反编译成Java代码
public final class B {
// $FF: synthetic field
static final KProperty[] $$delegatedProperties;
@NotNull
private final Text a$delegate = new Text();
@NotNull
public final String getA() {
return this.a$delegate.getValue(this, $$delegatedProperties[0]);
}
public final void setA(@NotNull String var1) {
Intrinsics.checkNotNullParameter(var1, "<set-?>");
this.a$delegate.setValue(this, $$delegatedProperties[0], var1);
}
static {
KProperty[] var0 = new KProperty[]{Reflection.mutableProperty1((MutablePropertyReference1)(new MutablePropertyReference1Impl(B.class, "a", "getA()Ljava/lang/String;", 0)))};
$$delegatedProperties = var0;
}
}
// Text.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import kotlin.reflect.KProperty;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@Metadata(
mv = {1, 9, 0},
k = 1,
xi = 48,
d1 = {"\u0000\"\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0002\n\u0002\u0010\u000e\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u0002\n\u0002\b\u0002\u0018\u00002\u00020\u0001B\u0005¢\u0006\u0002\u0010\u0002J\u001f\u0010\u0003\u001a\u00020\u00042\b\u0010\u0005\u001a\u0004\u0018\u00010\u00012\n\u0010\u0006\u001a\u0006\u0012\u0002\b\u00030\u0007H\u0086\u0002J'\u0010\b\u001a\u00020\t2\b\u0010\u0005\u001a\u0004\u0018\u00010\u00012\n\u0010\u0006\u001a\u0006\u0012\u0002\b\u00030\u00072\u0006\u0010\n\u001a\u00020\u0004H\u0086\u0002¨\u0006\u000b"},
d2 = {"Lcom/example/memoryoptimizing/delegate/Text;", "", "()V", "getValue", "", "thisRef", "property", "Lkotlin/reflect/KProperty;", "setValue", "", "value", "app_debug"}
)
public final class Text {
@NotNull
public final String getValue(@Nullable Object thisRef, @NotNull KProperty property) {
Intrinsics.checkNotNullParameter(property, "property");
return "属性拥有者 = " + thisRef + " ,属性的名字 = ‘" + property.getName() + "’ 属性的值";
}
public final void setValue(@Nullable Object thisRef, @NotNull KProperty property, @NotNull String value) {
Intrinsics.checkNotNullParameter(property, "property");
Intrinsics.checkNotNullParameter(value, "value");
String var4 = "属性的值 = " + value + " 属性的名字 = '" + property.getName() + "' 属性拥有者 = " + thisRef;
System.out.println(var4);
}
}
// TextKt.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
@Metadata(
mv = {1, 9, 0},
k = 2,
xi = 48,
d1 = {"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
d2 = {"main", "", "app_debug"}
)
public final class TextKt {
public static final void main() {
B b = new B();
String var1 = b.getA();
System.out.println(var1);
b.setA("ahaha");
}
// $FF: synthetic method
public static void main(String[] args) {
main();
}
}
可以看到B类持有Text对象，当调用B.get()方法，内部调用了Text.getValue()，B中创建了KProperty来保存属性的各种参数。
简单的实现属性委托
每次实现委托都要写getValue/setValue方法，相对来说比较麻烦，Kotlin也提供了接口，方便我们重写这些方法，ReadOnlyProperty和ReadWriterProperty
public fun interface ReadOnlyProperty<in T, out V> {
/**
* Returns the value of the property for the given object.
* @param thisRef the object for which the value is requested.
* @param property the metadata for the property.
* @return the property value.
*/
public operator fun getValue(thisRef: T, property: KProperty<*>): V
}
/**
* Base interface that can be used for implementing property delegates of read-write properties.
*
* This is provided only for convenience; you don't have to extend this interface
* as long as your property delegate has methods with the same signatures.
*
* @param T the type of object which owns the delegated property.
* @param V the type of the property value.
*/
public interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V> {
/**
* Returns the value of the property for the given object.
* @param thisRef the object for which the value is requested.
* @param property the metadata for the property.
* @return the property value.
*/
public override operator fun getValue(thisRef: T, property: KProperty<*>): V
/**
* Sets the value of the property for the given object.
* @param thisRef the object for which the value is requested.
* @param property the metadata for the property.
* @param value the value to set.
*/
public operator fun setValue(thisRef: T, property: KProperty<*>, value: V)
}
被委托类只需要实现接口重写方法就行，val继承ReadOnlyProperty
class Text1:ReadOnlyProperty<Any,String>{
override fun getValue(thisRef: Any, property: KProperty<*>): String {
return "属性拥有者 = $thisRef ,属性的名字 = ‘${property.name}’ 属性的值"
}
}
class Text2: ReadWriteProperty<Any,String>{
override fun getValue(thisRef: Any, property: KProperty<*>): String {
return "属性拥有者 = $thisRef ,属性的名字 = ‘${property.name}’ 属性的值"
}
override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {
println("属性的值 = $value 属性的名字 = '${property.name}' 属性拥有者 = $thisRef")
}
}
class B{
val b :String by Text1()
var c : String by Text2()
}
fun main(){
var b = B()
b.c = "1"
}
Kotlin标准库中提供的几个委托
- 延迟属性（lazy properties）:其值只在访问时计算
- 可观察属性（observable properties）:监听器会收到此属性的变更通知
- 把多个属性映射到Map中，而不存在单个字段
延迟属性Lazy
lazy()接收一个lambda，返回Lazy实例，返回的实例可以作为实现延迟属性的委托，仅在第一次调用属性进行初始化
class Lazy{
val name:String by lazy(LazyThreadSafetyMode.SYNCHRONIZED){
println("第一次初始化")
"aa"
}
}
fun main(){
var lazy = Lazy()
println(lazy.name)
println(lazy.name)
}
反编译Java代码
public final class Lazy {
@NotNull
private final kotlin.Lazy name$delegate;
public Lazy() {
this.name$delegate = kotlin.LazyKt.lazy( (Function0)null.INSTANCE);
}
@NotNull
public final String getName() {
kotlin.Lazy var1 = this.name$delegate;
Object var2 = null;
return (String)var1.getValue();
}
}
// LazyKt.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
@Metadata(
mv = {1, 9, 0},
k = 2,
xi = 48,
d1 = {"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
d2 = {"main", "", "app_debug"}
)
public final class LazyKt {
public static final void main() {
Lazy lazy = new Lazy();
String var1 = lazy.getName();
System.out.println(var1);
var1 = lazy.getName();
System.out.println(var1);
}
// $FF: synthetic method
public static void main(String[] args) {
main();
}
}
发现Lazy再初始化时生成了name $ delegate，变量是Kotlin.Lazy类型的，而getName()方法返回的其实就是name $ delegate.getValue()
name $ delegate是由kotlin.LazyKt.lazy (Function0)null.INSTANCE);生成的，可以看一下源码
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
最终是由SynchronizedLazyImpl生成
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)
}
可以直接看value的get方法，如果_v1 !== UNINITIALIZED_VALUE则表明已经初始化过了，就直接返回value，否则表明没有初始化过，调用initializer方法，也就是lazy的lambda表达式
Lazy委托参数
public enum class LazyThreadSafetyMode {
/**
* Locks are used to ensure that only a single thread can initialize the [Lazy] instance.
*/
SYNCHRONIZED,
/**
* Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value,
* but only the first returned value will be used as the value of [Lazy] instance.
*/
PUBLICATION,
/**
* No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
*
* This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
*/
NONE,
}
- SYNCHRONIZED:添加同步锁，使lazy延迟初始化线程安全
- PUBLICATION：初始化的lambda表达式，可以在同一时间多次调用，但是只有第一次的返回值作为初始化值
- NONE：没有同步锁，非线程安全
使用
val name :String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
println("第一次调用初始化")
"aa" }
}
可观察属性Observable委托
可以观察一个属性的变化过程
class Observable {
var a:String by Delegates.observable("默认值"){
property, oldValue, newValue ->
println("${oldValue} -> ${newValue}")
}
}
fun main(){
var observable = Observable()
observable.a = "第一次修改的值"
observable.a = "第二次修改的值"
}
vetoable委托
vetoable和Observable一样，可以观察属性的变化，不同的是vetoable可以决定是否使用新值
class Vetoable {
var age:Int by Delegates.vetoable(0){
property, oldValue, newValue ->
println("oldValue = $oldValue -> oldValue = $newValue" )
newValue > oldValue
}
}
fun main() {
var c = Vetoable()
c.age = 5
println(c.age)
c.age = 10
println(c.age)
c.age = 8
println(c.age)
c.age = 20
println(c.age)
}
可以看到，当新值小于旧值，就会不生效
属性储存在Map中
class D(val map:Map<String,Any?>){
val name:String by map
val age:Int by map
}
fun main() {
var d = D(
mapOf(
"name" to "小明",
"age" to 12
)
)
println("name = ${d.name},age = ${d.age}")
}
实践方式
双击back退出
private var backPressedTime by Delegates.observable(0L){pre,old,new ->
//2次的时间间隔小于2秒就退出了
if(new - old < 2000){
finish()
}else{
Toast.makeText(this,"再按返回键退出",Toast.LENGTH_LONG)
}
}
override fun onBackPressed() {
super.onBackPressed()
backPressedTime = System.currentTimeMillis()
}
Fragment/Activity传参
在项目中经常需要给Fragment/Activity传递参数
模版代码
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
class DelegateFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_delegate, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment DelegateFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
DelegateFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
}
我们可以把参数赋值和获取的代码抽取委托类，然后把param1和param2声明为委托属性
修改后的Fragment代码
class DelegateFragment : Fragment() {
private var param1: String? by argumentNullable()
private var param2: String by argument("1")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
Log.d("DelegateFragment","param1 ${param1} param2 ${param2}")
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_delegate, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment DelegateFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
DelegateFragment().apply {
this.param1 = param1
this.param2 = param2
}
}
}
委托类
import android.os.Bundle
import android.os.Parcelable
import android.util.Log
import androidx.fragment.app.Fragment
import java.io.Serializable
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
fun <T> Fragment.argumentNullable() = FragmentArgumentPropertyNullable<T>()
fun <T> Fragment.argument(defaultValue:T? = null) = FragmentArgumentProperty<T>(defaultValue)
class FragmentArgumentPropertyNullable<T> : ReadWriteProperty<Fragment,T?>{
override fun getValue(thisRef: Fragment, property: KProperty<*>): T? {
return thisRef.arguments?.getValue(property.name)
}
override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T?) {
Log.d("DelegateFragment","property.name ${property.name} thisRef.arguments ${thisRef.arguments}")
val arguments = thisRef.arguments?:Bundle().also {
thisRef.arguments = it
}
if(arguments.containsKey(property.name)){
return
}
arguments[property.name] = value
}
}
class FragmentArgumentProperty<T> (private val defaultValue: T? = null): ReadWriteProperty<Fragment,T>{
override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
return thisRef.arguments?.getValue(property.name) as? T
?:defaultValue
?:throw IllegalStateException("Property ${property.name} could not be read")
}
override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T) {
val arguments = thisRef.arguments?:Bundle().also {
thisRef.arguments = it
}
if(arguments.containsKey(property.name)){
return
}
arguments[property.name] = value
}
}
fun <T> Bundle.getValue(key:String):T?{
return get(key) as T?
}
//操作符重载a[i] = b set() a.set(i, b)
operator fun <T> Bundle.set(key: String, value: T?) {
when (value) {
is Boolean -> putBoolean(key, value)
is Byte -> putByte(key, value)
is Char -> putChar(key, value)
is Short -> putShort(key, value)
is Int -> putInt(key, value)
is Long -> putLong(key, value)
is Float -> putFloat(key, value)
is Double -> putDouble(key, value)
is String? -> putString(key, value)
is CharSequence? -> putCharSequence(key, value)
is Serializable? -> putSerializable(key, value) // also ArrayList
is Parcelable? -> putParcelable(key, value)
is Bundle? -> putBundle(key, value)
is BooleanArray? -> putBooleanArray(key, value)
is ByteArray? -> putByteArray(key, value)
is CharArray? -> putCharArray(key, value)
is ShortArray? -> putShortArray(key, value)
is IntArray? -> putIntArray(key, value)
is LongArray? -> putLongArray(key, value)
is FloatArray? -> putFloatArray(key, value)
is DoubleArray? -> putDoubleArray(key, value)
is ArrayList<*>? -> throw IllegalStateException("ArrayList<*> $key is not supported")
is Array<*>? -> throw IllegalStateException("Array<*> $key is not supported")
else -> throw IllegalStateException("Type $key is not supported")
}
}
相比于常规的写法，使用属性委托优势会相对明显，不需要定义Key字符串，而是使用变量名作为Key。不再需要编写向Argument设置参数和读取参数的代码，声明可空参数时也可以声明默认值。
ViewBinding和委托
在Fragment中使用
class DelegateFragment : Fragment(R.layout.fragment_delegate) {
private var _binding: FragmentDelegateBinding? = null
private val binding get() = _binding!!
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
_binding = FragmentDelegateBinding.bind(view)
binding.tvName.text = "This is Hello World"
}
override fun onDestroyView() {
super.onDestroyView()
//置空，防止内存泄漏
_binding = null
}
}
ViewBinding绑定类的源码，反编译如下：
public final class FragmentDelegateBinding implements ViewBinding {
private final ConstraintLayout rootView;
public final TextView tvDisplay;
private FragmentDelegateBinding(ConstraintLayout paramConstraintLayout1, TextView paramTextView)
this.rootView = paramConstraintLayout1;
this.tvDisplay = paramTextView;
}
public static FragmentDelegateBindingbind(View paramView) {
TextView localTextView = (TextView)paramView.findViewById(2131165363);
if (localTextView != null) {
return new ActivityMainBinding((ConstraintLayout)paramView, localTextView);
}else {
paramView = "tvDisplay";
}
throw new NullPointerException("Missing required view with ID: ".concat(paramView));
}
public static FragmentDelegateBinding inflate(LayoutInflater paramLayoutInflater) {
return inflate(paramLayoutInflater, null, false);
}
public static FragmentDelegateBinding inflate(LayoutInflater paramLayoutInflater, ViewGroup paramViewGroup, boolean paramBoolean) {
paramLayoutInflater = paramLayoutInflater.inflate(2131361821, paramViewGroup, false);
if (paramBoolean) {
paramViewGroup.addView(paramLayoutInflater);
}
return bind(paramLayoutInflater);
}
public ConstraintLayout getRoot() {
return this.rootView;
}
}
通过委托的方式进行优化
- 委托ViewBinding.bind()的调用 -> 反射
- 委托destroy时binding = null的调用 -> 监听Fragment视图生命周期
- 想要binding属性声明为非空不可变变量val -> 属性委托ReadOnlyProperty<F,V>
编写委托类，详细内容可看注释
package com.example.memoryoptimizing.delegate
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.view.View
import androidx.fragment.app.Fragment
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.LifecycleOwner
import androidx.viewbinding.ViewBinding
import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty
//为什么使用inline fun<reified V>，方便直接拿到V::class.java
/**
* fun <V> printClass() {
* println(V::class.java) // ❌ 编译错误：Cannot access 'java.lang.Class' for a type parameter V
* }
* inline fun <reified V> printClass() {
* println(V::class.java) // ✅ 输出如：class kotlin.String
* }
*/
//在属性委托中，编译器可以通过属性声明的类型,如 FragmentDelegateBinding）来推断泛型函数中的具体类型参数；
// 而在普通函数调用中，仅凭返回值或赋值目标无法反推出泛型参数的具体类型。
/**
✅ 场景一：属性委托 + reified 泛型函数 ✅ 可以推断
private val binding: FragmentDelegateBinding by viewBindingV1()
❌ 场景二：普通函数调用 ❌ 无法推断
inline fun <reified V> getTypeName(): String {
return V::class.java.name
}
val name: String = getTypeName()
*/
private const val TAG = "ViewBindingProperty"
//使用inline fun <reified V>可以在调用泛型函数时省略参数的传递，Kotlin会自动根据泛型类型帮你找到对应的class<T>
public inline fun <reified V:ViewBinding> viewBindingV1() = viewBindingV1(V::class.java)
public inline fun <reified T:ViewBinding> viewBindingV1(clazz:Class<T>):FragmentViewBindingProperttV1<Fragment,T>{
val bindMethod = clazz.getMethod("bind", View::class.java)
return FragmentViewBindingProperttV1{ fragment->
/**
* 调用静态方法bind(View view)，第一个参数为null(因为是静态方法) 第二个参数是View，来自Fragment的requireView()
* as T 将结果强制转换为泛型T，即具体的ViewBinding子类(如FragmentDelegateBinding)
* FragmentDelegateBinding.bind(Fragment.requireView())
*/
bindMethod.invoke(null,fragment.requireView()) as T
}
}
/**
* viewBinder 创建绑定类对象
*/
class FragmentViewBindingProperttV1<in F:Fragment,out V: ViewBinding>(
private val viewBinder:(F) ->V //给定一个 Fragment（或其子类），返回一个对应的 ViewBinding 实例
):ReadOnlyProperty<F,V>{
private var viewBinding:V? = null
override fun getValue(thisRef: F, property: KProperty<*>): V {
//viewBinding不为空说明已经绑定，直接返回
viewBinding?.let {
return it
}
//Fragment视图的生命周期
val lifecycle = thisRef.viewLifecycleOwner.lifecycle
//实例化绑定类对象
val viewBinding = viewBinder(thisRef)
if(lifecycle.currentState == Lifecycle.State.DESTROYED){
Log.w(
TAG, "Access to viewBinding after Lifecycle is destroyed or hasn't created yet. " +
"The instance of viewBinding will be not cached."
)
}else{
lifecycle.addObserver(ClearOnDestroyLifecycleObserver())
this.viewBinding = viewBinding
}
return viewBinding
}
fun clear(){
viewBinding = null
}
private inner class ClearOnDestroyLifecycleObserver : LifecycleObserver{
private val mainHandler = Handler(Looper.getMainLooper())
fun onDestroy(owner:LifecycleOwner){
owner.lifecycle.removeObserver(this)
mainHandler.post {
clear()
}
}
}
}
使用例子：
class DelegateFragment : Fragment(R.layout.fragment_delegate) {
private val binding : FragmentDelegateBinding by viewBindingV1()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.tvName.text = "This is Hello World"
}
}
不使用反射的方式，反射调用bind函数的主要目的是获得一个ViewBinding绑定类对象，我们可以把创建对象的行为交给外部去定义
inline fun <F:Fragment,V:ViewBinding> viewBindingV2(
crossinline viewBinder:(View) -> V,//接受一个View，返回Binding实例
crossinline viewProvider:(F) -> View = {
fragment -> fragment.requireView() //这里的fragment就是F
} //接受一个Fragment，返回它的View
) = FragmentViewBindingPropertyV2{ fragment:F ->
viewBinder(viewProvider(fragment)) //FragmentDelegateBinding.bind(Fragment.requireView())
}//fragment它是 Kotlin 属性委托机制在访问 binding 属性时自动传入的当前 Fragment 实例
class FragmentViewBindingPropertyV2<in F:Fragment , out V: ViewBinding>(
private val viewBinder:(F) -> V
):ReadOnlyProperty<F,V>{
private var viewBinding: V? = null
override fun getValue(thisRef: F, property: KProperty<*>): V {
//viewBinding不为空说明已经绑定，直接返回
viewBinding?.let {
return it
}
//Fragment视图的生命周期
val lifecycle = thisRef.viewLifecycleOwner.lifecycle
//实例化绑定类对象
val viewBinding = viewBinder(thisRef)
if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
Log.w(
TAG, "Access to viewBinding after Lifecycle is destroyed or hasn't created yet. " +
"The instance of viewBinding will be not cached."
)
} else {
lifecycle.addObserver(ClearOnDestroyLifecycleObserver())
this.viewBinding = viewBinding
}
return viewBinding
}
fun clear() {
viewBinding = null
}
private inner class ClearOnDestroyLifecycleObserver : LifecycleObserver {
private val mainHandler = Handler(Looper.getMainLooper())
fun onDestroy(owner: LifecycleOwner) {
owner.lifecycle.removeObserver(this)
mainHandler.post {
clear()
}
}
}
}
使用方式
class DelegateFragment : Fragment(R.layout.fragment_delegate) {
private val binding : FragmentDelegateBinding by viewBindingV2(FragmentDelegateBinding::bind)
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.tvName.text = "This is Hello World"
}
}