전략 패턴(Strategy Pattern)

시작하며

---

안녕하세요. 개발자 stark입니다!

개발을 하다 보면 동일한 기능을 다양한 방법으로 구현해야 하는 상황이 종종 있습니다. 이때 전략 패턴(Strategy Pattern)을 사용하면 코드 구조를 유연하게 하고 재사용성을 높일 수 있습니다. 이번 포스팅에서는 전략 패턴의 개념부터 시작해서 간단한 자바 코드 예제와 스프링 기반 예제까지 살펴봅시다. 디자인 원칙인 '개방-폐쇄 원칙(OCP)'과 '전략 패턴'의 연관성도 함께 설명하여, 자바 백엔드 개발자뿐만 아니라 개발에 입문하시는 분들에게도 도움이 되었으면 좋겠습니다.

 

 

전략 패턴의 정의와 목적 (OCP와의 관련성)

---

전략 패턴은 알고리즘 집합을 정의하고 각각을 캡슐화하여, 이들 알고리즘을 상호 교체 가능하게 만드는 디자인 패턴입니다. 쉽게 말해, 실행 시간에 알고리즘을 선택할 수 있도록 '동적 교체'를 지원하는 패턴입니다​. 예를 들어 정렬(sorting)을 하는 기능이 있을 때, 버블 정렬, 퀵 정렬 등의 알고리즘을 각각 별도의 “전략(strategy)”으로 만들어두고 상황에 맞게 선택해서 사용할 수 있습니다. 이러한 방식은 코드에 if-else나 switch문을 여러 개 작성하여 분기하지 않아도 되므로 코드가 깔끔해지고 유지보수가 쉬워집니다.

 

전략 패턴의 가장 큰 목적 중 하나는 '유연한 확장'입니다. 새로운 알고리즘(전략)을 추가하더라도 기존 코드(컨텍스트나 다른 전략들)를 수정하지 않고 확장할 수 있습니다. 이는 SOLID 원칙 중 하나인 '개방-폐쇄 원칙(OCP)'을 잘 준수하는 설계라고 볼 수 있습니다. 개방-폐쇄 원칙이란 “소프트웨어 요소는 확장에는 열려 있고, 변경에는 닫혀 있어야 한다”는 원칙으로, 기존 코드를 수정하지 않으면서 새로운 기능을 추가할 수 있어야 함을 뜻합니다​.

 

전략 패턴을 적용하면 코드 구조를 변경하지 않고도 새로운 알고리즘 클래스를 추가하여 기능을 확장할 수 있으므로 OCP를 실현하는 데 도움이 됩니다. 또한 전략 패턴은 의존성 역전 원칙(DIP)과 인터페이스 분리 원칙(ISP)과도 관련이 있는데, 구체 구현이 아닌 추상 인터페이스에 의존하고 전략 인터페이스를 통해 알고리즘 집합을 분리하기 때문입니다.

 

요약하면, 전략 패턴은 변하는 부분(알고리즘 구현)을 캡슐화하여 변경에 유연한 코드를 만들기 위한 패턴입니다.

 

 

전략 패턴의 구조 (인터페이스, 구현체, 컨텍스트)

---

전략 패턴의 UML 다이어그램

전략 패턴 UML 다이어그램

위 그림에서 Context 클래스는 Strategy 인터페이스 타입의 전략 객체(strategy)를 참조하여 사용합니다. Strategy는 알고리즘을 추상화한 전략 인터페이스이고, ConcreteStrategyA와 ConcreteStrategyB는 Strategy를 구현한 '구체 전략 클래스들'입니다. Context는 구체적인 전략 구현에 대해서는 모르며, 단지 Strategy 인터페이스를 통해서만 알고리즘을 실행합니다. 이렇게 함으로써 새로운 전략 클래스를 추가하더라도 Context의 코드는 수정할 필요가 없게 되어 확장에 열려 있고 변경에는 닫혀있는 구조(OCP 준수)가 됩니다.

 

전략 패턴의 구성 요소를 정리하면 다음과 같습니다.

 

Strategy (전략 인터페이스)

알고리즘들을 추상화한 인터페이스로, 공통 메서드를 정의합니다. 예를 들어 execute()나 doStrategy() 등의 메서드를 가질 수 있습니다.

 

ConcreteStrategy (구체 전략)

Strategy 인터페이스를 구현한 클래스들로 각각 개별적인 알고리즘을 담고 있습니다. 예를 들어 정렬 알고리즘이라면 BubbleSortStrategy, QuickSortStrategy 등이 여기에 해당합니다. 각 클래스는 Strategy의 메서드를 자신의 방식으로 구현합니다.

 

Context (문맥)

Strategy 인터페이스를 사용하는 클래스입니다. 내부에 Strategy 타입을 합성(composition)하여 가지고 있으며, 필요에 따라 전략을 바꿔서 사용할 수 있습니다. 자체적으로는 구체적인 알고리즘을 구현하지 않고, 전략 객체에 해당 작업을 위임(delegation)합니다. 참고로 여기서 말하는 합성(composition)은 “클래스가 다른 클래스의 객체를 필드(멤버 변수)로 가지고 있는 것”을 뜻합니다. 즉, 어떤 기능을 상속이 아닌 포함(참조)을 통해 사용하는 방식입니다.

 

Client (클라이언트)

전략을 지정하는 주체입니다. 클라이언트 코드는 컨텍스트에 원하는 전략 객체를 주입하거나 설정하여 사용합니다. 예컨대 사용자가 원하는 정렬 방법을 고르게 한다면, 그 입력을 받아 클라이언트 코드가 컨텍스트에 해당 전략을 세팅합니다. (스프링이라면 설정이나 DI 컨테이너가 클라이언트 역할을 일부 담당하기도 합니다.)

 

이러한 구조 덕분에 상속보다는 구성(composition)을 활용하여 기능을 구현하며, 필요시 전략 교체를 통해 동작을 변경할 수 있습니다. 다음 섹션에서 실제 자바 코드로 이 구조를 구현해 보겠습니다.

 

 

자바 예제: 전략 패턴을 적용한 결제 서비스

---

Strategy (전략 인터페이스)

• 다양한 알고리즘을 추상화한 공통 인터페이스
• 모든 구체적인 전략이 구현해야 하는 메서드(execute() -> pay()) 정의

// 전략 인터페이스
public interface PaymentStrategy {
    void pay(int amount);
}

ConcreteStrategy (구체 전략)

• Strategy 인터페이스를 구현한 실제 클래스들
• 각각 서로 다른 알고리즘이나 동작 방식을 제공

// 구체적인 전략 클래스들
public class CreditCardStrategy implements PaymentStrategy {

    private String name;
    private String cardNumber;
    
    public CreditCardStrategy(String name, String cardNumber) {
        this.name = name;
        this.cardNumber = cardNumber;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + "원을 카드로 결제했습니다.");
    }
    
}

public class KakaoPayStrategy implements PaymentStrategy {

    private String accountId;
    
    public KakaoPayStrategy(String accountId) {
        this.accountId = accountId;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + "원을 카카오페이로 결제했습니다.");
    }
    
}

Context (문맥)

• Strategy 객체를 참조하고 사용하는 클래스
• 클라이언트로부터 전략을 주입받고, 실행 시점에 해당 전략을 사용
• 전략 객체에게 작업을 위임(delegate)

public class ShoppingCart {

    // strategy 인터페이스를 참조
    private PaymentStrategy paymentStrategy;
    
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    
    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
    
}

Client (클라이언트)

• 사용할 전략을 결정하고 Context에 주입하는 역할
• 스프링 환경에서는 DI 컨테이너가 이 역할을 일부 수행할 수 있음

public class PaymentExample {

    public static void main(String[] args) {
        // Context 객체 생성
        ShoppingCart cart = new ShoppingCart();
        
        // 카드 결제 전략 사용
        cart.setPaymentStrategy(new CreditCardStrategy("홍길동", "1234-5678-9012-3456"));
        cart.checkout(50000);
        
        // 카카오페이 결제 전략으로 변경
        cart.setPaymentStrategy(new KakaoPayStrategy("user@example.com"));
        cart.checkout(30000);
    }
    
}

클라이언트는 상황에 맞게 결제 전략을 선택하고, 컨텍스트(ShoppingCart)는 선택된 전략을 사용하여 결제를 진행합니다.

 

 

스프링에서 조건에 따른 전략 패턴 구현 예시

---

이번 예시는 사용자에게 알림을 보내는 다양한 방법(이메일, SMS, 푸시 알림)을 조건에 따라 선택하는 간단한 시스템입니다.

 

1. 전략 인터페이스

package com.example.notification.strategy;

public interface NotificationStrategy {
    void sendNotification(String userId, String message);
}

2. 구체적인 전략 구현

// 이메일 알림 전략
@Component("emailNotification")
public class EmailNotificationStrategy implements NotificationStrategy {
    
    @Override
    public void sendNotification(String userId, String message) {
        System.out.println("이메일로 알림 전송: " + message + " (To: " + userId + ")");
        // 실제 이메일 발송 로직
    }
}

// SMS 알림 전략
@Component("smsNotification")
public class SmsNotificationStrategy implements NotificationStrategy {
    
    @Override
    public void sendNotification(String userId, String message) {
        System.out.println("SMS로 알림 전송: " + message + " (To: " + userId + ")");
        // 실제 SMS 발송 로직
    }
}

// 푸시 알림 전략
@Component("pushNotification")
public class PushNotificationStrategy implements NotificationStrategy {
    
    @Override
    public void sendNotification(String userId, String message) {
        System.out.println("푸시 알림 전송: " + message + " (To: " + userId + ")");
        // 실제 푸시 알림 발송 로직
    }
}

3. 조건에 따른 전략 선택 서비스

@Service
public class NotificationService {
    
    private final Map<String, NotificationStrategy> strategies;
    
    // 생성자 주입으로 모든 알림 전략 빈들을 주입받음
    public NotificationService(Map<String, NotificationStrategy> strategies) {
        this.strategies = strategies;
    }
    
    // 사용자 설정에 따라 알림 전략 선택
    public void sendNotification(String userId, String message, String notificationType) {
        // 조건부 전략 선택 로직
        NotificationStrategy strategy;
        
        switch (notificationType) {
            case "EMAIL":
                strategy = strategies.get("emailNotification");
                break;
            case "SMS":
                strategy = strategies.get("smsNotification");
                break;
            case "PUSH":
                strategy = strategies.get("pushNotification");
                break;
            default:
                // 기본값으로 이메일 사용
                strategy = strategies.get("emailNotification");
        }
        
        // 선택된 전략으로 알림 발송
        strategy.sendNotification(userId, message);
    }
    
    // 시간대에 따라 자동으로 알림 전략 선택
    public void sendNotificationBasedOnTime(String userId, String message) {
        LocalTime now = LocalTime.now();
        int hour = now.getHour();
        
        // 야간에는 푸시 알림, 주간에는 이메일, 아침/저녁에는 SMS
        if (hour >= 22 || hour < 7) {
            // 야간에는 푸시 알림(조용함)
            strategies.get("pushNotification").sendNotification(userId, message);
        } else if (hour >= 9 && hour < 18) {
            // 업무 시간에는 이메일
            strategies.get("emailNotification").sendNotification(userId, message);
        } else {
            // 아침/저녁에는 SMS
            strategies.get("smsNotification").sendNotification(userId, message);
        }
    }
    
}

4. 컨트롤러 (간단한 사용 예시)

@RestController
@RequestMapping("/notifications")
public class NotificationController {
    
    private final NotificationService notificationService;
    
    public NotificationController(NotificationService notificationService) {
        this.notificationService = notificationService;
    }
    
    @PostMapping("/send")
    public ResponseEntity<String> sendNotification(@RequestParam String userId,
                                                   @RequestParam String message,
                                                   @RequestParam(required = false) String type) {
        if (type != null) {
            // 사용자가 지정한 알림 유형 사용
            notificationService.sendNotification(userId, message, type);
        } else {
            // 시간대에 따라 자동 선택
            notificationService.sendNotificationBasedOnTime(userId, message);
        }
        
        return ResponseEntity.ok("알림이 성공적으로 전송되었습니다.");
    }
    
}

5. 스프링 부트 애플리케이션 클래스

@SpringBootApplication
public class NotificationApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(NotificationApplication.class, args);
    }
    
    // 테스트를 위한 CommandLineRunner
    @Bean
    public CommandLineRunner demo(NotificationService service) {
        return args -> {
            // 직접 타입 지정
            service.sendNotification("user123", "안녕하세요, 이것은 테스트 메시지입니다.", "EMAIL");
            service.sendNotification("user123", "할인 이벤트 안내입니다.", "SMS");
            
            // 시간대 기반 자동 선택
            service.sendNotificationBasedOnTime("user123", "시간 기반 알림 테스트");
        };
    }
}

 

 

스프링의 DI와 전략 패턴은 어떻게 다를까?

---

스프링 DI를 사용하다 보면 인터페이스와 구현체를 분리하고 Bean을 생성자로 주입받는 구조를 흔히 사용합니다. 저는 한때 DI를 전략 패턴의 일종이라고 착각한 적이 있었습니다. 그런데 공부를 하며 자세히 생각해 보니 DI 사용이 '전략 패턴'을 의미하는 것이 아니었습니다. 전략 패턴이라고 부를 때는 여러 개의 구현체를 상황에 따라 바꿔가며 사용할 수 있어야 합니다. 단순히 하나의 구현체만 주입하여 사용하는 경우는 그저 인터페이스를 통한 느슨한 결합(loose coupling) 일뿐, 런타임에 알고리즘을 교체하는 유연성이 사용되지 않습니다.

 

다시 말해, 다음과 같은 코드는 전략 패턴이라고 부르기 어렵습니다.

@RequiredArgsConstructor
@Component
public class MyService {

    // 한 구현체만 주입
    private final SomeStrategy someStrategy;

    public void doSomething() {
        someStrategy.execute();  // 항상 동일한 someStrategy만 사용
    }
    
}

위 MyService는 SomeStrategy 인터페이스를 주입받았지만, 만약 실제로 주입된 구현체가 하나뿐이고 실행 중에 바뀌는 일 없이 고정되어 있다면 이는 '전략 패턴'이라기보다는 그냥 '의존성 주입을 활용한 구현'입니다. 전략 패턴의 핵심은 전략을 쉽게 교체할 수 있는 구조에 있으므로, 애플리케이션이 동작하면서 서로 다른 전략을 사용할 수 있거나, 설정에 따라 다른 구현체를 선택할 수 있는 구조여야 합니다.

 

전략 패턴을 제대로 활용하려면 컨텍스트 부분에서 setter 메서드나 생성자를 통해 외부에서 다른 전략을 주입하도록 열어두거나, 혹은 스프링이라면 여러 구현체 빈 중 하나를 선택하도록 설계해야 합니다. 예를 들어 앞서 예시로 작성한 NotificationService처럼 여러 구현을 받아 Map으로 관리하면서 조건에 따라 골라 쓰는 형태가 전형적인 전략 패턴 적용 사례입니다.

 

요약하면, 'DI는 수단이고 전략 패턴은 목적'입니다. DI를 사용하여 구현체 교체를 용이하게 하는 설계를 했다면 그것이 전략 패턴인 것이지, DI 자체가 전략 패턴은 아니라는 점을 기억합시다.

 

 

마무리하며

---

마지막으로 전략 패턴을 언제 사용하면 좋은지 정리해 보겠습니다.

 

1. 알고리즘(비즈니스 로직)이 여러 가지 방식으로 구현될 수 있고 상황에 따라 그중 하나를 선택해야 하는 경우.

• (예: 정렬 방식, 결제 수단, 로그 출력 방식, 데이터 압축 알고리즘 등)

2. 조건문이나 분기문이 너무 많아지는 코드를 리팩토링하고 싶을 때.

• 여러 if-else나 switch문으로 알고리즘을 분기하기보다는 전략 클래스로 분리하여 코드 복잡도를 낮출 수 있습니다.

3. 새로운 요구사항으로 알고리즘을 추가해야 할 가능성이 있을 때.

• 미리 전략 패턴으로 설계해 두면 새로운 전략 클래스를 추가하는 것만으로 기능을 확장할 수 있어 변경에 유연합니다.

4. 변경 가능성이 있는 행동을 캡슐화하여 다른 부분과 분리하고자 할 때.

• 이렇게 하면 변경 지점이 명확해지고, 다른 클래스나 모듈에 영향을 주지 않습니다.
  
  

다만, 전략으로 분리할 것들이 별로 없는데 인터페이스와 클래스를 너무 잘게 나눠서 전략 패턴을 적용하게 되면 오히려 코드가 복잡해질 수 있습니다. 또한 전략을 런타임에 교체할 일 없이 고정적으로 한 가지 구현만 쓰인다면 굳이 전략 패턴으로 설계할 이유가 없습니다. 상황에 맞게 '유연성 vs. 복잡성'의 트레이드오프를 고려해야 합니다.

 

긴 글 읽어주셔서 감사합니다 :)