[아이템 21] 델리게이터 사용 예시

[NDjust]

p.129 코틀린 stdlib 에서 다음과 같은 프로퍼티 렐리게이터를 알아 두면 좋습니다.

질문 :
책에서 나오는 아래 프로퍼티 델리게이터 패턴에 대한 예시와 어떻게 동작하는지 설명해주시면 좋을 거 같습니다.

• lazy
• Delegates.observable
• Delegates.vetoable
• Delegates.notNull

[Gobukgol]

observable과 vetoable을 먼저 보면 좋을 것 같아.
observable과 vetoable은 간단하게 프로퍼티의 변화를 감지하고 정의한 동작을 한다. 라 볼 수 있는데 vetoable의 경우 정의한 동작에 boolean 타입의 반환값이 존재해.
vetoable의 경우 반환된 boolean의 값이 true 일 경우에만 최종적으로 프로퍼티의 값을 변경시켜.

class DelegatesExample {
 var observable : Int by Delegates.observable(0) { _, oldValue, newValue ->
 println("oldValue = $oldValue, newValue = $newValue ")
 }

 var vetoable : Int by Delegates.vetoable(0) { _, oldValue, newValue ->
 println("oldValue = $oldValue, newValue = $newValue ")
 oldValue < newValue
 }

 fun observableFunc() {
 println("observable delegates")
 println("observable = $observable")
 observable = -1
 println("observable = $observable")
 }

 fun vetoableFunc() {
 println("vetoable delegates")
 println("vetoable = $vetoable")
 vetoable = -1
 println("vetoable = $vetoable")
 vetoable = 1
 println("vetoable = $vetoable")
 }
...
}

fun main() {
 val delegates = DelegatesExample()
...
 delegates.observableFunc()
 delegates.vetoableFunc()
...
}

이 코드의 결과는 아래와 같아

다음으로 lazy와 Delegates.notNull을 보면 좋을 것 같아.
lazy와 Delegates.notNull에 대해 얘기하기전에 lateinit 의 특징에 대해서 간단하게 보고 넘어가자면

• 선언은 해두고 나중에 초기화하여 사용
• var 에만 붙일 수 있다. 즉 초기화 후에 변경이 가능하다
• primitive 타입에는 사용 불가
• nullable 할 수 없다. lateinit var a : String? 불가
• 초기화하지 않고 사용시 exception 발생

class Socks {
 lateinit var size: Size

 fun init(size: Int) {
 this.size = Size(size)
 }
}

class Size(val size: Int)

위 코드는 아래와 같이 컴파일 돼.

public final class Socks {
 public Size size;

 @NotNull
 public final Size getSize() {
 Size var10000 = this.size;
 if (var10000 == null) {
 Intrinsics.throwUninitializedPropertyAccessException("size");
 }

 return var10000;
 }

 public final void setSize(@NotNull Size var1) {
 Intrinsics.checkNotNullParameter(var1, "<set-?>");
 this.size = var1;
 }

 public final void init(int size) {
 this.size = new Size(size);
 }
}

코드를 보면 생성할 때 Size 클래스는 null로 초기화 되어있고, getSize를 할 때 null 체크를 하는걸 알 수 있어. null로 초기화해야하기 때문에 primitive 타입은 사용할 수 없고, 값을 가져올 때마다 null 체크 후 exception을 던지기 때문에 nullable 타입에는 사용할 수 없는거지

다음으로 lateinit과 비교했을때 lazy의 특징은 아래와 같아.

• 선언할 때 초기화 코드를 작성해야함
• primitive 타입 사용 가능
• val 에 사용
• nullable 타입도 사용 가능

아래와 같은 코드가 있을 때 자바로 컴파일 해보면

class LazyValue {
 val size: Int by lazy {
 println("hi! lazy")
 1000
 }
}

public final class LazyValue {
 @NotNull
 private final Lazy size$delegate;

 public final int getSize() {
 Lazy var1 = this.size$delegate;
 Object var3 = null;
 return ((Number)var1.getValue()).intValue();
 }

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

다음으로 Delegates.notNull의 특징을 보면

• primitive 타입도 사용 가능
• 초기화 전에 사용하면 exception 발생
• null을 할당할 수 없다

아래와 같은 코드가 있을 때 자바로 컴파일 해보면

class DelegatesNotNull {
 var size: Int by Delegates.notNull()

 fun init() {
 println(size)
 }
}

public final class DelegatesNotNull {
 // $FF: synthetic field
 static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(DelegatesNotNull.class, "size", "getSize()I", 0))};
 @NotNull
 private final ReadWriteProperty size$delegate;

 public final int getSize() {
 return ((Number)this.size$delegate.getValue(this, $$delegatedProperties[0])).intValue();
 }

 public final void setSize(int var1) {
 this.size$delegate.setValue(this, $$delegatedProperties[0], var1);
 }

 public final void init() {
 int var1 = this.getSize();
 System.out.println(var1);
 }

 public DelegatesNotNull() {
 this.size$delegate = Delegates.INSTANCE.notNull();
 }
}

lazy와 Delegates.notNull의 경우 lateinit 과 다르게 Lazy 또는 ReadWriteProperty로 한번 wrapping하고 사용하기 때문에 primitive 타입도 사용 가능한 것을 확인할 수 있어.