팩토리 패턴

팩토리 패턴은 객체 생성 로직을 캡슐화 하여 코드의 유연성과 재 사용성을 높이는 디자인 패턴 중 하나

팩토리 패턴은 객체를 직접 생성하는 대신, 객체 생성에 대한 책임을 별도의 팩토리 클래스나 메서드에 위임함으로써 클라이언트 코드와 객체 생성 로직을 분리, 이로인해 클라이언트 코드는 생성할 객체의 구체적인 클래스에 의존하지 않고도 객체를 생성할 수 있게 됨

즉 상속 관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고, 하위 클래스에서 객체생성에 관한 구체적인 내용을 결정하는 패턴

상위 클래스에서는 객체 생성방식에 대해 알 필요가 없어져 유연성을 갖게되며 객체생성로직은 하위 클래스에서만 관리되기 때문에 유지보수성이 증가

1. 단순 팩토리 패턴 (Simple Factory Pattern)

단순 팩토리 패턴은 객체 생성을 단일 메서드에 캡슐화 함

javascript코드 복사
class Product {
    use() {
        console.log('Using product');
    }
}

class SimpleFactory {
    static createProduct(type) {
        switch (type) {
            case 'A':
                return new ConcreteProductA();
            case 'B':
                return new ConcreteProductB();
            default:
                throw new Error('Unknown product type');
        }
    }
}

class ConcreteProductA extends Product {
    use() {
        console.log('Using product A');
    }
}

class ConcreteProductB extends Product {
    use() {
        console.log('Using product B');
    }
}

// Usage
const productA = SimpleFactory.createProduct('A');
productA.use();

const productB = SimpleFactory.createProduct('B');
productB.use();

2. 팩토리 메서드 패턴 (Factory Method Pattern)

팩토리 메서드 패턴은 객체 생성을 위한 인터페이스를 정의하고, 이를 구현하는 서브클래스가 구체적인 객체 생성 작업을 담당

javascript코드 복사
class Product {
    use() {
        throw new Error('Abstract method!');
    }
}

class ConcreteProductA extends Product {
    use() {
        console.log('Using product A');
    }
}

class ConcreteProductB extends Product {
    use() {
        console.log('Using product B');
    }
}

class Creator {
    factoryMethod() {
        throw new Error('Abstract method!');
    }

    anOperation() {
        const product = this.factoryMethod();
        product.use();
    }
}

class ConcreteCreatorA extends Creator {
    factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    factoryMethod() {
        return new ConcreteProductB();
    }
}

// Usage
const creatorA = new ConcreteCreatorA();
creatorA.anOperation();

const creatorB = new ConcreteCreatorB();
creatorB.anOperation();

3. 추상 팩토리 패턴 (Abstract Factory Pattern)

추상 팩토리 패턴은 관련된 객체들의 집합을 생성하는 인터페이스를 제공

javascript코드 복사
class AbstractProductA {
    use() {
        throw new Error('Abstract method!');
    }
}

class AbstractProductB {
    eat() {
        throw new Error('Abstract method!');
    }
}

class ConcreteProductA1 extends AbstractProductA {
    use() {
        console.log('Using product A1');
    }
}

class ConcreteProductB1 extends AbstractProductB {
    eat() {
        console.log('Eating product B1');
    }
}

class ConcreteProductA2 extends AbstractProductA {
    use() {
        console.log('Using product A2');
    }
}

class ConcreteProductB2 extends AbstractProductB {
    eat() {
        console.log('Eating product B2');
    }
}

class AbstractFactory {
    createProductA() {
        throw new Error('Abstract method!');
    }

    createProductB() {
        throw new Error('Abstract method!');
    }
}

class ConcreteFactory1 extends AbstractFactory {
    createProductA() {
        return new ConcreteProductA1();
    }

    createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 extends AbstractFactory {
    createProductA() {
        return new ConcreteProductA2();
    }

    createProductB() {
        return new ConcreteProductB2();
    }
}

// Usage
const factory1 = new ConcreteFactory1();
const productA1 = factory1.createProductA();
const productB1 = factory1.createProductB();
productA1.use();
productB1.eat();

const factory2 = new ConcreteFactory2();
const productA2 = factory2.createProductA();
const productB2 = factory2.createProductB();
productA2.use();
productB2.eat();