[iOS] 의존성 주입(Dependency Injection, DI) 이란 ? Swift 에서 적용하기, 의존 관계 역전 법칙

의존성 주입을 고민하게 된 계기

프레임워크 내에서 다른 add-on 프레임워크 api를 사용할 때,

dynamic 프레임워크는 프로젝트 내 embed 한 경우, 해당 api가 정상 호출되지만,

embed 하지 않고 호출하는 경우, 에러가 발생하는데, 이 에러가 발생하지 않도록 구현이 필요했다.

---

의존성 주입(DI, Dependency Injection) 이란?

먼저, 두 단어를 뜯어서 보면,

의존성(Dependency) 이란 ? 서로 다른 객체 사이에 의존 관계가 있다는 것을 말한다. 

코드로 이해해보자.

 

즉, 아래 그림과 같이 클래스 A가 B를 직접 생성하고 사용한다면, 'A 객체가 B 객체를 의존한다' 라고 한다.

 

무슨 말이냐 

위 코드의 B 클래스 name 변수를 name2로 변경해보면,

바로 A 클래스에서 에러가 발생!!!!

따라서 B 클래스에서 변경사항이 생기면,  A에서도 변경사항을 반영해주어야 한다!

 

즉, 의존하는 객체가 수정되면, 다른 객체도 영향을 받는다는 것이다.

위와 같이 A가 B를 멤버변수 및 로컬변수로 가지고 있거나 B의 메소드를 호출하는 경우, B에 관련된 어떠한 연관된 일을 하는 경우 의존한다라고 표현할 수 있다.

위 코드에서 A 객체는 B 객체에 의존한다는 것이다.

*의존 관계의 문제점 :

• A 객체는 B 객체를 의존하고 있으므로, A객체가 아무것도 변하지 않았음에도 예상치 못한 동작을 하거나 컴파일이 안되는 일 발생
• A의 재사용성이 낮아진다. 만약 A를 다른 모듈 또는 다른 클래스에 재사용하고 싶은 경우, B도 끌어와야 하는 상황이 발생

그렇담, 주입(Injection)이란?

외부에서 값을 넣어주면서 객체를 생성할 때, 값을 주입한다고 한다.

우리가 늘 쓰던 생성자(init)가 바로 이 개념이다.

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

let person = Person(name: "삼연")

위 코드와 같이 외부에서 인스턴스를 생성할 때, 생성자를 통해 값을 넣어주는 것!

 

그럼, 두 단어를 합친 의존성 주입(Dependency Injection, DI)이란?

기존의 의존성을 외부에서 주입할 수 있도록 바꿔는 것이다. 즉, 두 클래스가 의존적이지 않은 관계로 만들어 주는 것이다.

외부에서 초기화해서 클래스 안에 할당해주므로 유연한 구조가 된다.

 

어떻게 적용하지 ?

---

의존성 주입 적용하기 - 의존 관계 역전 법칙(DIP, Dependency Inversion Principle)

우리의 목표는 아래 그림과 같이 A와 B클래스의 의존성을 끊고, 외부에서 B를 만든 후 만든 것을 가져와서 A가 사용하도록 바꾸어 주어야 한다.

즉, A객체가 B객체가 아닌 외부(매개체)을 의존하도록 하는 것이다.

 

이 때, 객체 지향 프로그래밍 설계의 의존 관계 역전 법칙(DIP)에 따라,

객체들 중간에 제어권을 가지는 이 매개체는 구체적인 것이 아닌 추상화된 것이 된다.

*객체지향 프로그램 (OOP)의 5대 원칙(SOLID) 중 하나인 의존관계 역전 원칙(DIP: Dependency Inversion Principle) 의존 관계 분리 : 추상화된 것은 구체적인 것에 의존하면 안되고, 구체적인 것이 추상화된 것에 의존해야 한다. 

즉, 구체적인 객체는 추상화된 객체(프로토콜)에 의존해야 한다.

 

이 법칙은 기존 의존관계를 역전시킴으로써 A클래스와 B클래스가 독립된 아래 그림과 같은 구조가 된다.

 

[기존 구조]

[의존 관계 역전 법칙 구조]

 

이렇게 의존 방향이 역전되어 제어가 반전되는 상황을 제어의 반전(IoC, Inversion of Control)이라고 표현한다.

---

이 때, 이 추상화 된 것(매개체)이 Swift에서는 Protocol이 있다.

우리는 이 Protocol을 활용해서 의존성 주입을 구현해보자.

 

우선 Protocol을 활용해서 추상적인 객체를 만들어야 한다.

protocol DIInterface {
    var name: String{ get set }
}

 

B클래스가 생성한 DIInterface Protocol을 채택하여 정의한 변수도 할당해준다.

class B: DIInterface {
    var name: String = "B변수"
}

 

DI를 적용하기 위해  A클래스의 의존성을 외부에서 주입받도록 구현해보자.

A클래스 생성 및 사용 시 원하는 DIInterface 인스턴스를 주입할 수 있다.

class A{
    // 프로토콜로 타입으로 변수 선언
    var b: DIInterface

    //프로토콜에 선언된 모든 타입들은 선언 가능하다.
    init(b: DIInterface) {
        self.b = b
    }
    
    func printName() {
        print(b.name)
    }
}

이렇게 구현한다면, A객체와 B객체는 독립적인 객체가 된다.

즉, 기존처럼 B클래스의 name 변수가 이름을 바꾸거나 없어도 A를 수정해야되는 일은 없다.

 

즉, 기존에는 의존성을 직접 모두 제어했다면 제어권이 역전되어 Protocol에 제어권이 있다는 것이다.

---

또한, 모듈을 추가 가능하다.

A 클래스의 새로운 b가 필요하다면 DIInterface Protocol을 채택한 새로운 C 클래스를 만들어보자.

DIInterface Protocol을 준수하는 어떤 타입이라도 저장할 수 있도록 한다.

이제, 사용자가 직접 생성하지 않고 필요할 때 DIInterface가 의존성 있는 모듈들을 주입해 주는 것이다.

protocol DIInterface {
    var name: String{ get set }
}

class B: DIInterface {
    var name: String = "B변수"
}

class C: DIInterface {
    var name: String = "C변수"
}

class A{
    var b: DIInterface

    init(b: DIInterface) {
        self.b = b
    }
    
    func printName() {
        print(b.name)
    }
}

let moduledB = B()
let moduledC = C()

let devlopedA = A(b: moduledB)

protocol 타입으로 뜨니까 프로토콜을 상속받은 모든 애들을 사용 가능하다.

즉, 주입은 하되 protocol 타입으로 주입을 해서 여러가지 코드로 확장해서 만들 수 있다는 것!!!

 

위의 의존성 높던 A클래스와 B클래스의 구조가 의존성 주입으로 인해 아래와 같은 구조가 된다.

 

DIInterface(Protocol)에게 모든 관계설정에 관한 책임을 위임을 하게 되었다.

---

의존성 주입의 장단점

✔️ 장점 

1. 객체 간 결합도(Coupling)을 낮춰 의존성 감소
   • 변경에 민감하지 않아 기존 기능 리팩토링 수월 및 새 기능 개발 용이
   • 모듈별 독립적인 재사용 가능
   • 유지보수 용이
2. 빌드시간 단축
   • 객체가 의존성을 받는 시점이 컴파일타임이 아닌 런타임으로 늦춰진다.
   • static한 class Dependency가 런타임의 dynamic한 object Dependency로 변경 되어 빌드 시간 단축
3.  테스트 용이성
   • 주입할 의존 객체를 Mock 객체로 구현한 후 주입

✔️ 단점 

1. 코드가 복잡해져 이해하기 어려워짐
   • 의존성 주입을 위한 선행 작업이 필요
   • 호출들이 protocol로 연결되어 있어서 호출을 따라가기가 힘들어짐
   • 디버깅이 어려워짐

---

 

 

Interface Injection

내가 고민하다 사용한 방법으로 Interface를 이용하여 의존성을 주입하는 방법이다.

 

객체지향 프로그래밍에서 추상화 개념있음 swift에서는 클래스를 정의하는 추상화 방법에 protocol이 있음

Interface를 사용하게 되면 긴밀하게 연결되어 있는 의존성이 약해져 모듈과 모듈사이의 결합이 줄어든다.

 

---