안드로이드 의존성 주입: Dagger-Hilt 사용법 🚀

안녕, 친구들! 오늘은 안드로이드 개발자들 사이에서 핫한 주제인 의존성 주입(Dependency Injection)에 대해 얘기해볼 거야. 특히 구글이 공식적으로 밀고 있는 Dagger-Hilt라는 라이브러리를 중심으로 설명할 거니까 집중해서 들어봐! 😊

먼저, 의존성 주입이 뭔지 모르는 친구들을 위해 간단히 설명해볼게. 의존성 주입은 쉽게 말해서 객체를 직접 만들지 않고 외부에서 가져와 사용하는 방식이야. 이렇게 하면 코드가 더 유연해지고, 테스트하기 쉬워진다는 장점이 있어. 근데 이걸 직접 구현하려면 좀 복잡하거든? 그래서 Dagger-Hilt 같은 라이브러리를 쓰는 거야.

Dagger-Hilt는 구글이 안드로이드를 위해 특별히 만든 의존성 주입 라이브러리야. 기존의 Dagger 2를 안드로이드에 맞게 더 쉽고 편하게 사용할 수 있도록 개선한 버전이지. 이제부터 Dagger-Hilt를 어떻게 사용하는지 하나하나 자세히 알아볼 거야. 준비됐니? 그럼 시작해보자고! 🎉

1. Dagger-Hilt 설정하기 ⚙️

자, 이제 본격적으로 Dagger-Hilt를 사용해볼 거야. 먼저 프로젝트에 Dagger-Hilt를 설정해야 해. 걱정 마, 어렵지 않아!

1.1 Gradle 설정

프로젝트 수준의 build.gradle 파일에 다음 내용을 추가해줘:


buildscript {
    ...
    dependencies {
        ...
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.38.1'
    }
}

그 다음, 앱 수준의 build.gradle 파일에 이렇게 추가해:


plugins {
    ...
    id 'kotlin-kapt'
    id 'dagger.hilt.android.plugin'
}

dependencies {
    implementation "com.google.dagger:hilt-android:2.38.1"
    kapt "com.google.dagger:hilt-android-compiler:2.38.1"
}

이렇게 하면 Dagger-Hilt를 사용할 준비가 끝났어! 근데 잠깐, 버전 번호는 계속 업데이트되니까 최신 버전을 확인해보는 게 좋아. 구글에서 "Dagger-Hilt latest version"이라고 검색해보면 금방 찾을 수 있을 거야.

1.2 Application 클래스 설정

이제 Application 클래스에 @HiltAndroidApp 어노테이션을 추가해줘야 해. 이게 Dagger-Hilt의 시작점이 되는 거지. 이렇게 하면 돼:


@HiltAndroidApp
class MyApplication : Application() {
    // ...
}

이 어노테이션을 추가하면 Dagger-Hilt가 의존성 주입을 위한 컴포넌트들을 자동으로 생성해줘. 정말 편리하지?

🔔 주의사항: Application 클래스를 만들었다면 AndroidManifest.xml 파일에 등록하는 걸 잊지 마! 이렇게:


<application
    android:name=".MyApplication"
    ...>

여기까지 했다면 Dagger-Hilt의 기본 설정은 끝났어! 이제 본격적으로 의존성 주입을 사용해볼 준비가 된 거지. 어때, 생각보다 쉽지? 😉

다음 섹션에서는 Dagger-Hilt를 실제로 어떻게 사용하는지 더 자세히 알아볼 거야. 재능넷에서 모바일 앱 개발 관련 강의를 들어본 적 있다면 이해하기 더 쉬울 거야. 아직 안 들어봤다고? 그럼 한번 찾아보는 것도 좋을 것 같아! 재능넷에는 이런 실용적인 프로그래밍 지식을 공유하는 강의가 많거든. 자, 그럼 계속해서 Dagger-Hilt의 세계로 들어가볼까? 🚀

2. Dagger-Hilt 기본 사용법 🛠️

자, 이제 Dagger-Hilt를 실제로 어떻게 사용하는지 알아볼 거야. 걱정 마, 천천히 하나씩 설명할 테니까!

2.1 의존성 주입 대상 정의하기

먼저, 의존성 주입을 받을 클래스를 만들어보자. 예를 들어, 데이터베이스 작업을 담당하는 DatabaseHelper 클래스를 만들어볼게:


class DatabaseHelper @Inject constructor() {
    fun getUser(): User {
        // 데이터베이스에서 사용자 정보를 가져오는 로직
        return User("홍길동", 25)
    }
}

여기서 중요한 건 @Inject constructor() 부분이야. 이 어노테이션을 붙이면 Dagger-Hilt에게 "이 클래스의 인스턴스를 만들어줘!"라고 말하는 거지.

2.2 의존성 주입 받기

이제 이 DatabaseHelper를 사용할 곳에서 의존성 주입을 받아보자. 예를 들어, UserViewModel에서 사용한다고 해볼게:


@HiltViewModel
class UserViewModel @Inject constructor(
    private val databaseHelper: DatabaseHelper
) : ViewModel() {
    fun getUser(): User {
        return databaseHelper.getUser()
    }
}

여기서 몇 가지 중요한 점이 있어:

@HiltViewModel 어노테이션: 이걸 붙이면 Dagger-Hilt가 ViewModel을 위한 의존성 주입을 처리해줘.
@Inject constructor(...): 이 생성자를 통해 DatabaseHelper의 인스턴스를 주입받아.

이렇게 하면 Dagger-Hilt가 알아서 DatabaseHelper의 인스턴스를 만들어서 UserViewModel에 주입해줘. 우리가 직접 new 키워드로 객체를 만들 필요가 없는 거지!

2.3 액티비티에서 사용하기

이제 이 ViewModel을 액티비티에서 사용해보자:


@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val user = viewModel.getUser()
        // user 정보를 사용하는 로직...
    }
}

여기서 주목할 점은:

@AndroidEntryPoint 어노테이션: 이걸 붙이면 Dagger-Hilt가 이 액티비티에 의존성 주입을 할 수 있게 돼.
by viewModels(): 이건 Jetpack의 기능으로, ViewModel을 쉽게 가져올 수 있게 해줘.

💡 팁: by viewModels()를 사용하려면 build.gradle에 다음 의존성을 추가해야 해:

implementation "androidx.fragment:fragment-ktx:1.3.6"

이렇게 하면 기본적인 Dagger-Hilt 사용법을 마스터한 거야! 어때, 생각보다 쉽지? 😊

근데 이게 다가 아니야. Dagger-Hilt는 더 복잡한 상황에서도 강력한 기능을 발휘해. 예를 들어, 인터페이스를 주입하거나, 같은 타입의 다른 구현체를 주입하는 경우도 있을 수 있어. 이런 경우에는 어떻게 할까? 그건 다음 섹션에서 자세히 알아볼 거야.

그리고 말이야, 이런 의존성 주입 패턴은 앱 개발에서 정말 중요해. 재능넷에서도 이런 고급 개발 기술에 대한 수요가 많다고 들었어. 혹시 너도 이런 기술을 가르치고 싶다면 재능넷에서 강의를 개설해보는 건 어때? 많은 개발자들에게 도움이 될 거야!

자, 이제 더 깊이 들어가볼 준비가 됐니? 다음 섹션에서는 Dagger-Hilt의 고급 기능들을 살펴볼 거야. 기대되지 않아? 😎

3. Dagger-Hilt 고급 기능 🚀

오케이, 이제 Dagger-Hilt의 더 강력한 기능들을 알아볼 차례야. 준비됐어? 조금 어려울 수 있지만, 천천히 따라오면 돼!

3.1 모듈과 바인딩

때로는 인터페이스나 외부 라이브러리의 클래스처럼 직접 @Inject를 붙일 수 없는 경우가 있어. 이럴 때 사용하는 게 바로 모듈(Module)이야.


@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    @Provides
    @Singleton
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

여기서 몇 가지 새로운 개념이 나왔지?

@Module: 이 클래스가 Dagger-Hilt 모듈임을 나타내.
@InstallIn(SingletonComponent::class): 이 모듈을 어느 컴포넌트에 설치할지 지정해. 여기서는 앱 전체에서 싱글톤으로 사용한다는 뜻이야.
@Provides: 이 메서드가 의존성을 제공한다는 걸 나타내.
@Singleton: 이 의존성을 싱글톤으로 제공한다는 뜻이야.

이렇게 하면 Retrofit이나 ApiService 같은 외부 라이브러리도 쉽게 주입받을 수 있어!

3.2 한정자(Qualifier) 사용하기

같은 타입의 다른 구현체를 주입해야 할 때가 있어. 이럴 때 사용하는 게 한정자야.


@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class AuthInterceptorOkHttpClient

@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class OtherInterceptorOkHttpClient

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @AuthInterceptorOkHttpClient
    @Provides
    fun provideAuthInterceptorOkHttpClient(): OkHttpClient {
        // Auth 인터셉터를 포함한 OkHttpClient 반환
    }

    @OtherInterceptorOkHttpClient
    @Provides
    fun provideOtherInterceptorOkHttpClient(): OkHttpClient {
        // 다른 인터셉터를 포함한 OkHttpClient 반환
    }
}

이렇게 하면 사용할 때 이렇게 구분해서 주입받을 수 있어:


class SomeClass @Inject constructor(
    @AuthInterceptorOkHttpClient private val authClient: OkHttpClient,
    @OtherInterceptorOkHttpClient private val otherClient: OkHttpClient
) {
    // 사용 로직...
}

이렇게 하면 같은 OkHttpClient 타입이지만 다른 설정을 가진 객체를 구분해서 주입받을 수 있어!

3.3 멀티 바인딩

때로는 여러 개의 구현체를 한 번에 주입받고 싶을 때가 있어. 이럴 때 사용하는 게 멀티 바인딩이야.


interface Fruit {
    fun getName(): String
}

class Apple @Inject constructor() : Fruit {
    override fun getName() = "Apple"
}

class Banana @Inject constructor() : Fruit {
    override fun getName() = "Banana"
}

@Module
@InstallIn(SingletonComponent::class)
abstract class FruitModule {
    @Binds
    @IntoSet
    abstract fun bindApple(apple: Apple): Fruit

    @Binds
    @IntoSet
    abstract fun bindBanana(banana: Banana): Fruit
}

class FruitBasket @Inject constructor(
    private val fruits: Set<@JvmSuppressWildcards Fruit>
) {
    fun listFruits() {
        fruits.forEach { println(it.getName()) }
    }
}

이렇게 하면 FruitBasket에 모든 Fruit 구현체가 자동으로 주입돼. 정말 편리하지?

🍎 참고: @JvmSuppressWildcards는 Java와의 호환성을 위해 사용해. Kotlin의 제네릭과 Java의 제네릭 사이의 차이를 해결해주는 역할을 해.

와, 여기까지 왔다면 정말 대단한 거야! Dagger-Hilt의 고급 기능들을 모두 살펴봤어. 이제 너도 Dagger-Hilt 마스터라고 할 수 있을 것 같아! 😎

이런 고급 기술들을 익히면 앱 개발이 훨씬 더 재미있어질 거야. 그리고 말이야, 이런 기술들은 실무에서 정말 중요해. 재능넷에서도 이런 고급 안드로이드 개발 기술에 대한 수요가 많다고 들었어. 혹시 너도 이런 기술을 가르치고 싶다면 재능넷에서 강의를 개설해보는 건 어때? 많은 개발자들에게 도움이 될 거야!

자, 이제 Dagger-Hilt의 거의 모든 것을 배웠어. 하지만 아직 끝이 아니야! 다음 섹션에서는 Dagger-Hilt를 실제 프로젝트에 적용할 때 주의해야 할 점들과 베스트 프랙티스에 대해 알아볼 거야. 계속 따라올 준비 됐지? 가보자고! 🚀

4. Dagger-Hilt 실전 적용과 베스트 프랙티스 💼

자, 이제 Dagger-Hilt를 실제 프로젝트에 적용할 때 알아두면 좋을 팁들과 베스트 프랙티스에 대해 알아볼 거야. 이 부분은 정말 중요하니까 집중해서 들어봐!

4.1 스코프 관리하기

Dagger-Hilt에서는 다양한 스코프를 제공해. 각 스코프는 의존성의 생명주기를 결정하지. 주요 스코프들을 살펴볼까?

@Singleton: 앱 전체에서 하나의 인스턴스만 유지돼.
@ActivityScoped: 액티비티 생명주기 동안 유지돼.
@ViewModelScoped: ViewModel 생명주기 동안 유지돼.
@FragmentScoped: 프래그먼트 생명주기 동안 유지돼.

스코프를 적절히 사용하면 메모리 관리에 큰 도움이 돼. 하지만 남용하면 오히려 문제가 될 수 있으니 주의해야 해!


@ActivityScoped
class MyRepository @Inject constructor() {
    // 이 리포지토리는 액티비티 생명주기 동안 유지돼
}

@HiltViewModel
class MyViewModel @Inject constructor(
    private val repository: MyRepository
) : ViewModel() {
    // ViewModel에서 ActivityScoped 리포지토리 사용
}

4.2 테스트 용이성 높이기

Dagger-Hilt를 사용하면 테스트가 훨씬 쉬워져. 특히 의존성을 쉽게 교체할 수 있어서 단위 테스트하기 좋아져.


@Module
@InstallIn(SingletonComponent::class)
object TestModule {
    @Provides
    @Singleton
    fun provideTestApiService(): ApiService {
        return FakeApiService()  // 테스트용 가짜 API 서비스
    }
}

@HiltAndroidTest
class MyTest {
    @get:Rule
    var hiltRule = HiltAndroidRule(this)

    @Inject
    lateinit var apiService: ApiService

    @Test
    fun testSomething() {
        // 여기서 주입받은 apiService는 FakeApiService
    }
}

이렇게 하면 실제 API 대신 테스트용 가짜 API를 사용할 수 있어. 테스트가 훨씬 쉬워지겠지?

4.3 모듈 구조화하기

프로젝트가 커지면 모듈도 많아지게 돼. 이럴 때는 모듈을 잘 구조화하는 게 중요해.


@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    // 앱 전체에서 사용되는 의존성들
}

@Module
@InstallIn(ActivityComponent::class)
object ActivityModule {
    // 액티비티 레벨에서 사용되는 의존성들
}

@Module
@InstallIn(ViewModelComponent::class)
object ViewModelModule {
    // ViewModel에서 사용되는 의존성들
}

이렇게 모듈을 분리하면 코드 관리가 훨씬 쉬워져. 각 모듈의 책임이 명확해지니까 말이야!

4.4 바인딩 최적화하기

가능하면 @Binds를 사용하는 게 좋아. @Provides보다 성능이 더 좋거든.


interface Repository

class RepositoryImpl @Inject constructor() : Repository

@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
    @Binds
    @Singleton
    abstract fun bindRepository(impl: RepositoryImpl): Repository
}

@Binds는 컴파일 타임에 최적화되기 때문에 런타임 성능이 더 좋아. 작은 차이지만, 이런 게 모여서 큰 차이를 만들어내는 거야!

4.5 의존성 그래프 시각화하기

프로젝트가 커지면 의존성 관계가 복잡해질 수 있어. 이럴 때 의존성 그래프를 시각화하면 도움이 돼.


./gradlew :app:hiltDebugTreeGraph

이 명령어를 실행하면 의존성 그래프를 볼 수 있어. 복잡한 의존성 관계를 한눈에 파악할 수 있지!

💡 Pro Tip: 의존성 그래프를 정기적으로 확인하면 프로젝트의 구조를 더 잘 이해할 수 있어. 특히 팀 프로젝트에서 유용하지!

자, 여기까지가 Dagger-Hilt의 실전 적용과 베스트 프랙티스야. 이런 팁들을 잘 활용하면 더 효율적이고 유지보수하기 쉬운 코드를 작성할 수 있을 거야.

그리고 말이야, 이런 고급 기술들을 익히면 정말 프로페셔널한 개발자가 될 수 있어. 재능넷에서도 이런 실전 경험을 공유하는 강의가 인기가 많다고 해. 너도 이런 경험을 쌓다 보면 언젠가는 재능넷 에서 강의를 할 수 있을지도 몰라! 많은 개발자들에게 도움이 될 거야.

자, 이제 Dagger-Hilt에 대해 거의 모든 것을 배웠어. 기본부터 고급 기능, 그리고 실전 팁까지! 하지만 기술은 계속 발전하고 있어. 항상 새로운 것을 배우려는 자세가 중요해. 그럼 마지막으로 Dagger-Hilt의 미래와 안드로이드 개발의 트렌드에 대해 얘기해볼까? 🚀

5. Dagger-Hilt의 미래와 안드로이드 개발 트렌드 🔮

자, 이제 우리가 배운 Dagger-Hilt가 앞으로 어떻게 발전할지, 그리고 안드로이드 개발 생태계에서 어떤 위치를 차지할지 살펴볼 거야. 흥미진진하지 않아?

5.1 Jetpack Compose와의 통합

구글이 밀고 있는 새로운 UI 툴킷인 Jetpack Compose와 Dagger-Hilt의 통합이 더욱 강화될 거야. 이미 Compose에서 Hilt를 사용할 수 있지만, 앞으로는 더 seamless한 통합이 이루어질 거라고 봐.


@HiltViewModel
class MyViewModel @Inject constructor(
    private val repository: MyRepository
) : ViewModel()

@Composable
fun MyScreen(viewModel: MyViewModel = hiltViewModel()) {
    // Compose UI 로직
}

이런 식으로 Compose와 Hilt를 함께 사용하는 패턴이 더 보편화될 거야. 재능넷에서도 이런 최신 트렌드를 반영한 강의들이 늘어나고 있다고 해!

5.2 코루틴과의 더 나은 통합

Dagger-Hilt와 코루틴의 통합도 더욱 발전할 거야. 특히 비동기 의존성 주입에 대한 지원이 강화될 것 같아.


@Module
@InstallIn(SingletonComponent::class)
object AsyncModule {
    @Provides
    @Singleton
    fun provideAsyncService(): AsyncService = AsyncService()
}

class AsyncService {
    suspend fun doAsyncWork() {
        // 비동기 작업
    }
}

@HiltViewModel
class AsyncViewModel @Inject constructor(
    private val asyncService: AsyncService
) : ViewModel() {
    fun doWork() = viewModelScope.launch {
        asyncService.doAsyncWork()
    }
}

이런 식으로 비동기 작업과 의존성 주입을 더 쉽게 결합할 수 있게 될 거야.

5.3 멀티모듈 프로젝트에서의 개선

대규모 앱 개발에서 중요한 멀티모듈 아키텍처에서 Dagger-Hilt의 사용이 더욱 편리해질 거야.


// app 모듈
@HiltAndroidApp
class MyApplication : Application()

// feature 모듈
@Module
@InstallIn(SingletonComponent::class)
object FeatureModule {
    @Provides
    @Singleton
    fun provideFeatureService(): FeatureService = FeatureServiceImpl()
}

이런 식으로 각 모듈에서 정의한 의존성들을 더 쉽게 통합하고 관리할 수 있게 될 거야. 모듈 간의 의존성 관리가 더 쉬워질 거라고 봐!

5.4 테스트 지원 강화

Dagger-Hilt의 테스트 지원도 계속 발전할 거야. 특히 UI 테스트에서의 의존성 교체가 더 쉬워질 것 같아.


@HiltAndroidTest
class MyUITest {
    @get:Rule
    val hiltRule = HiltAndroidRule(this)

    @BindValue @JvmField
    val fakeRepository: MyRepository = FakeRepository()

    @Test
    fun testUI() {
        // UI 테스트 로직
    }
}

이런 식으로 UI 테스트에서도 의존성을 쉽게 교체할 수 있게 될 거야. 테스트 코드 작성이 훨씬 쉬워질 거라고 기대해도 좋아!