Koin (Scopes)

Koin은 limit lifetime에 연결된 인스턴스를 정의할 수 있는 간단한 API를 제공합니다.

What is a scope?

Scope는 객체가 존재하는 고정된 기간 또는 메서드 호출입니다.

Scope는 동일한 객체의 상태가 지속되는 시간으로 생각하는 것.

 

Scope Context가 종료되면 해당 Scope 아래에 바인딩된 객체를 다시 주입할 수 없습니다(컨테이너에서 삭제됨)

Scope definition

기본적으로 Koin에는 3가지 종류의 Scope가 있습니다.

 

single, 전체 컨테이너 수명 동안 지속되는 개체를 만듭니다(삭제할 수 없음).
factory  매번 새로운 객체를 생성합니다. 짧은 라이브. 컨테이너에 지속성이 없습니다(공유할 수 없음)
scoped  연결된 scoped 수명에 영구적으로 연결된 개체를 만듭니다.

 

scope 정의를 선언하려면 다음과 같은 scope 함수를 사용하십시오.

scoped는  scoped definition를 논리적 시간 단위로 수집합니다.

 

주어진 유형에 대한 scope를 선언하려면 scope 키워드를 사용해야 합니다.

module {
    scope<MyType>{
        scoped { Presenter() }
        // ...
    }
}

Scope Id & Scope Name

scope 정의됩니다.

- scope name - scope의 한정자

- scope id - scope 인스턴스의 고유 식별자

 

* scope<A> { } 는 scope(named<A>()){ } 와 동일하지만 쓰기가 더 편리합니다.

 문자열 한정자(scope(named("SCOPE_NAME")) { } )를 사용할 수도 있습니다.

 

Koin instance

 

createScope(id : ScopeID, scopeName : Qualifier) - 주어진 id와 scopeName으로 닫힌 scope 인스턴스를 생성합니다.

getScope(id : ScopeID) - 주어진 ID로 이전에 생성된 scope를 검색합니다.

getOrCreateScope(id : ScopeID, scopeName : Qualifier) - 이미 생성된 경우 지정된 id 및 scopeName을 가진 닫힌 scope 인스턴스를 생성하거나 검색

 

Scope Component: Associate a scope to a component [2.2.0 이상]

Koin은 클래스에  scope instance 를 가져오는 데 도움이 되는 KoinScopeComponent 개념을 가지고 있습니다.

class A : KoinScopeComponent {
    override val scope: Scope by lazy { createScope(this) }
}

class B

KoinScopeComponent 인터페이스는 다음과 같은 몇 가지 extention function을 제공합니다.

 

현재 component Scope ID 및 name에서 scope를 생성하는 createScope

get, injection - 범위에서 인스턴스를 해결하기 위해(scope.get() 및 scope.inject()와 동일)

 

class B를 위해 A의 scope를 정의합시다

module {
scope<A> {
		scoped { B() } // Tied to A's scope
	}
}

org.koin.core.scope get 및 injection  extention 덕분에 B 인스턴스를 직접 resolve할 수 있습니다.

class A : KoinScopeComponent {
    override val scope: Scope by lazy { newScope(this) }

    // resolve B as inject
    val b : B by inject() // inject from scope

    // Resolve B
    fun doSomething(){
        val b = get<B>()
    }

    fun close(){
        scope.close() // don't forget to close current scope
    }
}

 

Resolving dependencies within a scope

scope의 get 및 injection function을 사용하여 종속성을 해결 하기.

val Presenter = scope.get<Presenter>()

 

scope의 관심은 scope 정의에 대한 공통 논리적 시간 단위를 정의하는 것입니다.

주어진 scope 내에서 정의를 해결할 수도 있습니다.

// given the classes
class ComponentA
class ComponentB(val a : ComponentA)

// module with scope
module {
    
    scope<A> {
        scoped { ComponentA() }
        // will resolve from current scope instance
        scoped { ComponentB(get()) }
    }

// create scope
val myScope = koin.createScope<A>()

// from the same scope
val componentA = myScope.get<ComponentA>()
val componentB = myScope.get<ComponentB>()

기본적으로 현재 범위에서 정의를 찾을 수 없는 경우 기본 범위에서 해결하기 위한 모든 범위 대체

Close a scope

scope 인스턴스가를 다 사용하고 나면, close() 함수로 닫습니다.

// from a KoinComponent
val scope = getKoin().createScope<A>()

// use it ...

// close it
scope.close()

Closed Scope에서 더 이상 인스턴스를 주입할 수 없습니다.

 

Getting scope's source value

 

2.1.4의 Koin Scope API를 사용하면 정의에서 Scope의 원래 소스를 전달할 수 있습니다.

싱글톤 인스턴스 A가 있다고 가정해 보겠습니다.

class A
class BofA(val a : A)

module {
    single { A() }
    scope<A> {
        scoped { BofA(getSource() /* or even get() */) }

    }
}

A의 범Scope를 생성함으로써 Scope의 소스(A 인스턴스)에 대한 참조를 범위의 기본 정의로 전달할 수 있습니다.

scoped { BofA(getSource()) } 또는 scoped { BofA(get()) }

 

val a = koin.get<A>()
val b = a.scope.get<BofA>()
assertTrue(b.a == a)

getSource()와 get()의 차이점: getSource는 소스 값을 직접 가져옵니다.

Get은 모든 정의를 해결하려고 시도하고 가능한 경우 소스 값으로 대체합니다. 그러면 getSource()가 성능 면에서 더 효율적입니다.

 

Scope Linking

Koin Scope API를 사용하면 scope를 다른 scope에 연결한 다음 joined definition space.을 확인할 수 있습니다.

 

예를 들어 보겠습니다. 여기에서 2개의 scope 범위 공간을 정의하고 있습니다.

A의 scope와 B의 scope입니다. A의 scope에서는 C에 대한 액세스 권한이 없습니다(B의 범위에 정의됨)

module {
    single { A() }
    scope<A> {
        scoped { B() }
    }
    scope<B> {
        scoped { C() }
    }
}

scope link API를 사용하면 A의 범위에서 직접 B의 scope 인스턴스 C를 확인할 수 있습니다.

이를 위해 scope 인스턴스에서 linkTo()를 사용합니다.

val a = koin.get<A>()
// let's get B from A's scope
val b = a.scope.get<B>()
// let's link A' scope to B's scope
a.scope.linkTo(b.scope)
// we got the same C instance from A or B scope
assertTrue(a.scope.get<C>() == b.scope.get<C>())