不仅类可以使用委托，属性也可以使用委托，本章节我们介绍委托属性及其实现原理

1、语法

语法如下：
var/val propertyName [:Type] by express
propertyName：属性名称
Type：如果可以从express中推导出类型，则可以省略，否则不能省略
by后面的express：表达式，表示属性的get和set委托给表达式实现

2、属性委托给类实现及其原理

此种方式是将属性的get和set的实现委托给一个类的getValue和setValue实现，例子如下所示：

class TDelegateProperty {
    var deleProperty: Int by Delegate()  //deleProperty委托给Delegate类实现get和set
}
class Delegate {
    //thisRef指属性所属的类实例对象，本实例是TDelegateProperty 类的实例对象
    //property是属性反射对象，可以通过范围属性名称、属性类型等
    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int {
        println("$thisRef, delegate ${property.name} to get val")
        return 10
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
        println("$thisRef, delegate ${property.name} to set val with $value")
    }
}

在调用deleProperty时实际上是委托给Delegate 对象的getValue或者setValue方法。
我们从字节码上分析其实现原理：

public final class com/java/test/kt/delegate/TDelegateProperty {

  // compiled from: TDelegateProperty.kt
  //省略......

  //生成并声明静态数组属性：KProperty[] delegatedProperties
  // access flags 0x1018
  final static synthetic [Lkotlin/reflect/KProperty; $$delegatedProperties
  
  //生成并声明属性：Delegate deleProperty$delegate
  // access flags 0x12
  private final Lcom/java/test/kt/delegate/Delegate; deleProperty$delegate
  @Lorg/jetbrains/annotations/NotNull;() // invisible
  
  // access flags 0x8
  static <clinit>()V
    //类加载时的初始化函数
    //将常量1载入栈顶
    ICONST_1
    //创建KProperty数组，长度为1，并将生成的数组引用入栈顶。它用来存放委托属性的信息
    ANEWARRAY kotlin/reflect/KProperty
    //复制栈顶即KProperty数组的引用，并在入栈顶
    DUP
    //将常量0载入栈顶
    ICONST_0
    //创建MutablePropertyReference1Impl对象，并将引用入栈顶
    NEW kotlin/jvm/internal/MutablePropertyReference1Impl
    //复制栈顶即MutablePropertyReference1Impl引用，并在入栈顶
    DUP
    //从常量池中载入TDelegateProperty.class进入栈顶
    LDC Lcom/java/test/kt/delegate/TDelegateProperty;.class
    //调用静态反射方法getOrCreateKotlinClass 获取TDelegateProperty的class对象
    INVOKESTATIC kotlin/jvm/internal/Reflection.getOrCreateKotlinClass (Ljava/lang/Class;)Lkotlin/reflect/KClass;
    LDC "deleProperty" //从常量池中载入常量字符串"deleProperty"，放入栈顶
    LDC "getDeleProperty()I" //从常量池中载入常量字符串"getDeleProperty()I"，放入栈顶
    //调用MutablePropertyReference1Impl的init方法，参数分别为：TDelegateProperty的class对象
、deleProperty字符串、getDeleProperty()I字符串
    INVOKESPECIAL kotlin/jvm/internal/MutablePropertyReference1Impl.<init> (Lkotlin/reflect/KDeclarationContainer;Ljava/lang/String;Ljava/lang/String;)V
    //调用Reflection.mutableProperty1 方法，参数为创建的MutablePropertyReference1Impl对象，实际上返回的是它本身
    INVOKESTATIC kotlin/jvm/internal/Reflection.mutableProperty1 (Lkotlin/jvm/internal/MutablePropertyReference1;)Lkotlin/reflect/KMutableProperty1;
    CHECKCAST kotlin/reflect/KProperty
    //将创建的MutablePropertyReference1Impl放入KProperty数组中
    AASTORE
    //将创建的KProperty数组赋值给成员变量$$delegatedProperties
    PUTSTATIC com/java/test/kt/delegate/TDelegateProperty.$$delegatedProperties : [Lkotlin/reflect/KProperty;
    RETURN
    //省略......

  // access flags 0x11
  //获取属性的值的方法
  public final getDeleProperty()I
   L0
    //将第1个局部变量即this载入栈顶
    ALOAD 0
    //使用栈顶即this获取属性deleProperty$delegate,它是Delegate类的实例对象，并放入栈顶
    GETFIELD com/java/test/kt/delegate/TDelegateProperty.deleProperty$delegate : Lcom/java/test/kt/delegate/Delegate;
    //将第1个局部变量即this载入栈顶
    ALOAD 0
    //使用栈顶即this获取$$delegatedProperties属性，并放入栈顶
    GETSTATIC com/java/test/kt/delegate/TDelegateProperty.$$delegatedProperties : [Lkotlin/reflect/KProperty;
    //将常量0载入栈顶
    ICONST_0
    //从数组$$delegatedProperties中获取下标为0 的值，即delegatedProperty的属性对象
    AALOAD
    //调用Delegate实例对象的getValue方法，参数分别是：this，delegatedProperty的属性对象，并将返回值入栈顶
    INVOKEVIRTUAL com/java/test/kt/delegate/Delegate.getValue (Ljava/lang/Object;Lkotlin/reflect/KProperty;)I
    IRETURN //返回栈顶的值，即Delegate.getValue的值
   //省略......

  // access flags 0x11
  //设置属性的方法
  public final setDeleProperty(I)V
   L0
    ALOAD 0 //将第1个局部变量即this载入栈顶
    //使用栈顶即this获取属性deleProperty$delegate,它是Delegate类的实例对象，并放入栈顶
    GETFIELD com/java/test/kt/delegate/TDelegateProperty.deleProperty$delegate : Lcom/java/test/kt/delegate/Delegate;
    ALOAD 0 //将第1个局部变量即this载入栈顶
    //使用栈顶即this获取$$delegatedProperties属性，并放入栈顶
    GETSTATIC com/java/test/kt/delegate/TDelegateProperty.$$delegatedProperties : [Lkotlin/reflect/KProperty;
     //将常量0载入栈顶
    ICONST_0
    //从数组$$delegatedProperties中获取下标为0 的值，即delegatedProperty的属性对象
    AALOAD
    //将常量1载入栈顶
    ILOAD 1
    //调用deleProperty$delegate即Delegate.setValue 设置属性值，参数分别是：this、delegatedProperty的属性对象、要设置的值
    INVOKEVIRTUAL com/java/test/kt/delegate/Delegate.setValue (Ljava/lang/Object;Lkotlin/reflect/KProperty;I)V
    RETURN
   //省略......

  // access flags 0x1
  //自动生成的实例对象初始化函数
  public <init>()V
   L0
    LINENUMBER 5 L0
    ALOAD 0 //将第1个局部变量即this载入栈顶
    //调用父类Object的init方法
    INVOKESPECIAL java/lang/Object.<init> ()V
   L1
    LINENUMBER 6 L1
    ALOAD 0 //将第1个局部变量即this载入栈顶
    //创建Delegate实例对象，并载入栈顶
    NEW com/java/test/kt/delegate/Delegate
    DUP //复制栈顶即Delegate对象的引用并再次放入栈顶
    //调用栈顶即Delegate对象的init方法
    INVOKESPECIAL com/java/test/kt/delegate/Delegate.<init> ()V
    //将Delegate对象赋值给成员变量deleProperty$delegate
    PUTFIELD com/java/test/kt/delegate/TDelegateProperty.deleProperty$delegate : Lcom/java/test/kt/delegate/Delegate;
    RETURN
  //省略......
}

属性委托给类实现的原理可以可以概括为：
编译之后自动生成委托的实现代码，包括：

• 自动为属性生成静态属性对象数组——它用来存储被委托的属性的属性对象KProperty。它在类加载对类对象初始化时cinit方法中创建并赋值。为什么是生成的是静态属性对象数组？因为这属性对象中的信息是不变的部分，在类加载时进行赋值并存储在静态变量中，可以避免多个实例对象都创建，提高性能；其次用数组的原因是属性委托可能不止一个。
• 自动生成属性的委托对象Delegate，类型是委托类Delegate，在类的实例对象初始化init函数中创建并赋值
• 自动生成属性的get/set方法，内部的实现是委托给委托对象Delegate相应的方法getValue/setValue

3、属性委托给其他属性实现及其原理

属性出了可以委托给其他类之前，还可以委托给其他属性（kotlin1.4+之后才支持）。
我们举了例子：

class DelegateByOhterProperty {
    var newVal : Int = 10
    var oldVal by this::newVal
}
val d = DelegateByOhterProperty()
println("ff", "oldValue = ${d.oldVal}")
d.oldVal = 20
println("ff", "newValue = ${d.newVal}")

上述例子将oldVal 属性委托给newVal实现get/set，对oldVal的取值其实就是取newVal的值，对oldVal 的赋值其实就是对newVal的赋值，所以打印的结果分别是：oldValue = 10 、newValue = 20
我们看下编译之后DelegateByOhterProperty类的class文件：

public final class com/wyx/tcanvas/test/delegate/DelegateByOhterProperty {

  // compiled from: DelegateByOhterProperty.kt
  //省略......
  // access flags 0x1000
  //内部类DelegateByOhterProperty$oldVal$2，其实现了KMutableProperty0接口
  synthetic INNERCLASS com/wyx/tcanvas/test/delegate/DelegateByOhterProperty$oldVal$2 null null

  // access flags 0x2
  //声明属性newVal
  private I newVal

  // access flags 0x12
 //声明oldVal的委托对象，类型为KMutableProperty0
  private final Lkotlin/reflect/KMutableProperty0; oldVal$delegate
  @Lorg/jetbrains/annotations/NotNull;() // invisible

  // access flags 0x1
  //实例对象初始化函数
  public <init>()V
   L0
    LINENUMBER 3 L0
    ALOAD 0
    //调用父类Object的init方法
    INVOKESPECIAL java/lang/Object.<init> ()V
   L1
    LINENUMBER 4 L1
    ALOAD 0
    BIPUSH 10
    //给newVal赋予初值10
    PUTFIELD com/wyx/tcanvas/test/delegate/DelegateByOhterProperty.newVal : I
   L2
    LINENUMBER 5 L2
    ALOAD 0
    //创建委托类DelegateByOhterProperty$oldVal$2的实例对象对象，参数为this
    NEW com/wyx/tcanvas/test/delegate/DelegateByOhterProperty$oldVal$2
    DUP
    ALOAD 0
    INVOKESPECIAL com/wyx/tcanvas/test/delegate/DelegateByOhterProperty$oldVal$2.<init> (Ljava/lang/Object;)V
    CHECKCAST kotlin/reflect/KMutableProperty0
    //将创建的实例对象赋值给委托对象oldVal$delegate 
    PUTFIELD com/wyx/tcanvas/test/delegate/DelegateByOhterProperty.oldVal$delegate : Lkotlin/reflect/KMutableProperty0;
   //省略......

  // access flags 0x11
  // 自动生成newVal的取值函数
  public final getNewVal()I
   L0
    LINENUMBER 4 L0
    ALOAD 0
    GETFIELD com/wyx/tcanvas/test/delegate/DelegateByOhterProperty.newVal : I
    //读取this.newVal的值，并放入栈顶返回
    IRETURN
   //省略......

  // access flags 0x11
  //自动生成newVal的赋值函数setNewVal
  public final setNewVal(I)V
   L0
    LINENUMBER 4 L0
    ALOAD 0
    ILOAD 1
    //给this.newVal 赋值为setNewVal方法的参数
    PUTFIELD com/wyx/tcanvas/test/delegate/DelegateByOhterProperty.newVal : I
    RETURN
   //省略......

  // access flags 0x11
   //自动生成oldVal的取值函数
  public final getOldVal()I
   L0
    LINENUMBER 5 L0
    ALOAD 0
    //载入this.oldVal$delegate即oldVal的委托对象放到栈顶
    GETFIELD com/wyx/tcanvas/test/delegate/DelegateByOhterProperty.oldVal$delegate : Lkotlin/reflect/KMutableProperty0;
    //省略......
    //调用委托对象this.oldVal$delegate的get方法，返回的是Object实际上是newVal的值
    INVOKEINTERFACE kotlin/reflect/KProperty0.get ()Ljava/lang/Object; (itf)
    CHECKCAST java/lang/Number //校验是否是Number类型
    INVOKEVIRTUAL java/lang/Number.intValue ()I   //转为int类型并放入栈顶
   L1
    LINENUMBER 5 L1
    IRETURN //返回栈顶的值即newVal的值
   //省略......

  // access flags 0x11
  //自动生成oldVal的赋值函数
  public final setOldVal(I)V
   L0
    LINENUMBER 5 L0
    ALOAD 0
    //将this.oldVal$delegate 即oldVal的委托对象放到栈顶
    GETFIELD com/wyx/tcanvas/test/delegate/DelegateByOhterProperty.oldVal$delegate : Lkotlin/reflect/KMutableProperty0;
     //省略......
    ILOAD 1 //载入第2个局部变量即方法的参数
    //将int包装为Integer对象
    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
    //调用this.oldVal$delegate的set方法，参数为setOldVal的参数，将值赋值给newVal
    INVOKEINTERFACE kotlin/reflect/KMutableProperty0.set (Ljava/lang/Object;)V (itf)
   L1
    LINENUMBER 5 L1
    RETURN
   //省略......
}

上面的class字节码经过jd-gui工具反编译之后，等价于下面的java代码：

public final class DelegateByOhterProperty {
  private int newVal = 10;
  
  public final int getNewVal() {
    return this.newVal;
  }
  
  public final void setNewVal(int <set-?>) {
    this.newVal = <set-?>;
  }
  
  @NotNull
  private final KMutableProperty0 oldVal$delegate = (KMutableProperty0)new DelegateByOhterProperty$oldVal$2(this);
  
  public final int getOldVal() {
    KProperty0 kProperty0 = (KProperty0)this.oldVal$delegate;
    Object object = null;
    boolean bool = false;
    return ((Number)kProperty0.get()).intValue();
  }
  
  public final void setOldVal(int <set-?>) {
    KMutableProperty0 kMutableProperty0 = this.oldVal$delegate;
    Object object = null;
    Integer integer = Integer.valueOf(<set-?>);
    boolean bool = false;
    kMutableProperty0.set(integer);
  }
}

委托类DelegateByOhterProperty2并没有看到其具体实现代码，但是通过其创建时传递this、使用时分别调用get和set方法，我们可以猜测DelegateByOhterProperty2的大致实现如下(具体是否待考证)所示：

class DelegateByOhterProperty$oldVal$2 implement KMutableProperty0 {
    DelegateByOhterProperty  targetObj;
    public init(DelegateByOhterProperty targetObj) {
        this.targetObj = targetObj;
    }

    override public int get() {
        return this.targetObj.newVal;
    }

    override public void set(int val) {
        this.targetObj.newVal = val;
    }
}

根据对字节码class文件的分析，属性委托的实现原理我们可以得出如下结论：

• 会自动创建一个内部的委托类
• 在类实例初始化init时创建委托类实例对象，并赋值给委托对象
• 被委托的属性如oldVal是不存在的，但会自动生成被委托对象的get和set函数
• 被委托对象的get和set函数内部其实就是调用委托对象的get和set函数，委托对象的get和set函数内部委托给真正的委托对象实现（如上面的newVal）

4、总结

不论属性委托给类还是其他属性实现，最终都是需要依赖额外的委托类，借此委托类的实例对象的get/set实现委托取值/赋值。不仅增加了一个委托类，而且还还在初始化时就创建了委托类的实例对象，算起来其实性能并不好。
不要滥用属性的委托特性，特别是对基本类型，属性委托的使用场景建议：

• 非基本类型，且当前类型的实例化较为耗资源且可以依靠当前现存的对象完成
• 非基本类型，对象实例化较为耗资源，且并不需要立即使用在时候时再进行初始化——场景的懒加载lazy语法