Encapsulate What Varies

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from abc import ABC, abstractmethod

# 인터페이스
class Logger(ABC):
    @abstractmethod
    def log(self, msg): pass

# 구현체 1
class FileLogger(Logger):
    def log(self, msg): print(f"파일 기록: {msg}")

# 구현체 2
class ConsoleLogger(Logger):
    def log(self, msg): print(f"콘솔 기록: {msg}")

# 클라이언트
def do_logging(logger: Logger):
    logger.log("로그 메시지")

# 사용 예시
do_logging(FileLogger())
do_logging(ConsoleLogger())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from abc import ABC, abstractmethod

# 전략 인터페이스
class ShippingStrategy(ABC):
    @abstractmethod
    def calculate(self, order):
        pass

# 구체적 전략 1
class FedExStrategy(ShippingStrategy):
    def calculate(self, order):
        return 10.0  # FedEx 배송비

# 구체적 전략 2
class UPSStrategy(ShippingStrategy):
    def calculate(self, order):
        return 8.0  # UPS 배송비

# 컨텍스트: 전략을 사용하는 주체
class ShippingCostCalculator:
    def __init__(self, strategy: ShippingStrategy):
        self.strategy = strategy  # 전략 객체 주입

    def calculate_cost(self, order):
        return self.strategy.calculate(order)

# 사용 예시
order = {"weight": 2}
calculator = ShippingCostCalculator(FedExStrategy())
print(calculator.calculate_cost(order))  # 10.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 인터페이스
class MessageSender:
    def send(self, msg):
        pass

# 서비스 구현체 1
class EmailSender(MessageSender):
    def send(self, msg):
        print("이메일 전송:", msg)

# 서비스 구현체 2
class SmsSender(MessageSender):
    def send(self, msg):
        print("SMS 전송:", msg)

# 클라이언트
class Notifier:
    def __init__(self, sender: MessageSender):  # 생성자 주입
        self.sender = sender

    def notify(self, msg):
        self.sender.send(msg)

# 인젝터 역할
notifier = Notifier(EmailSender())
notifier.notify("환영합니다!")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// 제품 인터페이스(여기서는 명시적 인터페이스 대신 메서드 규약)
class Notification {
  send(msg) {}
}

// 구체적 제품 1
class EmailNotification extends Notification {
  send(msg) { console.log("이메일:", msg); }
}

// 구체적 제품 2
class SMSNotification extends Notification {
  send(msg) { console.log("SMS:", msg); }
}

// 팩토리
class NotificationFactory {
  static create(type) {
    if (type === "email") return new EmailNotification();
    if (type === "sms") return new SMSNotification();
    throw new Error("알 수 없는 타입");
  }
}

// 사용 예시
const notifier = NotificationFactory.create("email");
notifier.send("가입을 환영합니다!");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 컴포넌트 인터페이스
class Coffee:
    def cost(self):
        return 2000  # 기본 커피 가격

# 데코레이터 베이스
class CoffeeDecorator(Coffee):
    def __init__(self, coffee):
        self.coffee = coffee

    def cost(self):
        return self.coffee.cost()

# 구체적 데코레이터
class MilkDecorator(CoffeeDecorator):
    def cost(self):
        return super().cost() + 500  # 우유 추가

class SugarDecorator(CoffeeDecorator):
    def cost(self):
        return super().cost() + 300  # 설탕 추가

# 사용 예시
coffee = Coffee()
milk_coffee = MilkDecorator(coffee)
sugar_milk_coffee = SugarDecorator(milk_coffee)
print(sugar_milk_coffee.cost())  # 2800

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// 플러그인 인터페이스(규약)
class Plugin {
  execute(data) {}
}

// 플러그인 구현
class PrintPlugin extends Plugin {
  execute(data) { console.log("출력:", data); }
}

// 코어 시스템
class CoreSystem {
  constructor() {
    this.plugins = [];
  }
  register(plugin) {
    this.plugins.push(plugin);
  }
  run(data) {
    this.plugins.forEach(plugin => plugin.execute(data));
  }
}

// 사용 예시
const core = new CoreSystem();
core.register(new PrintPlugin());
core.run("플러그인 테스트");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

// 주문 서비스 API
@RestController
@RequestMapping("/orders")
public class OrderController {
    @PostMapping
    public OrderResponse createOrder(@RequestBody OrderRequest request) {
        // 주문 생성 로직
    }
    
    @GetMapping("/{id}")
    public OrderResponse getOrder(@PathVariable String id) {
        // 주문 조회 로직
    }
}

// 결제 서비스 API
@RestController
@RequestMapping("/payments")
public class PaymentController {
    @PostMapping
    public PaymentResponse processPayment(@RequestBody PaymentRequest request) {
        // 결제 처리 로직
    }
}

// 주문 서비스에서 결제 서비스 호출
@Service
public class OrderService {
    private final RestTemplate restTemplate;
    private final String paymentServiceUrl;
    
    // 생략…
    
    public Order createOrder(OrderRequest request) {
        // 주문 생성
        Order order = // …
        
        // 결제 서비스 호출
        PaymentRequest paymentRequest = new PaymentRequest(order.getId(), request.getAmount());
        PaymentResponse response = restTemplate.postForObject(
            paymentServiceUrl + "/payments",
            paymentRequest,
            PaymentResponse.class
        );
        
        // 결제 결과 처리
        // …
        
        return order;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

// 스토리지 추상화
public interface StorageService {
    void store(String key, byte[] data);
    byte[] retrieve(String key);
    void delete(String key);
}

// AWS S3 구현
public class S3StorageService implements StorageService {
    private final AmazonS3 s3Client;
    private final String bucketName;
    
    // 생략…
    
    @Override
    public void store(String key, byte[] data) {
        s3Client.putObject(bucketName, key, new ByteArrayInputStream(data), new ObjectMetadata());
    }
    
    @Override
    public byte[] retrieve(String key) {
        S3Object object = s3Client.getObject(bucketName, key);
        return IOUtils.toByteArray(object.getObjectContent());
    }
    
    @Override
    public void delete(String key) {
        s3Client.deleteObject(bucketName, key);
    }
}

// 파일 시스템 구현
public class FileSystemStorageService implements StorageService {
    private final Path rootLocation;
    
    // 생략…
    
    @Override
    public void store(String key, byte[] data) {
        try {
            Files.write(rootLocation.resolve(key), data);
        } catch (IOException e) {
            throw new StorageException("Failed to store file", e);
        }
    }
    
    @Override
    public byte[] retrieve(String key) {
        try {
            return Files.readAllBytes(rootLocation.resolve(key));
        } catch (IOException e) {
            throw new StorageException("Failed to retrieve file", e);
        }
    }
    
    @Override
    public void delete(String key) {
        try {
            Files.delete(rootLocation.resolve(key));
        } catch (IOException e) {
            throw new StorageException("Failed to delete file", e);
        }
    }
}

// 서비스에서 사용
@Service
public class DocumentService {
    private final StorageService storageService;
    
    @Autowired
    public DocumentService(StorageService storageService) {
        this.storageService = storageService;
    }
    
    public void saveDocument(String id, byte[] content) {
        storageService.store("documents/" + id, content);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// 기능 플래그 서비스
public interface FeatureFlagService {
    boolean isEnabled(String featureName);
    boolean isEnabled(String featureName, String userId);
}

// 구현
@Service
public class FeatureFlagServiceImpl implements FeatureFlagService {
    private final FeatureFlagRepository repository;
    
    @Autowired
    public FeatureFlagServiceImpl(FeatureFlagRepository repository) {
        this.repository = repository;
    }
    
    @Override
    public boolean isEnabled(String featureName) {
        FeatureFlag flag = repository.findByName(featureName);
        return flag != null && flag.isEnabled();
    }
    
    @Override
    public boolean isEnabled(String featureName, String userId) {
        FeatureFlag flag = repository.findByName(featureName);
        if (flag == null || !flag.isEnabled()) {
            return false;
        }
        
        // 사용자별 점진적 출시 로직
        if (flag.getRolloutPercentage() < 100) {
            int hash = Math.abs(userId.hashCode()) % 100;
            return hash < flag.getRolloutPercentage();
        }
        
        return true;
    }
}

// 서비스에서 사용
@Service
public class PaymentService {
    private final FeatureFlagService featureFlagService;
    private final LegacyPaymentProcessor legacyProcessor;
    private final NewPaymentProcessor newProcessor;
    
    // 생략…
    
    public PaymentResult processPayment(String userId, Payment payment) {
        if (featureFlagService.isEnabled("new-payment-processor", userId)) {
            return newProcessor.process(payment);
        } else {
            return legacyProcessor.process(payment);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 구성 클래스
@Configuration
public class AppConfig {
    @Bean
    public PaymentGateway paymentGateway() {
        if (useStripe()) {
            return new StripePaymentGateway(stripeApiKey);
        } else {
            return new PayPalPaymentGateway(paypalClientId, paypalSecret);
        }
    }
    
    private boolean useStripe() {
        return "stripe".equals(environment.getProperty("payment.gateway"));
    }
}

// 서비스에서 사용
@Service
public class CheckoutService {
    private final PaymentGateway paymentGateway;
    
    @Autowired
    public CheckoutService(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
    
    public OrderResult checkout(ShoppingCart cart) {
        // 결제 처리
        PaymentResult result = paymentGateway.processPayment(
            cart.getCustomerId(),
            cart.getTotalAmount()
        );
        
        // 결과 처리
        // …
    }
}