디자인 패턴

rada·2023년 4월 4일

개발

목록 보기

12/14

디자인 패턴

디자인 패턴이란 프로그램을 설계할 때 발생했던 문제점들을 객체 간의 상호 관계 등을 이용하여 해결할 수 있도록 하나의 '규약'형태로 만들어 놓은 것을 의미합니다.

싱글톤 패턴

싱글톤 패턴(singleton pattern)은 하나의 클래스에 오직 하나의 인스턴스만 가지는 패턴입니다. 보통 데이터베이스 연결 모듈에 많이 사용합니다.
하나의 인스턴스를 만들어 놓고 해당 인스턴스를 다른 모듈들이 공유하며 사용하기 때문에 인스턴스를 생성할 때 드는 비용이 줄어드는 장점이 있습니다. 하지만 의존성이 높아진다는 단점이 있습니다

싱글톤 패턴의 단점

싱글톤 패턴은 TDD(Test Driven Development)를 할 때 걸림돌이 됩니다. TDD를 할때 단위 테스트를 주로 하는데, 단위 테스트는 테스트가 서로 독립적이어야 하며 테스트를 어떤 순서로든 실행할 수 있어야 합니다.
하지만 싱글톤 패턴은 미리 생성된 하나의 인스턴스를 기반으로 구현하는 패턴이므로 각 테스트마다 '독립적인'인스턴스를 만들기가 어렵습니다.

의존성 주입

또한, 싱글톤 패턴은 사용하기가 쉽고 굉장히 실용적이지만 모듈간의 결합을 강하게 만들 수 있다는 단점이 있습니다. 이때 의존성 주입(DI, Dependency Injection)을 통해 모듈간의 결합을 조금 더 느슨하게 만들어 해결할 수 있습니다.
참고로 의존성이란 종속성이라고도 하며 A가 B에 의존성이 있다는 것은 B의 변경 사항에 대해 A 또한 변해야 된다는 것을 의미합니다.

A sample UML class and sequence diagram for the Dependency Injection design pattern.

메인 모듈(main module)이 '직접' 다른 하위 모듈에 대한 의존성을 주기보다는 중간에 의존성 주입자(dependency injector)가 이 부분을 가로채 메인 모듈이 '간접'적으로 의존성을 주입하는 방식입니다
이를 통해 메인 모듈(상위 모듈)은 하위 모듈에 대한 의존성이 떨어지게 됩니다. 참고로 이를 '디커플링이 된다'고도 합니다.

의존성 주입의 장점

모듈들을 쉽게 교체할 수 있는 구조가 되어 테스팅하기 쉽고 마이그레이션하기도 수월합니다. 또한, 구현할 때 추상화 레이어를 넣고 이를 기반으로 구현체를 넣어 주기 때문에 애플리케이션 의존성 방향이 일관되고, 애플리케이션을 쉽게 추론할 수 있으며, 모듈 간의 관계들이 조금 더 명확해집니다.

의존성 주입의 단점

모듈들이 더욱더 분리되므로 클래스 수가 늘어나 복잡성이 증가될 수 있으며 약간의 런타임 페널티가 생기기도 합니다.

의존성 주입 원칙

의존성 주입은 '상위 모듈은 하위 모듈에서 어떤 것도 가져오지 않아야 합니다.
또한, 둘 다 추상화에 의존해야 하며, 이때 추상화는 세부 사항에 의존하지 말아야 합니다.'라는 의존성 주입 원칙을 지켜주면서 만들어야 합니다.

팩토리 패턴

팩토리 패턴(factory patturn)은 객체를 사용하는 코드에서 객체 생성 부분을 떼어내 추상화한 패턴이자 상속 관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고, 하위 클래스에서 객체 생성에 관한 구체적인 내용을 결정하는 패턴입니다.
상위 클래스와 하위 클래스가 분리되기 때문에 느슨한 결합을 가지며 상위 클래스에서는 인스턴스 생성방식에 대해 전혀 알 필요가 없기 때문에 더 많은 유연성을 갖게 됩니다.
그리고 객체 생성 로직이 따로 떼어져 있기 때문에 코드를 리팩터링하더라도 한 곳만 고칠수 있게 되니 유지 보수성이 증가됩니다.
예를 들어 라떼 레시피와 아메리카노 레시피, 우유 레시피라는 구체적인 내용이 들어 있는 하위 클래스가 컨베이어 벨트를 통해 전달되고 상위 클래스인 바리스타 공장에서 이 레시피들을 토대로 우유 등을 생산하는 생산 공정을 생각하면 됩니다.

자바스크립트의 팩토리 패턴

자바스크립트에서 팩토리 패턴을 구현한다면 간단하게 new Object()로 구현할 수 있습니다.

const num = new Object(42)
const str = new Object('abc');
num.constructor.name; // Number
str.constructor.name; // String

숫자를 전달하거나 문자열을 전달함에 따라 다른 타입의 객체를 생성하는 것을 볼 수 있습니다. 즉, 전달받은 값에 따라 다른 객체를 생성하며 인스턴스의 타입 등을 정합니다.
커피 팩토리를 기반으로 라떼 등을 생산하는 코드를 구축해보겠습니다.

class Latte {
	constructor(){
    	this.name = 'latte'
    }
}
class Espresso{
	constructor(){
    	this.name = 'espresso'
    }
}
class LatteFatory {
	static createCoffee(){
    	return new Latte()
    }
}
class EspressoFactory{
	static createCoffee(){
    	return new Espresso()
    }
}
const factoryList = {LatteFactory, EspressoFactory}

class CoffeeFactory {
	static createCoffee(type){
    	const factory = factoryList[type]
        return factory.createCoffee()
    }
}
const main = () => {
	//라떼 커피를 주문한다.
  const coffee = CoffeeFactory.createCoffee("LatteFactory")
  //커피 이름을 부른다.
  console.log('coffee.name') //latte
}
main();

CoffeeFactory라는 상위 클래스가 중요한 뼈대를 결정하고 하위 클래스인 LatteFactory가 구체적인 내용을 결정하고 있습니다.
참고로 이는 의존성 주입이라고도 볼 수 있습니다. CoffeeFactory에서 LatteFactory의 인스턴스를 생성하는 것이 아닌 LatteFactory에서 생성한 인스턴스를 CoffeeFactory에 주입하고 있기 때문이죠.
또한, CoffeFactory를 보면 static으로 createCoffee() 정적 메서드를 정의한 것을 알수 있는데, 정적 메서드를 쓰면 클래스의 인스턴스 없이 호출이 가능하여 메모리 절약을 할 수 있고 개별 인스턴스에 묶이지 않으며 클래스 내의 함수를 정의할 수 있는 장점이 있습니다.

자바의 팩토리 패턴

이를 자바로 구현하면 다음과 같습니다.

abstract class Coffee{
	public abstract in getPrice();
    
    @override
    public String toString() {
    	return "Hi this coffee is " + this.getPrice();
    }
}
class CoffeeFactory {
	public static Coffe getCoffee(String type, int price){
    	if ("Latte".equalsIgnoreCase(type)) return new Latte(price);
        else if ("Americano".equalsIgnoreCase(type)) returm new Americano(price);
        else {
	        return new DefaultCoffe();
        }
    }
}
class DefaultCoffee extends Coffee {
	private int price;
    
    public DefaultCoffee(){
    	this.price = -1;
    }
    
    @override
    public int getPrice(){
    	return this.price;
    }
}
class Latte extends Coffee {
	private int price;
    
    public Latte(int price){
    	this.price = price;
    }
    @override
    public int getPrice(){
    	return this.price;
    }
}
class Americano extends Coffee{
	private int price;
    
    public Americano(int price){
    	this.price = price;
    }
    @override
    public int getPrice(){
   		return this.price;
    }
}
public class HelloWorld {
	public static void main(String[] args){
    	Coffee latte = CoffeeFactory.getCoffee("Latte", 4000);
        Coffee ame = CoffeeFactory.getCoffee("Americano", 3000);
    	System.out.printIn("Factory latte :: " + latte);
        System.out.printIn("Factory ame :: " + ame);
    }
}
/*
Factory latte : Hi this coffee is 4000
Factory ame : Hi this coffe is 3000
*/

지금 보면 if ("Latte".equalsIgnoreCase(type))을 통해 문자열 비교 기반으로 로직이 구성됨을 볼 수 있는데, 이는 Enum 또는 Map을 이용하여 if문을 쓰지 않고 매핑해서 할 수도 있습니다.

Enum
상수의 집합을 정의할 때 사용되는 타입이다. 상수나 메서드 등을 집어넣어서 관리하며 코드를 리팩터링할 때 해당 집합에 관한 로직 수정 시 이 부분만 수정하면 되므로 코드 리팩터링 시 강점이 생긴다.

전략 패턴

전략패턴(strategy pattern)은 정책 패턴(policy pattern)이라고도 하며, 객체의 행위를 바꾸고 싶은 경우 '직접' 수정하지 않고 전략이라고 부르는 '캡슐화한 알고리즘'을 컨텍스트 안에서 바꿔주면서 상호 교체가 가능하게 만드는 패턴입니다.

우리가 어떤 것을 살 때 네이버페이, 카카오페이 등 다양한 방법으로 결제하듯이 어떤 아이템을 살 때 LUNACard로 사는 것과 KAKAOCard로 사는 것을 구현한 예제입니다. 결제 방식의 '전략'만 바꿔서 두가지 방식으로 결제하는것을 구현했습니다.

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
interface PaymrnyStrategy{
	public void pay(int amount);
}
class KAKAOCardStrategy implements PaymentStrategy{
	private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;
    
    public KAKAOCardStrategy(String nm, String ccNum, String cvv, String expiryDate) {
    	this.name = nm;
        this.cardNumber = ccNum;
        this.cvv = cvv;
        this.dateOfExpiry = expiryDate;
    }
    
    @override
    public void pay(int amount){
    	System.out.printIn(amount + " paid using KAKAOCard.");
    }
}
class LUNACardStrategy implements PaymentStrategy{
	private String emailId;
    private String password;
    
    public LUNACardStrategy(String email, String pwd){
    	this.emailId = email;
        this.password = pwd;        
    }
    @override
    public void pay(int amount){
        System.out.printIn(amount + " paid using LUNACard.");
    }
}
class Item {
	private String name;
    private int price;
    public Item(String name, int cost){
    	this.name = name;
        this.price = cost;
    }
    public int getName(){
    	return name;
    }
    public int getPrice(){
    	return price;
    }
}
class ShoppingCart{
	List<item> items;
    public ShoppingCart(){
    	this.items = new ArrayList<item>();
    }
    public void addItem(Item item){
    	this.items.add(item);
    }
    public void removeItem(Item item){
    	this.items.remove(item);
    }
    public int calculateTotal(){
    	int sum = 0;
        for (Item item : items){
        	sum += item.getPrice();
        }
        return sum;
    }
    public void pay(PaymemtStrategy paymentMethod){
    	int amount = calculateTotal();
        paymentMethod.pay(amount);
    }
}
public class HelloWorld{
	public static void main(String[] args){
		ShoppingCart cart = new ShoppingCart();
        Item A = new Item("KundolA", 100);
        Item B = new Item("KundolB", 300);
		
        cart.addItem(A);
        cart.addItem(B);
        
        //pay by LUNACard
        cart.payy(new LUNACardStrategy("Kundol@example.com", "pukubababo"));
        
        //pay by KAKAOCard
        cart.pay(new KAKAOCardStrategy("Ju hongchul", "123456789". "123","12/01"));
    }
}	
/*
400 paid usingLUNACard.
400 paid using KAKAOCard.
*/