디자인 패턴 1 (싱글톤 패턴, 팩토리 패턴, 전략 패턴)

 

1. 디자인 패턴

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

---

1) 싱글톤 패턴(singleton pattern)

하나의 클래스에 오직 하나의 인스턴스만 가지는 패턴

 

하나의 클래스를 기반으로 여러 개의 개별적인 인스턴스를 만들 수 있지만, 그렇게 하지 않고 하나의 클래스를 기반으로 단 하나의 인스턴스를 만들어 이를 기반으로 로직을 만드는데 쓰이며, 보통 데이터베이스 연결 모듈에 많이 사용한다.

 

• 장점 : 하나의 인스턴스를 만들어 놓고, 해당 인스턴스를 다른 모듈들이 공유하며 사용하므로 인스턴스를 생성할 때 드는 비용이 줄어든다.
• 단점 : 의존성이 높아진다.

자바스크립트의 싱글톤 패턴

자바스크립트에서는 리터럴 {} 또는 new Object로 객체를 생성하게 되면 다른 어떤 객체와도 같지 않기 때문에 이 자체만으로 싱글톤 패턴을 구현할 수 있다.

// 객체 리터럴을 사용한 예제
const obj = {
	a: 27
}
const obj2 = {
	a: 27
}
console.log(obj === obj2) // false

obj와 obj2는 다른 인스턴스를 가진다.

// Singleton 클래스로 구현한 예제
class Singleton {
	constructor() {
    	if (!Singleton.instance) { // 인스턴스가 없으면
        	Singleton.instance = this // 현재 인스턴스를 저장
        }
        return Singleton.instance // 기존 인스턴스 반환
    }
    get Instance() {
    	return this // 현재 인스턴스 반환
    }
}
const a = new Singleton()
const b = new Singleton()
console.log(a === b) // true

Singleton.instance 라는 하나의 인스턴스를 가지는 Singleton 클래스를 구현한 코드이다.

기존 인스턴스가 없으면 현재 인스턴스를 Singleton.instance에 저장하고, 기존 인스턴스가 있으면 새로운 객체를 생성하지 않고 기존 인스턴스를 반환하는 과정을 통해 클래스의 인스턴스가 하나만 유지된다.

즉, a와 b는 하나의 인스턴스를 가진다.

 

데이터베이스 연결 모듈

싱글톤 패턴은 데이터베이스 연결 모듈에 많이 쓰인다.

const URL = 'mongodb://localhost:27017/kundolapp'
const createConnection = url => ({"url" : url})
class DB {
	constructor(url {
    	if (!DB.instance) {
        	DB.instance = createConnection(url)
		}
        return DB.instance
    }
    connect() {
    	return this.instance
    }
}
const a = new DB(URL)
const b = new DB(URL)
console.log(a === b) // true

이렇게 DB.instance라는 하나의 인스턴스를 기반으로 a, b를 생성하는 것을 볼 수 있다.

이를 통해 데이터베이스 연결에 관한 인스턴스 생성 비용을 아낄 수 있다.

 

자바에서의 싱글톤 패턴

class Singleton {
	private static class singleInstanceHolder {
    	private static final Singleton INSTANCE = new Singleton();
    }
    private static Singleton getInstance() {
    	return singleInstanceHolder.INSTANCE;
    }
}

public class HelloWorld {
	public static void main(String[] args) {
    	Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println(a.hashCode());
        System.out.println(b.hashCode());
        if (a === b) {
        	System.out.println(true);
        }
    }
}
/*
705927765
705927765
true
*/

 

mongoose의 싱글톤 패턴

실제로 싱글톤 패턴은 Node.js에서 MongoDB 데이터베이스를 연결할 때 쓰는 mongoose모듈에서 볼 수 있다.

mongoose의 데이터베이스를 연결할 때 쓰는 connect()라는 함수는 싱글톤 인스턴스를 반환한다.

Mongoose.prototype.connect = function(uri, options, callback) {
    const _mongoose = this instanceof Mongoose ? this : mongoose;
    const conn = _mongoose.connection;
    
    return _mongoose._promiseOrCallback(callback, cb => {
    	conn.openUri(uri, options, err => {
        	if (err != null) {
                    return cb(err);
            }
            return cb(null, _mongoose);
        });
    });
};

 

MySQL의 싱글톤 패턴

Node.js에서 MySQL 데이터베이스를 연결할 때도 싱글톤 패턴이 쓰인다.

// 메인 모듈
const mysql = require('mysql');
const pool = mysql.createPool({
    connectionLimit: 10,
    host: 'example.org',
    user: 'kundol',
    password: 'secret',
    database: '모래디비'
});
pool.connect();

// 모듈 A
pool.query(query, function(error, results, fields) {
    if (error) throw error;
    console.log('The solution is: ', results[0].solution);
});

// 모듈 B
pool.query(query, function(error, results, fields) {
    if (error) throw error;
    console.log('The solution is: ', results[0].solution);
});

위의 코드처럼 메인 모듈에서 데이터베이스 연결에 관한 인스턴스를 정의하고, 다른 모듈인 A 또는 B에서 해당 인스턴스를 기반으로 쿼리를 보내는 형식으로 쓰인다.

 

싱글톤 패턴의 단점

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

의존성 주입

• 또한 싱글톤 패턴은 사용하기가 쉽고 굉장히 실용적이지만 모듈 간의 결합을 강하게 만들 수 있다는 단점이 있다.
  이 때, 의존성 주입(DI, Dependency Injection)을 통해 모듈 간의 결합을 조금 더 느슨하게 만들어 해결할 수 있다.
  • 의존성 : 종속성이라고도 하며, A가 B에 의존성이 있다는 것은 B의 변경사항에 대해 A도 변해야 된다는 것을 의미
  • 메인 모듈(.main mudule)이 '직접' 다른 하위 모듈에 대한 의존성을 주기보다는 중간에 의존성 주입자(dependency injector)가 이 부분을 가로채 메인 모듈이 '간접'적으로 의존성을 주입하는 방식
  • 이를 통해 메인 모듈(상위 모듈)은 하위 모듈에 대한 의존성이 떨어지게 된다( = 디커플링 된다)
• 의존성 주입의 장점
  • 모듈들을 쉽게 교체할 수 있는 구조가 되어 테스팅하기 쉽고 마이그레이션 하기도 수월하다.
  • 또한, 구현할 때 추상화 레이어를 넣고 이를 기반으로 구현체를 넣어주기 때문에 애플리케이션 의존성 방향이 일관되고, 애플리케이션을 쉽게 추론할 수 있으며, 모듈 간의 관계들이 조금 더 명확해진다.
• 의존성 주입의 단점
  • 모듈들이 더욱더 분리되므로 클래스 수가 늘어나 복잡성이 증가될 수 있으며, 약간의 런타임 페널티가 생기기도 한다.
• 의존성 주입 원칙
  • 상위 모듈은 하위 모듈에서 어떤 것도 가져오지 않아야 한다.
  • 둘 다 추상화에 의존해야 하며, 이 때 추상화는 세부 사항에 의존하지 말아야 한다.

---

2) 팩토리 패턴(factory pattern)

객체를 사용하는 코드에서 객체 생성 부분을 떼어내 추상화한 패턴이자, 상속 관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고, 하위 클래스에서 객체 생성에 관한 구체적인 내용을 결정하는 패턴

 

부모(상위) 클래스에 알려지지 않은 구체 클래스를 생성하는 패턴이며, 자식(하위) 클래스가 어떤 객체를 생성할지를 결정하도록 하는 패턴이다.

 

상위 클래스와 하위 클래스가 분리되므로 느슨한 결합을 가지며 상위 클래스에서는 인스턴스 생성 방식에 대해 전혀 알 필요가 없기 때문에 더 많은 유연성을 갖게 된다.

그리고 객체 생성 로직이 따로 떼어져 있으므로 코드를 리팩토링 하더라도 한 곳만 고칠 수 있게 되니 유지 보수성이 증가된다.

 

ex) 라떼 레시피와 아메리카노 레시피, 우유 레시피라는 구체적인 내용이 들어 있는 하위 클래스가 컨베이어 벨트를 통해 전달되고, 상위 클래스인 바리스타 공장에서 이 레시피들을 토대로 우유 등을 생산하는 생산 공정을 생각하면 된다.

 

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

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

숫자를 전달하거나 문자열을 전달함에 따라 다른 타입의 객체를 생성하는 것을 볼 수 있다.

즉, 전달 받은 값에 따라 다른 객체를 생성하며 인스턴스 타입 등을 정한다.

 

// 커피 팩토리를 기반으로 라떼 등을 생산하는 코드
Class CoffeeFactory {
	static createCoffee(type) {
    	const factory = factoryList[type]
        return factory.createCoffee()
    }
}
Class Latte {
	constructor() {
    	this.name = "latte"
    }
}
Class Espresso {
	constructor() {
    	this.name = "espresso"
    }
}
Class LatteFactory extends CoffeeFactory {
	static createCoffee() {
    	return new Latte()
    }
}
Class EspressoFactory extends CoffeeFactory {
	static createCoffee() {
    	return new Espresso()
    }
}
const factoryList = {LatteFactory, EspressoFactory}

const main = () => {
    // 라떼 커피를 주문한다.
    const coffee = CoffeeFactory.createCoffee("LatteFactory")
    // 커피 이름을 부른다.
    console.log(coffee.name) // latte
}
main()

CoffeeFactory 라는 상위 클래스가 중요한 뼈대를 결정하고, 하위 클래스인 LatteFactory가 구체적인 내용을 결정하고 있다.

참고로 이는 의존성 주입이라고도 볼 수 있다. CoffeeFactory에서 LatteFactory의 인스턴스를 생성하는 것이 아닌 LatteFactory 에서 생성한 인스턴스를 CoffeeFactory에 주입하고 있기 때문이다.

 

또한, CoffeeFactory 클래스를 보면 static 키워드를 통해 createCoffee() 메서드를 정적 메서드로 선언한 것을 볼 수 있는데, 이렇게 정적 메서드로 정의하면 클래스를 기반으로 객체를 만들지 않고 호출이 가능하며, 해당 메서드에 대한 메모리 할당을 한 번만 할 수 있는 장점이 있다.

 

• 정적 메서드는 클래스 자체에서 호출 가능 → new CoffeeFactory() 할 필요 없음
• 객체를 매번 생성하지 않아도 되므로 메모리 절약 가능!

자바의 팩토리 패턴

// CoffeeFactory 밑에 Coffee 클래스를 놓고 해당 클래스를 상속하는 Latte, Espresso 클래스를 기반으로 구현한 코드
enum CoffeeType {
	LATTE,
    ESPRESSO
}

abstract class Coffee {
	protected String name;
    
    public String getName() {
    	return name;
    }
}

class Latte extends Coffee {
	public Latte() {
    	name = "latte";
    }
}

class Espresso extends Coffee {
	public Espresso() {
    	name = "espresso";
    }
}

class CoffeeFactory {
	public static Coffee createCoffee(CoffeeType type) {
    	switch (type) {
        	case LATTE:
				return new Latte();
            case ESPRESSO:
            	return new Espresso();
            default:
            	throw new IllegalArgumentException("Invalid coffee type: " + type);
        }
    }
}

public class Main {
	public static void main(String[] args) {
    	Coffee coffee = CoffeeFactory.createCoffee(CoffeeType.LATTE);
        System.out.println(coffee.getName()); // latte
    }
}

 

---

3) 전략 패턴(strategy pattern)

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

 

컨텍스트 : 상황, 맥락, 문맥을 의미하며 개발자가 어떠한 작업을 완료하는 데 필요한 모든 관련 정보를 말한다.

 

자바의 전략 패턴

어떤 아이템을 살 때 LUNACard로 사는 것과 KAKAOCard로 사는 것을 구현한 예제. 결제 방식의 '전략'만 바꿔서 두 가지 방시긍로 결제하는 것을 구현한 코드

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

interface PaymentStrategy {
	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.println(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.println(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 String 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(PaymentStrategy paymentMethod) {
    	int amount = calculateTotal();
        paymentMethod.pay(amount);
    }
}

public class HelloWorld {
	public static void main(String[] args) {
    	ShoppingCart cart = new ShoppingCart();
        
        Item A = new Item("marieA", 100);
        Item B = new Item("marieB", 300);
        
        cart.addItem(A);
        cart.addItem(B);
        
        // pay by LUNACard
        cart.pay(new LUNACardStrategy("marie@example.com", "pukubababo"));
        
        // pay by KAKAOCard
        cart.pay(new KAKAOCardStrategy("Park sujin", "12345678", "123", "12/01"));
    }
}

/*
400 paid using LUNACard.
400 paid using KAKAOCard.
*/

 

passport의 전략 패턴

전략 패턴을 활용한 라이브러리로는 passport가 있다.

 

passport는 Node.js에서 인증 모듈을 구현할 때 쓰는 미들웨어 라이브러리로 여러가지 '전략'을 기반으로 인증할 수 있게 한다. 서비스 내의 회원가입 된 아이디와 비밀번호를 기반으로 인증하는 LocalStrategy 전략과 페이스북, 네이버 등 다른 서비스를 기반으로 인증하는 OAuth 전략 등을 지원한다.

var passport = require('passport')
    , LoalStrategy = require('passport-local').Strategy;
    
passport.use(new LocalStrategy(
	function(username, password, done) {
    	User.findOne({ username: username }, function (err, user) {
            if (err) { return done(err); }
            if (!user) {
            	return done(null, false, { message: 'Incorrect username.' });
            }
            if (!user.validPassword(password)) {
            	return done(null, false, { message: 'Incorrect password.' });
            }
            return done(null, user);
        });
    }
});

passport.use(new LocalStrategy( ... 처럼 passport.use() 라는 메서드에 '전략'을 매개변수로 넣어서 로직을 수행하는 것을 볼 수 있다.

 

 

---

참조

면접을 위한 CS 전공지식노트