[Design Pattern] Strategy Pattern - 전략 패턴

Strategy Pattern

스트래티지 패턴(Strategy Pattern)은 행위 패턴(Behavioral Pattern)의 일종으로, 알고리즘 군을 정의하고, 각 알고리즘을 캡슐화하며, 이들을 상호 교환 가능하게 만드는 패턴입니다.

• 즉, 알고리즘을 클라이언트에서 분리하여 독립적으로 변경할 수 있게 합니다.
• 이를 통해 클라이언트 코드의 변경 없이 알고리즘을 쉽게 교체할 수 있습니다.

• Runtime 중에 알고리즘을 선택하게 합니다.
• 하나의 알고리즘을 직접 Implementing 하는 대신 어떠한 알고리즘을 사용할지 Runtime Instruction을 받습니다.
• Animal을 받아서 Speaking을 시키는 함수
• 동물은 고양이 혹은 사자
• 고양이가 들어오면 “meow”
• 사자가 들어오면 “roar”
• 함수는 이 상태로 고정이 된 상태이며 어떤 동물이 어떤말을 하지는 Runtime에 결정됩니다.

 

class Animal:
    def speak(self):
        pass

class Cat(Animal):
    def speak(self):
        print("meow")

class Lion(Animal):
    def speak(self):
        print("roar")

def makeSpeak(animal: Animal):
    animal.speak()

def createAnimal(input_str: str) -> Animal:
    if input_str == "cat":
        return Cat()
    elif input_str == "lion":
        return Lion()

• Animal class
  • Base Interface
  • speak 함수를 가지고 있습니다.
• Cat class
  • Animal 상속받고
  • speak를 통해 "meow" 를 출력합니다.
• Lion class
  • Animal 상속받음
  • speak를 통해 "roar" 를 출력합니다.
• makeSpeak()
  • argument로 Animal Interface 를 받습니다.
  • Animal.speak()를 통해 말을 하게 합니다.
• createAnimal()
  • argument로 string 형태의 input_str 받고 Animal object return 합니다.
  • input_str이 "cat"일 경우 Cat object return
  • input_str이 "lion"일 경우 Lion object return

 

# 사용 예시
input_str = input('choose animal: ')

animal = createAnimal(input_str)
makeSpeak(animal)

# 실행 결과
# choose animal: cat
# meow
# choose animal: lion
# roar

• 사용 예시
  • Runtime에 input을 받을 수 있는 변수인 input_str
  • createAnimal을 통해 input_str에 따라 animal을 생성합니다.
  • 그 다음 animal에게 makeSpeak을 통해 말을 겁니다.
  • 상단 코드 실행시키면 Runtime 중에 어떤 동물을 받을지 물어봅니다.
• 결과
  • input_str이 "cat"이면 "meow"
  • input_str이 "lion"이면 "roar"

---

• 런타임 중에 알고리즘을 선택하여 객체 동작을 실시간으로 적용할 수 있습니다.
• 전략이란 기능, 동작, 알고리즘 등 특정한 목표를 수행하기 위한 행동을 의미합니다.
• 알고리즘 변경이 빈번하게 필요한 경우에 적합합니다.

 

• Strategy: 전략을 이용하기 위한 APi를 결정합니다.
• ConcreteStrategy: API를 실제로 구현하며, 여기서 구체적인 전략 (작전, 방책, 방법, 알고리즘)을 실제로 프로그래밍합니다.
• Context: Strategy를 담아내고 이용하는 역할을 하는데, ConcreteStrategy의 인스턴스를 가지고 있으며 필요에 따라 그것을 이용합니다.

 

from abc import *

class IStrategy(metaclass=ABCMeta):
    @abstractmethod
    def doSomething(self):
        pass

class ConcreteStrategyA(IStrategy):
    def doSomething(self):
        print("do something using A")

class ConcreteStrategyB(IStrategy):
    def doSomething(self):
        print("do something using B")

class Context:
    def __init__(self):
        self.strategy = 0  # 추상화된 전략을 가지고 있음

    def setStrategy(self, stgy: IStrategy):
        self.strategy = stgy  # 설정된 전략에 따라 행동함

    def do(self):
        self.strategy.doSomething()

# 클라이언트 코드
context = Context()
context.setStrategy(ConcreteStrategyA())
context.do()
context.setStrategy(ConcreteStrategyB())
context.do()

• 전략 알고리즘의 여러 버전 또는 변형이 필요할 때 클래스를 통해 관리합니다.
• 알고리즘의 코드가 노출 되어서는 안되는 경우에 사용합니다.
• 알고리즘의 동작이 런타임에 실시간으로 교체되어야 할 때 사용합니다.

---

Strategy Pattern을 사용하지 않은 사례

weapon = {
    "SWORD": 0,
    "SHIELD": 1,
    "CROSSBOW": 2
}

class TakeWeapon:
    def __init__(self):
        self.state = 0

    def setState(self, state):
        self.state = state

    def attack(self):
        if self.state == weapon["SWORD"]:
            print("검을 휘두르다")
        elif self.state == weapon["SHIELD"]:
            print("방패로 밀치다")
        elif self.state == weapon["CROSSBOW"]:
            print("석궁을 쏘다")

# 플레이어 손에 무기 착용 전략을 설정
hand = TakeWeapon()

# 플레이어가 검을 들도록 전략 설정
hand.setState(weapon["SWORD"])
hand.attack()  # "검을 휘두르다"

# 플레이어가 방패를 들도록 전략 변경
hand.setState(weapon["SHIELD"])
hand.attack()  # "방패로 밀치다"

# 플레이어가 석궁을 들도록 전략 변경
hand.setState(weapon["CROSSBOW"])
hand.attack()  # "석궁을 쏘다"

• TakeWeapon 클래스는 하위 메서드(함수)에 의존되어 있으며, 공격 방법이 추가되면 TakeWeapon 클래스도 수정해야 하므로 if else 구문이 많아질 수 있습니다.

---

Strategy Pattern을 사용한 사례

# Strategy pattern implementation using DIP and polymorphism
class TakeWeaponStrategy:
    def __init__(self):
        self.weapon = 0

    def setWeapon(self, weapon: Weapon):
        self.weapon = weapon

    def attack(self):
        self.weapon.offensive()

# Abstract Weapon class
from abc import *

class Weapon(metaclass=ABCMeta):
    @abstractmethod
    def offensive(self):
        pass

# Concrete Weapon classes implementing the abstract Weapon class
class Sword(Weapon):
    def offensive(self):
        print("칼을 휘두르다")

class Shield(Weapon):
    def offensive(self):
        print("방패로 밀치다")

class CrossBow(Weapon):
    def offensive(self):
        print("석궁을 쏘다")

# Setting the strategies for the player
hand = TakeWeaponStrategy()
hand.setWeapon(Sword())
hand.attack()  # 칼을 휘두르다
hand.setWeapon(Shield())
hand.attack()  # 방패로 밀치다
hand.setWeapon(CrossBow())
hand.attack()  # 석궁을 쏘다

• Dependency Inversion Principle(DIP) 및 다형성을 통한 실시간 공격 전략의 교체가 가능합니다.
• TakeWeaponStrategy 함수 수정이 필요 없습니다.

---

실행중에 교체도 가능

• Strategy 패턴을 사용하면 프로그램의 동작 중에 ConcreteStrategy 역할의 클래스를 교체할 수도 있습니다.
• 가령, 메모리가 적은 환경에서는 Slow but Less Memory Strategy를 사용하고, 메모리가 많은 환경에서는 Fast but More Memory Strategy를 사용하는 것도 생각해볼 수 있습니다.
• 또는 복잡한 계산이 필요한 태스크가 있다고 가정할 때,
  • 버그가 있을지도 모르는 고속의 알고리즘 vs 저속이지만 확실한 계산을 실행하는 알고리즘 입니다.

---

일부러 Strategy Pattern을 만들 필요가 있을까?

보통 프로그래밍을 할 때 메소드 내부에 동화된 형태로 알고리즘을 구현하기 쉽습니다.

• 그러나, Strategy 패턴에서는 알고리즘의 부분을 다른 부분과 의식적으로 분리해서 알고리즘의 API부분만을 고정합니다.
• 그리고, 프로그램에서 위임에 의해 알고리즘을 이용합니다.
• 이것은 프로그램을 복잡하게 만드는 것처럼 보이지만 실제로는 그렇지 않습니다.
  • 예를 들어, 알고리즘을 개량해서 조금 더 빠르게 하고 싶다고 가정해보면, Strategy 패턴을 사용하면 Strategy 역할의 API를 변경하지 않도록 주의하고 ConcreteStrategy의 역할만을 수정하면 됩니다.
• 더욱이 위임이라는 느슨한 연결을 사용하고 있으므로 알고리즘을 용이하게 교환할 수 있고, 가령 원래의 알고리즘과 개선한 알고리즘의 속도를 비교하고 싶은 경우에도 간단하게 교체해서 시험할 수 있습니다.