[디자인 패턴] 싱글톤 패턴(Singleton Pattern)

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

1. 싱글톤 패턴

• 하나의 클래스에 오직 하나의 인스턴스만 가지는 패턴
• 보통 데이터베이스 연결 모듈에 많이 사용

장점

1. 메모리 절약

     - 한 번 생성된 인스턴스가 계속 재사용되므로 메모리 절약 가능

   2. 데이터 공유가 쉬움

    - 전역으로 사용하는 인스턴스이기 때문에 다른 여러 클래스에서 데이터를 공유하며 사용 가능

  3. 제어된 리소스 접근 가능

   - 싱글톤 객체는 한 번에 하나의 요청만 처리하므로, 데이터베이스 연결이나 파일 작성과 같은 리소스를 안전하게 제어가 가능

단점

   1. TDD(Test Driven Development)가 불리

    - 싱글톤 객체는 사실상 전역 상태를 만드므로, 각 테스트마다 '독립적인' 인스턴스를 만들기 어려움

  2. 멀티 스레드에서 문제 발생 가능성

   - 여러 스레드가 동시에 싱글톤 객체에 엑세스하려고 시도하면 동기화 문제가 발생 가능

  3. 확장성 문제

  - 일반적으로 싱글톤 클래스는 서브클래싱이 어렵고, 클라이언트 코드와 밀접하게 결합되어 확장하기 어려움

 

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

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

const obj = {
	a: 27
}
const obj2 = {
	a: 27
}

console.log(obj === obj2)
// false

  위의 코드에서 볼 수 있듯이 obj와 obj2는 다른 인스턴스를 가진다. 이 또한 new Object라는 클래스에서 나온 단 하나의 인스턴스니 어느 정도 싱글톤 패턴이라 볼 수 있지만, 실제 싱글톤 패턴은 보통 다음과 같은 코드로 구성된다.

class Singleton {
	constructor() {
    	if (!Singleton.instance) {
        	Singleton.instance = this
        }
        return Singleton.instance
    }
    getInstance() {
    	return this.instance
    }
}
const a = new Singleton()
const b = new Singleton()
console.log(a === b) // true

 위의 코드는 Singleton.instance라는 하나의 인스턴스를 가지는 Singleton 클래스를 구현한 모습이다. 이를 통해 a와 b는 하나의 인스턴스를 가진다.

3. 데이터베이스 연결모듈

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를 생성하는 것을 볼 수 있다. 이를 통해 데이터베이스 연결에 관한 인스턴스 생성 비용을 아낄 수 있다.

4. 자바에서의 싱글톤 패턴

 중첩 클래스를 이용해서 만드는 방법이 가장 대중적이다.

class Singleton {
	private static class singleInstanceHolder {
    	private static final Singleton INSTANCE = new Singleton();
    }
    public 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
*/

 

5. 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 db(err);
            }
            return cb(null, _mongoose);
        });
    });
};

 

6. 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에서 해당 인스턴스를 기반으로 쿼리를 보내는 형식으로 쓰인다.

7. C++의 싱글톤 패턴

#include <iostream>

class Singleton {
private:
	Singleton() {}
	Singleton(const Singleton& ref) {}
	Singleton& operator=(const Singleton& ref) {}
	~Singleton() {}
public:
	static Singleton& getInstance() {
    	static Singleton s;
        return s;
    }
};

int main() {
	Singleton& s = Singleton::getInstance();
	return 0;
}

 

8. 의존성 주입

 싱글톤 패턴은 사용하기가 쉽고 굉장히 실용적이지만 모듈 간의 결합을 강하게 만들 수 있다는 단점이 있다. 이 때 의존성 주입(DI, Dependency Injection)을 통해 모듈 간의 결합을 조금 더 느슨하게 만들어 해결할 수 있습니다.

 참고로 의존성이란 종속성이라고도 하며 A가 B에 의존성이 있다는 것은 B의 변경 사항에 대해 A 또한 변해야 된다는 것을 의미한다.

 위의 그림처럼 메인 모듈(main module)이 '직접' 다른 하위 모듈에 대한 의존성을 주기보다는 중간에 의존성 주입자(dependency injector)가 이 부분을 가로채 메인 모듈이 '간접'적으로 의존성을 주입하는 방식이다.

 이를 통해 메인 모듈(상위 모듈)은 하위 모듈에 대한 의존성이 떨어지게 된다. 참고로 이를 '디커플링이 된다'고도 한다.

 의존성 주입의 장점

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

 의존성 주입의 단점

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

 의존성 주입 원칙

  "상위 모듈은 하위 모듈에서 어떠한 것도 가져오지 않아야 합니다. 또한, 둘 다 추상화에 의존해야 하며, 이때 추상화는 세부 사항에 의존하지 말아야 한다."