[Android] Dependency Injection Part 3. Dagger basics

이 글은 Android Developer 가이드 내용을 토대로 작성되었습니다. 예제 코드는 Kotlin만 가져왔으며, Java 코드는 원문에서 확인할 수 있습니다.

직접 의존성 주입이나 Service locator 사용은 프로젝트 크기에 따라 문제가 생길 수도 있습니다. Dagger를 사용해 디펜던시를 관리하면 프로젝트의 규모가 커지더라도 복잡성을 유지할 수 있습니다.

Dagger의 장점

Dagger는 번거롭고 에러가 발생하기 쉬운 보일러플레이트 코드를 작성하지 않도록 아래 기능을 제공합니다.

• Part 2에서 직접 구현했던 AppContainer 코드(application graph) 생성
• Application graph에서 사용 가능한 클래스들에 대한 팩토리 코드 생성 ➔ 내부적으로 각 의존성을 모두 만족시킴
• Scope을 사용하여 타입을 어떻게 정했느냐에 따라 디펜던시를 재사용하거나 새 인스턴스 생성
• 이전 파트의 로그인 플로우 예제에서처럼 Dagger subcomponent를 이용하여 특정 플로우에 대한 컨테이너 생성 ➔ 더 이상 필요없는 자원을 메모리에서 해제하여 앱 성능 향상에 도움

Dagger는 이 모든 작업을 빌드 타임에 자동으로 수행하며, 이전 파트에서 수동으로 작성했던 것과 비슷한 코드들을 생성합니다. 내부적으로, Dagger는 클래스 인스턴스를 제공 시 참조할 수 있는 그래프를 생성합니다. 그래프의 모든 클래스들에 대해 팩토리 타입 클래스를 생성하여 해당 타입의 인스턴스를 가져올 때 내부적으로 사용합니다.

빌드 타임에 Dagger는 코드를 탐색하고,

• 디펜던시 그래프 생성 및 아래 항목에 대해 검증합니다:
  • 모든 객체의 디펜던시가 Runtime Exception 없이 만족하는지
  • 디펜던시 사이클이 없는지 (무한 루프 참조가 없도록)
• 런타임에 사용될 클래스와 그들의 디펜던시를 생성합니다.

간단한 Dagger use case: 팩토리 생성

Dagger를 어떻게 사용하는지 알기 위해, 아래 다이어그램의 UserRepository처럼 간단한 팩토리를 생성해봅시다.

UserRepository는 이렇게 정의합니다.

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

UserRepository의 생성자에 @Inject 어노테이션을 추가하면 UserRepository 인스턴스가 어떻게 생성되는지 Dagger 가 알 수 있습니다.

// @Inject lets Dagger know how to create instances of this object
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

위 코드 스니펫에서 Dagger에게 알려주는 것은 두 가지입니다.

1. @Inject 어노테이션이 추가된 생성자를 통해 UserRepository가 어떻게 생성되는지
2. UserRepository의 디펜던시들: UserLocalDataSource, UserRemoteDataSource

이제 Dagger는 UserRepository 인스턴스를 어떻게 생성해야 하는지 알지만 그의 디펜던시들을 어떻게 생성해야 하는지는 알 수 없습니다. 다른 클래스들에도 똑같이 어노테이션을 추가한다면, 그들에 대해서도 알 수 있습니다.

// @Inject lets Dagger know how to create instances of these objects
class UserLocalDataSource @Inject constructor() { ... }
class UserRemoteDataSource @Inject constructor() { ... }

Dagger components

Dagger는 프로젝트의 디펜던시 그래프를 생성하여, 각 디펜던시가 필요할 때 어디에서 가져와야 하는지 알 수 있습니다. Dagger가 이 그래프를 생성하기 위해서는 인터페이스를 생성하고, 그 인터페이스에 @Component 어노테이션을 붙여줘야 합니다. 그럼 Dagger는 수동 디펜던시 주입에서 직접 했던 것과 같은 컨테이너를 생성합니다.

@Component 인터페이스 안에 필요한 클래스(예, UserRepository)의 인스턴스를 반환하는 함수를 정의할 수 있습니다. @Component 어노테이션은 Dagger가 생성해야하는 컨테이너를 나타냅니다. 이것을 Dagger component라고 하며, 어떻게 생성할지와 각 디펜던시에 대해 Dagger가 알고 있는 객체들로 구성된 그래프를 포함합니다.

// @Component makes Dagger create a graph of dependencies
@Component
interface ApplicationGraph {
    // The return type  of functions inside the component interface is
    // what can be provided from the container
    fun repository(): UserRepository
}

프로젝트를 빌드할 때 Dagger는 ApplicationGraph 인터페이스의 구현체를 생성합니다: DaggerApplicationGraph. 예제에서 Dagger는 3가지 클래스(UserRepository, UserLocalDataSource, UserRemoteDataSource)간의 관계로 구성된 그래프를 생성합니다. ApplicationGraph는 아래와 같이 사용할 수 있습니다.

// Create an instance of the application graph
val applicationGraph: ApplicationGraph = DaggerApplicationGraph.create()
// Grab an instance of UserRepository from the application graph
val userRepository: UserRepository = applicationGraph.repository()

Dagger는 applicationGraph.repository()가 호출될 때마다 인스턴스를 새로 생성합니다.

val applicationGraph: ApplicationGraph = DaggerApplicationGraph.create()

val userRepository: UserRepository = applicationGraph.repository()
val userRepository2: UserRepository = applicationGraph.repository()

assert(userRepository != userRepository2)

경우에 따라, 컨테이너에 같은 인스턴스만 필요한 경우도 있습니다. 아래와 같은 이유로요.

1. 해당 타입을 디펜던시로 갖는 다른 타입에 같은 인스턴스를 공유하고 싶을 때 (예, 여러 ViewModel에 동일한 UserData인스턴스를 공유)
2. 객체를 생성하는 비용이 커서 매번 새로운 인스턴스를 생성하지 않고, 한 번 정의된 인스턴스를 사용하고 싶을 때 (예, JSON parser)

디펜던시를 직접 주입할 때는 ViewModel의 생성자에 동일한 UserRepository 인스턴스를 전달하는 것으로 이를 구현했습니다. 하지만 Dagger를 사용할 땐 코드를 직접 작성하지 않기 때문에 Dagger에 같은 인스턴스를 원한다는 것만 알려주면 됩니다. 이것은 scope 어노테이션을 이용하여 표시할 수 있습니다.

Scoping with Dagger

Scope 어노테이션을 사용하여 한 객체의 라이프타임부터 그 컴포넌트의 라이프타임까지 제한할 수 있습니다. 즉 디펜던시가 필요할 때마다 같은 인스턴스를 사용할 수 있습니다.

UserRepository의 유일한 인스턴스를 가지기 위해, javax.inject에 이미 정의된 @Singletone 어노테이션을 사용할 수 있습니다.

// Scope annotations on a @Component interface informs Dagger that classes annotated
// with this annotation (i.e. @Singleton) are bound to the life of the graph and so
// the same instance of that type is provided every time the type is requested.
@Singleton
@Component
interface ApplicationGraph {
    fun repository(): UserRepository
}

// Scope this class to a component using @Singleton scope (i.e. ApplicationGraph)
@Singleton
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

또는 커스텀 scope 어노테이션을 직접 생성하여 사용할 수 있습니다. 아래처럼 scope 어노테이션을 생성합니다.

// Creates MyCustomScope
@Scope
@MustBeDocumented
@Retention(value = AnnotationRetention.RUNTIME)
annotation class MyCustomScope

그리고 이렇게 사용합니다.

@MyCustomScope
@Component
interface ApplicationGraph {
    fun repository(): UserRepository
}

@MyCustomScope
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val service: UserService
) { ... }

두 경우 모두 @Component 인터페이스와 동일한 scope 어노테이션을 사용했습니다. 즉 applicationGraph.repository()가 호출될 때마다 같은 UserRepository 인스턴스를 얻게 됩니다.

val applicationGraph: ApplicationGraph = DaggerApplicationGraph.create()

val userRepository: UserRepository = applicationGraph.repository()
val userRepository2: UserRepository = applicationGraph.repository()

assert(userRepository == userRepository2)

결론

더 복잡한 상황에 적용하기 전에, Dagger의 장점과 기본 동작 방식을 이해하는 것이 중요합니다.

다음 파트에서는 Android 앱에 Dagger를 추가하는 방법에 대해 알아보겠습니다.