What is Dependency Injection?

DI라는 개념은 최근에 처음 알게 되었다. 나는 지금껏 MVVM 패턴을 사용하면서 매번 액티비티나 프래그먼트에서 뷰모델을 직접 생성하며 사용했었다. 그런데 화면 개수가 늘어나면 늘어날수록 뷰모델을 호출하는 횟수가 잦아졌고, 이게 여간 귀찮은 일이 아니였다. 하지만 DI 프레임워크의 존재를 알게 된 이후, 내가 지금껏 비효율적인 방법으로 뷰모델을 비롯한 모듈들을 사용하고 있다는 것을 알게 되었다 (역시 공부하면 공부할수록 내가 지금껏 알고 있었던 건 새발의 피라는 생각이 든다 :D). 알다시피 개발은 '효율'을 굉장히 따진다. 아직 DI를 제대로 써본 적은 없지만, 앞으로 써볼 날을 위해 DI의 개념에 대해서 깊게 파본 후 Koin을 이용해 간단하게 실습한 기록을 포스팅에 남기려 한다!

Dependency Injection (DI)

DI는 소프트웨어공학의 디자인 패턴 중 하나다. 용어 그 자체로 '의존성을 주입'하기 위해 사용한다.

의존성? 그게 뭔데?

public class User{
	val Database mDatabase;
    
    init {
    	this.mDataBase = Database()
    }
}

위 코드를 보자. User 클래스의 생성자 내부에서 Database 클래스의 인스턴스를 생성할 수 있다. 그렇다는건 User 클래스는 Database 클래스가 없거나 클래스 내부에 오류가 있다면 생성될 수 없는 것인데, 이렇게 되면 User 클래스가 Database 클래스에 의존적이라고 할 수 있고, Database 클래스는 User 클래스에 종속성을 제공한다라고 할 수 있다.

의존성을 주입한다?

위 코드에서 User 클래스는 Database 클래스에 의존하고 있다고 했고, User 클래스는 생성자 내부에서 Database 클래스의 인스턴스를 생성함으로서 Database 클래스에 대한 종속성을 얻는다.

사실 위의 예시처럼 생성자를 선언하는 것은 서로 의존도가 높아 좋지 않기 때문에, 우리는 클래스를 서로 독립적으로 만들어줘야한다. 독립적으로 만들어주면 재사용이 가능하고, 단위 테스트를 위해서도 필수적이기 때문이다.

그렇다면 이런 방법으로 생성자를 선언하는 것은 어떨까? User 클래스의 생성자 내부에서 직접 Database를 객체화하는 것 대신에, User 생성자의 argument로 미리 생성되어 있던 Database 인스턴스를 넘기는 것이다.

public class User(val database : Database){
	val Database mDatabase;
    
    init {
    	this.mDataBase = database
    }
}

이렇게 클래스 외부에서 의존성(을 가진 객체)을 주입하는 것을 의존성 주입, 즉 Dependency Injection 이라고 부를 수 있다.

Class : 나는 A랑 B가 필요한데, 둘 다 줘!

DI framework : 그래 알겠어! 내가 A랑 B를 미리 생성해서 줄게.

DI 프레임워크를 사용해 개발을 한다면 다음과 같은 장점과 단점을 얻을 수 있다.

장점
1. 유닛 테스트가 가능하다.
2. 의존성 초기화가 미리 수행되므로 보일러 플레이트 코드를 줄일 수 있다.
3. 결합도를 낮춰 좀 더 독립적인 프로그래밍이 가능하다.

단점
1. 러닝커브가 높고, 과도하게 사용되면 다른 문제가 발생할 수 있다.
2. 컴파일 시간 에러로 인해 런타임에 문제가 발생할 수 있다.
3. reflection 또는 동적 프로그래밍으로 구현되기 때문에 안전한 리팩토링과 같은 IDE 자동화 사용을 방해할 수 있다.

여튼 장점도 있고, 단점도 있는 DI지만, 결론적으로 말하자면 결합도를 낮출 수 있고, 그에 따라 유지보수가 쉬워지며, 모듈 재사용 및 유닛 테스트가 가능하다는 게 우리가 DI를 사용해야 하는 이유다.

Koin

DI 프레임워크에는 대표적으로 Dagger, Dagger Hilt, Koin이 있는데, 나는 앞선 2개의 프레임워크보다 러닝커브가 낮고 좀 더 가벼운 Koin을 찍먹해보기로 했다.

Koin이란 순수 코틀린으로 작성된 DI 프레임워크로, 내부 동작은 Service Locator의 형태를 띈다. Koin은 앞서 말했다시피 러닝커브가 낮고, 코틀린 개발환경에 도입하기 쉬우며, 뷰모델 주입을 쉽게 할 수 있는 별도의 라이브러리를 제공하는 장점 덕에 많이들 사용한다. 다만 컴파일 타임에 주입대상을 선정하는 다른 DI 프레임워크에 비해 런타임에 Service locating을 통해 동적으로 인스턴스를 주입하기 때문에 런타임 퍼포먼스가 다소 떨어질 수 있고, 이로 인해 런타임 오버헤드가 발생할 수 있다.

Koin의 주요 키워드는 다음과 같다.

module{ ... }

주입받고자 하는 객체의 집합이다.

single{ ... }

앱이 실행되는 동안 계속 유지되는 싱글톤 객체를 생성한다. 싱글톤 scope로 해당 객체를 만들어서 사용할 수 있다. 보통 repository, retrofit, db등을 사용할 때 사용한다.

factory{ ... }

요청할 때마다 매번 새로운 객체를 생성한다. factory로 제공되는 객체는 컨테이너에 저장하지 않으므로 다시 참조할 수 없다.

viewModel { ... }

viewModel 키워드로 모듈을 등록하면 koin이 해당 뷰모델을 ViewModelFactory에 등록한 뒤 현재 컴포넌트와 바인딩하고, 주입 받을 때도 ViewModelFactory에서 해당 뷰모델 객체를 불러온다.

get()

해당 코드 런타임에 바로 객체를 주입한다.

by inject()

get과 같이 알맞은 의존성을 주입하나, val 변수에만 사용할 수 있다.
lazy 방식의 주입으로, 해당 객체가 사용되는 시점에 의존성을 주입한다.

Koin 사용해보기

koin은 모듈을 생성하고, Application 단위 클래스에서 startKoin()으로 koin을 실행하여 필요한 컴포넌트에 의존성을 주입해 사용할 수 있다.
1. Gradle 설정

//Koin
def koin_version= "3.1.2"
implementation "io.insert-koin:koin-android:$koin_version"
implementation "io.insert-koin:koin-android-compat:$koin_version"
implementation "io.insert-koin:koin-androidx-workmanager:$koin_version"
implementation "io.insert-koin:koin-androidx-compose:$koin_version"

2. 모듈 생성

val ViewModelModule = module {
    viewModel {MainViewModel(androidApplication())}
}

3. Application 단위 클래스에서 모듈 등록 후 manifest에 선언

class App: Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin{
            androidContext(this@App)
            modules(ViewModelModule)
        }
    }
}

<application
        ...
        android:name=".App"
</application>

onCreate() LifeCycle에서 startKoin을 호출하고 위에서 선언한 모듈 변수를 넘겨준다.
androidContext(...) : 해당 안드로이드 context 사용
modules(...) : 사용할 모듈 등록

4. Activity 또는 Fragment 내에서 의존성 주입 받기

private val dViewModel: diaryViewModel by inject() 

(추가) Activity, Fragment 외부에서 koin을 어떻게 사용해야 할까?

액티비티나 프래그먼트가 아닌 일반 클래스에서도 의존성 주입이 필요할 때가 있다. 하지만 일반 클래스에서는 get()이나 by inject()를 사용해 의존성 주입을 할 수 없다. 안드로이드에서 Koin을 사용할 시 컨테이너는 안드로이드 컴포넌트의 생명주기에 맞추어 생성과 파괴가 되도록 만들어져야 한다. 액티비티나 프래그먼트 내부에서 컨테이너를 생성한 경우 해당하는 생명주기를 따르겠지만, 일반 클래스의 경우 생명주기가 없기 때문이다.

여튼 이렇게 일반 클래스에서 Koin을 사용하기 위해 KoinComponent라는 것을 제공하고 있다. KoinComponent를 사용하면 by inject(), get() 등을 사용해 의존성을 주입할 수 있다.

class MyComponent : KoinComponent {

    // lazy inject Koin instance
    val myService : MyService by inject()

    // eager inject Koin instance
    val myService : MyService = get()
}

하지만 다음의 StackOverFlow, 기사를 확인해보면, 생성자 파라미터를 통해 의존성을 주입받을 수 없는 상황을 제외하면 이 방법은 권장되지 않는다. 따라서 KoinComponent보단, 액티비티나 프래그먼트에서 Koin을 사용해야 하는 클래스를 생성할 때 생성자를 통해 객체를 주입하는 것이 좋다.

class MainActivity : AppCompatActivity() {
	private val dataStoreModule : DataStoreModule by inject()
    
    override fun onCreate(savedInstance: Bundle){
    	super.onCreate(savedInstanceState)
        ...
        Aclass(dataStpreModule)
    }
}

class Aclass(private val dataStoreModule: DataStoreModule) {
	...
}

💛 도움이 된 문서 또는 블로그입니다

https://www.simplifiedcoding.net/android-dependency-injection/#What-is-Dependency
https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f
https://stackoverflow.com/questions/14301389/why-does-one-use-dependency-injection
https://jaejong.tistory.com/153