[Swift 기초] 프로토콜 지향 프로그래밍 ( POP )

 

 

 

프로토콜 지향 프로그래밍

Protocol - Oriented Programming 

 

프로토콜 지향 프로그래밍 

흔히 알고 있는 객체 지향 프로그래밍 : 사물을 객체로 형성하여 공통점을 갖는 모든 곳에서 상속받는 객체 내부의 모든 로직을 캡슐화한다. 의도 하지 않아도 상속했다는 이유로 모든 속성과 행위를 공유해야하며, 복잡한 상속 구조를 지닌 클래스를 상속했다면 원하는 클래스를 참조해야 할 때 다운캐스팅을 해야 한다. 또한 큰 단점은 단 하나의 SuperClass만 상속할 수 있다는 점이다. 시간이 흐르면 기능도 확장하기 마련이므로 복잡도도 높아지고 관리도 어려워진다.

 

프로토콜 지향 프로그래밍 : 필요한 부분만 프로토콜로 분리해서 만들 수 있고 다중 프로토콜을 구현할 수 있다. 게다가 프로토콜 규칙을 class, struct, enum에 적용할 수 있기 때문에 확장 부분에서도 유연하다. 스위프트는 다른 언어와 달리 클래스로 구현된 타입보다는 대부분 구조체로 기본 타입이 구현되어 있다. 상속도 되지 않는 공통 기능을 가질 수 있는 방법에는 프로토콜과 익스텐션이 있다.

 

 

 프로토콜 구현

protocol Walkable {
     var isBarFoot: Bool { get set }
     
     func walk()
}

struct Person: Walkable {
     var isBareFoot: Bool
     var name: String
     
     func walk() {
          print("\(name)은 걷습니다")
     }
}

struct Animal: Walkable {
     var isBareFoot: Bool
     
     func walk() {
          print("\name)은 걷습니다")
     }
}

여기 Walkable 프로토콜이 있다. 이 프로토콜은 맨발인지 아닌지의 구분과 걸을 수 있능이 있다.

 

프로토콜 채택시 프로토콜이 요구하는 사항을 모두 구현해주어야 한다. 

 

예를 들어, 프로토콜에 많은 요구사항이 들어있고 많은 구조체에서 채택을 했다면 많은 중복된 코드를 사용해야 할 것이다. 

이를 방지하기 위해 프로토콜의 요구사항을 구현하지 않더라도 프로토콜의 익스텐션에 미리 프로토콜의 요구사항을 구현해 둘 수 있다.

protocol Walkable {
     var isBareFoot: Bool { get set }
     var speed: Double { get set }
     
     func walk(name: String)
}

extension Walkable {
     func walk(name: String) {
          if isBareFoot == true {
               print("\(name)은 맨발인 상태에 \(speed)속도로 걷습니다.")
          } else {
               print("\(name)은 신발인 상태에 \(speed)속도로 걷습니다.")
          }
     }
}

struct Person: Walkable {
     var isBareFoot: Bool
     var speed: Double
}

struct Animal: Walkable {
     var isBareFoot: Bool
     var speed: Double
}

let gilDong = Person(isBareFoot: false, speed: 5.0)
gilDong.walk(name:"길동")

let cat = Animal(isBareFoot: true, speed: 10.0)
cat.walk(name:"야옹")

 

위 코드에서 Person과 Animal은 Walkable의 요구사항인 walk(name:)을 구현하지 않았음에도 불구하고 오류가 발생하지 않는다.

 

프로토콜이 요구하는 사항을 미리 구현해 둘 수 있다면 중복된 코드를 피할 수 있다. 구현을 잘해둔다면 프로토콜 채택만으로도 그 타입의 기능이 추가되어 사용할 수 있는 것이다.

protocol Walkable {
     func walk()
}

extension Walkable {
     func walk() {
          print("걷다")
     }
}

protocol Flyable {
     func fly()
}

extension Flyable {
     func fly() {
          print("날다")
     }
}

protocol Runable {
     func run()
}

extension Runable {
	 func run() {
          print("뛰다")
     }
}

struct Person: Walkable, Runable {}

let gilDong = Person()
gilDong.walk()

struct Bird: Flyable, Walkable, Runable {}

let bird = Bird()
bird.fly()
bird.walk()
bird.run()

 

포로토콜 채택만으로도 그 기능을 사용할 수 있게 프로토콜 구현을 잘 해두는게 프로토콜 지향 프로그래밍에서 가장 중요하다.

또한 객체 지향 프로그래밍의 SuperClass와 달리, 기능들을 분리하여, Protocol extension을 생성할 수 있다. 이는 SuperClass 단일화 문제점에 대한 해결책이라고 볼 수 있다.

 

 

---

조금 더 자세히 들여다보자

✅ Protocol Oriented Programming 탄생배경

일반적으로 OOP에서 클래스의 상속 개념을 통해 공통 기능들을 모듈화하여 사용할 수 있었으나, 구조체 혹은 열거형의 경우에는 상속이 불가하기에 같은 타입에 대해서 공통적인 기능 구현을 위해서는 다른 방법을 이용해야 했다.

 

이를 해결하기 위한 방안이 Appe WWDC15( Swift 2 )에서 Extension이 발표되었다.

Protocol ( 청사진 ) 을 구현하고 Extension으로 해당 프로토콜의 기능을 확장하는 형태로 사용한다.

이를 프로토콜 초기구현 ( Protocol Default Implementation ) 이라고 한다. 

 

 

✅ POP의 장점

• 코드의 중복을 최소화
• 가볍고 안전하다.
  • 상속과 달리 필요한 것만 골라서 사용할 수 있다.
  • 상속의 경우, 참조타입이므로 참조 추적을 위한 비용이 많이 발생하기 때문에 속도면에서는 다소 느리다.
• 값 타입의 상속 효과
  • 공통된 기능을 쉽게 구현할 수 있다.
• 수평적인 확장 기능
• 제네릭의 활용

✅ 프로토콜 ( Protocol )

프로토콜은 특정 기능 수행에 필수적인 요소를 정의한 청사진(blueprint)이다.
프로토콜을 만족시키는 타입을 프로토콜을 따른다(conform)고 말한다.
프로토콜에 필수 구현을 추가하거나 추가적인 기능을 더하기 위해 프로토콜을 확장(extend) 하는것이 가능하다. 

 

 

✅ 프로토콜 문법

protocol SomeProtocol {
     // protocol definition goes here
}

 

✅ 프로퍼티 요구사항

protocol SomeProtocol {
     var mustBeSettle: Int { get set }
     var doesNotToBeSettable: Int { get }
}

프로토콜에서는 프로퍼티의 타입 그리고 gettable, settable을 명시한다. 

필수 프로퍼티는 항상 var로 선언해야한다.

 

protocol AnotherProtocol {
     static var someTypeProperty: Int { get set }
}

타입 프로퍼티는 static 키워드를 적어 선언한다. 

 

✅ 메소드 요구사항

protocol someProtocol {
     static var someTypeMethod()
}

필수 메소드 지정시 함수명과 반환값을 지정할 수 있고, 구현에 사용하는 괄호는 적지 않아도 된다.

 

 

✅ 프로토콜 초기 구현 ( Protocol Default Implementation )

extension으로 protocol에 정의된 것들을 미리 구현함으로서 해당 protocl을 구현하는 대상들이 코드의 중복을 피할 수 있다.

// 프로토콜 정의
protocol Person {
     var name: String? { get }
     var age: Int? { get }
     
     func getName() -> String?
     func getAge() -> Int?
}

// 프로토콜 기능 확장
extension Person {
	func getName() -> String? {
         return self.name
    }
    
    func getAge() -> Int? {
         return self.age
    }
}

 

위 설명대로 protocl에는 선언부(정의)만 적어주고 해당 기능을 확장(extension) 해주었다.

 

struct Student: Person {
     var name: String?
     var age: Int?
     
     init(name: String?, age: Int?) {
          self.name = name
          self.age = age
     }
}

 

이어서 Student 구조체가 Person 프로토콜을 채택(준수) 한다.

let gilDong = Student(name: "gilDong", age: 25)
print(gilDong.getName()) // gilDong

Stduent 구조체를 초기화하고, .(dot)문법을 통해 getName 메소드를 호출하면 이름이 출력된다.