Head First Design Pattern - 제 1장 전략 패턴

 

 

디자인 원칙 - 달라지는 부분은 분리, 달라지지 않는 부분은 캡슐화 한다.

 

 

구현 위주가 아닌, 인터페이스 위주로 코드를 작성하면 더 유지보수 하기가 용이하다.

 

 

인터페이스에 구현해야할 기능을 정의하고

해당 인터페이스를 채택하는 class에 각 기능을 구현합니다

 

 

e.g.

새를 프로그래밍하려고 합니다

새는 여러 종류가 있습니다.

우선 기본적으로 날개짓을 하는데 날수도있고 날지 못할수도 있습니다.

 

 

디자인 원칙을 적용하여 인터페이스 위주의 구현을 해보겠습니다.

 

 

인터페이스에는 날개짓한다는 Fly 함수가 정의되어있고(캡슐화)

날수있는 class와 날지 못하는 class로 분리하여 분류합니다

해당 class는 모두 Fly라는 함수가 정의된 인터페이스를 상속합니다

 

 

이렇게 작성할 경우

나는 새, 날지 못하는 새 모두 동일한 행위(fly함수)에 대하여 인터페이스를 채택하고

각 class에 맞는 객체를 생성하면 분류된 기능과 캡슐화된 기능이

분기 처리되어 유지보수가 쉬워집니다.

 

protocol Fly { 
    func fly()
}

class Flyable: Fly {
    func fly() {
        print("날다")
    }
}

class Flydisable: Fly {
    func fly() {
        print("못날아")
    }
}

class Bird {
    private var interface: Fly
    
    init(interface: Fly) {
        self.interface = interface
    }
    
    func setInterface(interface: Fly){
        self.interface = interface
    }
    
    func birdFly() {
        interface.fly()
    }
}

 

 

이렇게 작성하고

 

import UIKit

class ViewController: UIViewController {

    var duck: Bird = Bird(interface: Flyable())
    var chicken: Bird = Bird(interface: Flydisable())
    
    override func viewDidLoad() {
        super.viewDidLoad()
        duck.birdFly() // 1
        chicken.birdFly() // 2
    }
}

 

 

코드를 실행해 보면

 

이런식으로 잘 나오는 모습입니다.

 

 

 

 

import UIKit

class ViewController: UIViewController {

    var duck: Bird = Bird(interface: Flyable())
    var chicken: Bird = Bird(interface: Flydisable())
    
    override func viewDidLoad() {
        super.viewDidLoad()
        duck.birdFly() // 1
        duck.setInterface(interface: Flydisable()) 
        duck.birdFly() // 2
        chicken.birdFly() // 3
    }
}

 

 

 

duck.setInterface 코드로 의존성 주입을 통해 값을 변경할 경우 (D.I. 패턴)

좀 더 안전하고 의존성 분리된 방식으로 값을 수정 할 수 있습니다.

 

 

 

 

 

Dependency Injection Pattern 이란

 

인터페이스를 채택하여 외부에서 인터페이스 값을 주입하여

인터페이스만 채택하고 값은 갖고있지 않은 ViewModel의 내부 값을 변경하는 패턴입니다.

 

import Foundation

// DI 인터페이스입니다. getter와 setter가 있는 int형 변수 num을 가지고 있습니다.
protocol DependencyIndependentInterface {
    var num : Int { get set }
}

// DI 인터페이스를 상속하는 Model 객체 입니다. 상속받은 num에 10을 set 합니다.
class Model: DependencyIndependentInterface {
    var num: Int = 10
}


// DI 인터페이스를 인자로 받아 내부 변수를 생성하는 뷰모델 객체 입니다.
class ViewModel {
    var internalVarialbe: DependencyIndependentInterface
    init(withExternalVariable variable: DependencyIndependentInterface){
        self.internalVarialbe = variable
    }
}

let test01 = ViewModel(withExternalVariable: Model())
print(test01.internalVarialbe.num)

 

 

ViewModel test01의 내부값이 10으로 출력되는 모습

 

 

 

 

이런 의존성 분리(DI)와 캡슐화 그리고 인터페이스를 통한 구현(전략패턴)으로

코드의 재사용성, 확장성, 가독성, 유지보수성이 향상되고 표준화된 설계가 가능합니다.

 

 

 

추가로

디자인 패턴은 도구일뿐 과도하게 사용하면 오히려 코드를 복잡하게 만들 수 있으며,

각 상황에 적절한 패턴을 선택하는 것이 중요하다고 합니다

 

 

 

"상속보다는 조합(Composition)을 사용해라"

 

 

수정 가능성이 있는 fly() 함수의 내부까지 구현하여 상속하기 보다는

날수도 날지 못할수도 있는 fly()를 인터페이스로 따로 구분하여,

fly() 함수가 포함된 인터페이스를 채택하는

날수있는 class와 날지못하는 class를 필요한 부분에 가져다 쓸수있다 (조합)

 

이런 식의 전략패턴을 사용하면 상속 보다는 조합을 사용한다고 볼 수 있겠습니다.