🎨 04. 팩토리 패턴

🏭 ’new’ 연산자가 눈에 띈다면 ‘구상’이라는 용어를 떠올려 주세요.

new를 사용하면 구상 클래스의 인스턴스가 만들어진다. 구상 클래스를 바탕으로 코딩하면 나중에 코드를 수정해야 할 가능성이 커지고, 유연성이 떨어진다.

// Duck 인터페이스 정의
interface Duck {
  quack(): void;
  swim(): void;
}

.
.
.

let duck: Duck;

if (picnic) {
  duck = new MallardDuck();
} else if (hunting) {
  duck = new DecoyDuck();
} else if (inBathTub) {
  duck = new RubberDuck();
}

duck.quack();
duck.swim();

🔍 이 코드의 문제점 (구상 클래스에 의존하는 문제)

MallardDuck, DecoyDuck, RubberDuck에 직접 new를 하고 있음 → 구상 클래스에 강하게 의존함

• 구상 클래스의 인스턴스가 여러 개 있으며(= Duck 타입의 여러 구현체가 존재), 그 인스턴스의 형식은 실행 시에 주어진 조건에 따라 결정된다.

이건 유지보수가 어렵고, 새로운 오리를 추가할 때마다 if-else 구문을 수정해야 한다. 따라서 코드를 이런 식으로 만들면 관리와 갱신이 어려워지고 오류가 생길 가능성도 커진다.

🔍 ‘new’ 에 어떤 문제가 있는 걸까요?

사실 new에는 문제가 없고, 진짜 말썽을 일으키는 녀석은 바로 ‘변화’이다! 변화하는 무언가 때문에 new를 조심해서 사용해야 한다.

✅ 인터페이스를 바탕으로 만들어진 코드는 어떤 클래스든 특정 인터페이스만 구현하면 사용할 수 있다.

• 다형성(Polymorphism)
  • 같은 타입으로 여러 객체를 다룰 수 있는 능력

interface Animal {
  speak(): void;
}

class Dog implements Animal {
  speak() {
    console.log("멍");
  }
}

class Cat implements Animal {
  speak() {
    console.log("먀");
  }
}

// 이 함수는 Animal만 알고 Dog, Cat은 모름
function makeSound(animal: Animal) {
  animal.speak(); // 어떤 동물이 와도 실행됨
}

makeSound(new Dog()); // 멍
makeSound(new Cat()); // 먀

❌ 구상 클래스를 많이 사용하면 새로운 구상 클래스가 추가될 때마다 코드를 고쳐야 하므로 많은 문제가 생길 수 있다.

• 즉, 변경에 닫혀 있는 코드가 되는 것

function playWithAnimal(type: string) {
  if (type === "dog") {
    const dog = new Dog();
    dog.speak();
  } else if (type === "cat") {
    const cat = new Cat();
    cat.speak();
  }
}

• 새로운 구상 형식을 써서 확장해야 할 때는 어떻게 해서든 다시 열 수 있게 만들어야 한다.
  • OCP (개방-폐쇄 원칙)
  • 코드 내부를 계속 수정하지 말고 새로운 클래스를 밖에서 “끼워넣을 수 있도록” 만들어라!

function playWithAnimal(animal: Animal) {
  animal.speak();
}

// 새로운 동물이 생김
class Parrot implements Animal {
  speak() {
    console.log("안녕");
  }
}

// 기존 함수는 절대 안 고치고 그냥 새로 넣기만 하면 됨
playWithAnimal(new Parrot()); // 안녕

✨ 이렇게 되면 playWithAnimal() 함수는 절대 고치지 않아도 되고, 새 동물이 추가될수록 확장은 가능하지만, 기존 코드는 건드리지 않게 되는 것

💡 어떻게 하면 애플리케이션에서 구상 클래스의 인스턴스 생성 부분을 전부 찾아내서 애플리케이션의 나머지 부분으로부터 분리(캡슐화)할 수 있을까?

🏭 최첨단 피자 코드 만들기

객체 마을의 최첨단 피자 가게는 다음과 같은 코드를 미리 만들어 두었다.

function orderPizza(): Pizza {
  const pizza = new Pizza();

  pizza.prepare();
  pizza.bake();
  pizza.cut();
  pizza.box();

  return pizza;
}

근데 피자 종류가 여러 개임…

function orderPizza(type: string): Pizza {
  let pizza: Pizza;

  if (type === "cheese") {
    pizza = new CheesePizza();
  } else if (type === "greek") {
    pizza = new GreekPizza();
  } else if (type === "pepperoni") {
    pizza = new PepperoniPizza();
  } else {
    throw new Error(`알 수 없는 피자 타입: ${type}`);
  }

  pizza.prepare();
  pizza.bake();
  pizza.cut();
  pizza.box();

  return pizza;
}

🏭 피자 코드 추가하기

맞은편에 있는 피자 가게에서 신메뉴를 2개나 출시했다. 조개 피자와 야채 피자! 최첨단 피자 가게도 따라서 똑같은 신메뉴를 출시하기로 했다. 이참에 별로 안 팔리는 그리스 스타일 피자는 메뉴에서 제외하기로 했다.

function orderPizza(type: string): Pizza {
  let pizza: Pizza;

  if (type === "cheese") {
    pizza = new CheesePizza();
  } else if (type === "pepperoni") {
    pizza = new PepperoniPizza();
  } else if (type === "clam") { // 추가됨
    pizza = new ClamPizza();
  } else if (type === "veggie") { // 추가됨
    pizza = new VeggiePizza();
  } else {
    throw new Error(`알 수 없는 피자 타입: ${type}`);
  }
  // greekPizza 삭제

  pizza.prepare();
  pizza.bake();
  pizza.cut();
  pizza.box();

  return pizza;
}

• if~else
  • 이 코드는 변경에 닫혀 있지 않다. 피자 가게에서 메뉴를 변경하려면 if-else 구문을 계속 고쳐야 한다.
• pizza.prepare() ~ pizza.box()
  • 이 부분은 바뀌지 않는다. 굽고, 자르고, 포장하는 일은 피자를 판매할 때 당연히 해야 하는 일이므로 이 코드는 고칠 일이 거의 없다. 호출하는 피자 클래스의 메소드만 달라질 뿐이다.
• orderPizza() 메소드에서 가장 문제가 되는 부분은 인스턴스를 만드는 구상 클래스를 선택하는 부분이다. 이 부분 때문에 상황이 변하면 코드를 변경해야 한다.

🏭 객체 생성 부분 캡슐화하기

객체 생성 부분을 orderPizza() 메소드에서 뽑아내야 한다. 그런데 어떻게 하면 좋을까? 우선 객체 생성 코드만 따로 빼서 피자 객체를 만드는 일만 전담하는 객체 ⇒ SimplePizzaFactory에 넣어보자.

새로 만들 객체를 팩토리라고 부르겠습니다.

객체 생성을 처리하는 클래스를 팩토리(Factory)라고 부른다. 일단 SimplePizzaFactory를 만들고 나면 orderPizza() 메소드는 새로 만든 객체의 클라이언트가 된다. 즉, 새로 만든 객체를 호출하는 것이다. 더 이상 orderPizza() 메소드에서 어떤 피자를 만들지 고민하지 않고, Pizza 인터페이스를 구현하는 피자를 받아서 그 인터페이스에서 정의했던 prepare(), bake(), cut(), box() 메소드를 호출하기만 하면 된다.

🏭 객체 생성 팩토리 만들기

우선 팩토리를 만들어 보자. 피자 객체 생성 부분을 전담할 클래스를 정의하면 된다.

class SimplePizzaFactory {
  createPizza(type: string): Pizza {
    if (type === "cheese") {
      return new CheesePizza();
    } else if (type === "pepperoni") {
      return new PepperoniPizza();
    } else if (type === "clam") {
      return new ClamPizza();
    } else if (type === "veggie") {
      return new VeggiePizza();
    } else {
      throw new Error(`알 수 없는 피자 타입: ${type}`);
    }
  }
}

• 우선 createPizza() 메소드를 정의한다.
  • 클라이언트가 새로운 객체 인스턴스를 만들 때 호출하는 메소드이다.
• 전달받은 매개변수(type)로 피자 종류를 결정한다.

🙋‍♀️ “그냥 문제를 다른 객체로 넘긴 것뿐 아닌가요?”

실제로도 new를 팩토리로 옮긴 것뿐이긴 함

하지만 “캡슐화”의 진짜 목적은 책임을 명확하게 분리해서 변경에 유연하게 대응하기 위한 설계에 있다.

🔍 단순 비교

function orderPizza(type: string): Pizza {
  if (type === "cheese") {
    return new CheesePizza();
  }
  // ...
}

• orderPizza()가 피자 종류를 다 알아야 함
• 새로운 피자 추가되면 이 코드도 계속 바뀜 → OCP 위반
• 단일 책임 원칙(SRP)도 깨짐 → “주문”과 “생성” 둘 다 책임짐

👍 팩토리에 위임

const pizza = factory.createPizza(type);

• 피자 종류를 아는 건 SimplePizzaFactory의 책임
• orderPizza()는 오직 주문 처리만 신경 씀
• 새 피자 추가해도 orderPizza()는 그대로 유지 가능

즉, 단순히 “문제를 넘겼다”가 아니라, 책임을 나눠서 변경에 강하고 유지보수 쉬운 구조로 캡슐화한 것

🏭 클라이언트 코드 수정하기

팩토리로 피자 객체를 생성하도록 고쳐보자.

class SimplePizzaFactory {
  createPizza(type: string): Pizza {
    if (type === "cheese") {
      return new CheesePizza();
    } else if (type === "pepperoni") {
      return new PepperoniPizza();
    } else if (type === "clam") {
      return new ClamPizza();
    } else if (type === "veggie") {
      return new VeggiePizza();
    } else {
      throw new Error(`알 수 없는 피자 타입: ${type}`);
    }
  }
}

class PizzaStore {
  constructor(private factory: SimplePizzaFactory) {}

  orderPizza(type: string): Pizza {
    const pizza = this.factory.createPizza(type); // 🍕 생성 책임 위임!

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
  }
}

• SimplePizzaFactory
  • 피자 만드는 기계!
  • 문자열(type)을 받아서 알맞은 피자 객체를 만들어 반환함
  • 실제 new CheesePizza() 같은 객체 생성 코드를 전부 한 곳에 집중시킴
• PizzaStore
  • 실제 피자 가게
  • 손님이 "cheese" 같은 문자열로 피자를 주문하면,
    1. SimplePizzaFactory에게 피자 만들어달라고 요청함
    2. 받은 피자 객체를 알맞은 순서대로 처리함 (준비 → 굽기 → 자르기 → 포장)

🏭 ’간단한 팩토리’의 정의

간단한 팩토리(Simple Factory)는 디자인 패턴이라기 보다는 프로그래밍에서 자주 쓰이는 관용구에 가깝다. 간단한 팩토리를 ‘팩토리 패턴’이라고 부르는 사람들도 있지만, 정확하게 패턴은 아니다. 간단한 팩토리를 왜 쓰는지 알아보자.

1. PizzaStore

• 🔹 역할: 클라이언트
• 🔹 orderPizza() 메서드를 통해 피자를 주문받음
• 🔹 피자 생성에 대해선 아무것도 모름, 대신 SimplePizzaFactory에 위임함

2. SimplePizzaFactory

• 🔹 역할: 팩토리
• 🔹 createPizza() 메서드로 요청받은 피자 종류의 객체를 생성
• 🔹 이곳에서만 구체적인 피자 클래스(CheesePizza, ClamPizza 등)를 직접 참조함
• 👉 이 부분만 바꾸면 피자 종류 추가/삭제 가능

3. Pizza

• 🔹 역할: 제품(Product)의 부모 클래스
• 🔹 추상 클래스 혹은 인터페이스처럼 동작
• 🔹 prepare(), bake(), cut(), box() 같은 공통 메서드를 정의

4. CheesePizza, ClamPizza, VeggiePizza, PepperoniPizza

• 🔹 역할: 구상 제품(Concrete Products)
• 🔹 Pizza를 상속해서 자기만의 prepare() 구현을 제공
• 🔹 팩토리에서 이 클래스들을 new 해서 만들어냄

🔁 전체 흐름 요약

1. PizzaStore에서 "cheese"라는 주문이 들어옴
2. SimplePizzaFactory.createPizza("cheese") 호출
3. 팩토리는 new CheesePizza()로 피자 객체 생성
4. PizzaStore는 받은 피자에 대해 prepare(), bake() 등 처리
5. 손님에게 반환 🍕

Kohi의 말:

그럼 내가 아까까지 한 게 모두 다 간단한 팩토리였다고…?

ChatGPT의 말:

👏 정확해! 네가 지금까지 만든 구조는 전형적인 “간단한 팩토리(Simple Factory)” 패턴이야!

1. PizzaStore에서 Pizza를 직접 new로 만들던 걸
2. SimplePizzaFactory로 객체 생성 책임을 분리하고
3. PizzaStore는 이제 “피자를 주문받고 처리”하는 역할만 하게 됨

👉 이 구조가 바로 간단한 팩토리 패턴의 대표적인 형태

🧠 그런데 왜 “패턴”이 아니라 “관용구(idiom)”라고 할까?

• GoF(디자인 패턴의 바이블)에 나오는 23가지 디자인 패턴에는 Simple Factory는 없음
• 그 대신 이건 자주 쓰이는 유용한 설계 습관이라서, 많은 사람들이 “패턴처럼” 사용하지만, 엄밀히 말하면 디자인 패턴은 아님

객체 구성을 활용하면 행동을 실행할 때 구현된 객체를 동적으로 바꿀 수 있습니다. PizzaStore에서도 그 방법을 쓸 수 없을까요? 팩토리 클래스에서 어떤 부분을 마음대로 바꿀 수 있을까요?

여러 가지 방법이 있지만, 우리는 뉴욕 스타일, 시카고 스타일, 캘리포니아 스타일 피자를 떠올렸습니다. 뉴 헤이븐 스타일 피자도 있어요!

🏭 다양한 팩토리 만들기

객체마을의 최첨단 피자 가게가 SNS에서 큰 인기를 끌게 되니 많은 사람들이 자기 동네에도 최첨단 피자 가게가 있으면 좋겠다는 바람을 가지게 되었다. 이제 지점을 낼 때가 왔다. 지금까지 잘 써왔던 코드를 다른 지점에도 쓸 수 있도록 발전시켜 보자. 먼저, 각 지점마다 그 지역의 특성과 입맛을 반영한 다양한 스타일의 피자(뉴욕 스타일, 시카고 스타일, 캘리포니아 스타일 등)을 만들어야 한다.

이미 1가지 방법을 앞에서 배웠습니다.

• SimplePizzaFactory를 삭제하고, 3가지 서로 다른 팩토리(NYPizzaFactory, ChicagoPizzaFactory, CaliforniaPizzaFactory)를 만든 다음, PizzaStore에서 적당한 팩토리를 사용하도록 하는 방법이다.

const nyStore = new NYPizzaStore();
const chicagoStore = new ChicagoPizzaStore();

하지만 지점들을 조금 더 제대로 관리해야 합니다.

지점에서 우리가 만든 팩토리로 피자를 만들긴 하는데, 굽는 방식이 달라진다거나 종종 피자를 자르는 것을 까먹는 일이 생기기 시작했다. 심지어 이상하게 생긴 피자 상자를 쓰는 일도 있었다. 이 문제를 해결하려면 피자 제작 코드 전체를 하나로 묶어주는 프레임워크를 만들어야 한다. 물론 그렇게 만들면서도 유연성을 잃어버리면 안 된다.

SimplePizzaFactory를 만들기 전에 썼던 코드에는 피자를 만드는 코드가 PizzaStore와 직접 연결되어 있긴 했지만 유연성이 전혀 없었다. 어떻게 해야 피자 가게와 피자 만드는 과정을 하나로 묶을 수 있을까?

🏭 피자 가게 프레임워크 만들기

이제 createPizza() 메소드를 PizzaStore()에 다시 넣도록 하자. 하지만 그 메소드를 추상 메소드로 선언하고, 지역별 스타일에 맞게 PizzaStore의 서브클래스를 만들어보자.

PizzaStore (추상 클래스)
 ├── NYPizzaStore           --> createPizza(): 뉴욕 스타일 피자 생성
 ├── ChicagoPizzaStore      --> createPizza(): 시카고 스타일 피자 생성
 └── CaliforniaPizzaStore   --> createPizza(): 캘리포니아 스타일 피자 생성

abstract class PizzaStore {
  orderPizza(type: string): Pizza {
    const pizza = this.createPizza(type);

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
  }

  protected abstract createPizza(type: string): Pizza;
}

이제 각 지점에 맞는 서브클래스를 만들어야 한다. 피자의 스타일은 각 서브클래스에서 결정한다.

🏭 서브클래스가 결정하는 것 알아보기

PizzaStore의 orderPizza() 메소드에 이미 주문 시스템이 잘 갖춰져 있다. 모든 지점에서 이 주문 시스템을 따라 주문이 진행되어여 한다. 각 지점마다 달라질 수 있는 것은 피자 스타일뿐이다. 달라지는 점은 createPizza() 메소드에 넣고 그 메소드에서 해당 스타일의 피자를 만들도록 할 계획이다. 이제 PizzaStore의 서브클래스에서 createPizza() 메소드를 구현하도록 하자.

class NYPizzaStore extends PizzaStore {
  protected createPizza(type: string): Pizza {
    if (type === "cheese") {
      return new NYStyleCheesePizza();
    } else if (type === "veggie") {
	    return new NYStyleVeggiePizza();
    } else if (type === "clam") {
	    return new NYStyleClamPizza();
    } else if (type === "pepperoni") {
	    return new NYStylePepperoniPizza();
    } else {
      throw new Error("해당 타입 없음");
    }
  }
}

const nyStore = new NYPizzaStore();
nyStore.orderPizza("cheese"); 

🏭 피자 팩토리 메소드로 피자 주문하기

에단: 나는 뉴욕 스타일 피자가 좋아. 얇고 바삭바삭한 빵 위에 치즈는 약간만 올리고, 맛있는 소스를 뿌려야 진짜 피자 맛이 나지.

조엘: 나는 시카고 스타일 피자가 좋은데? 두껍고 깊숙한 크러스트에 치즈가 왕창 들어간 게 정말 맛있지.

• 조엘과 에단 둘 다 PizzaStore 인스턴스를 확보해야 한다. 조엘은 ChicagoPizzaStore 인스턴스를, 에단은 NYPizzaStore 인스턴스를 만들어야 한다.

const joelStore = new ChicagoPizzaStore();  // 조엘은 시카고 지점
const ethanStore = new NYPizzaStore();      // 에단은 뉴욕 지점

• PizzaStore가 만들어지면 각각 orderPizza()를 호출한다. 이때 인자를 써서 원하는 메뉴(치즈 피자, 야채 피자 등)을 알려 줘야 한다.

const joelPizza = joelStore.orderPizza("cheese");     // 조엘은 치즈 피자 주문
const ethanPizza = ethanStore.orderPizza("veggie");   // 에단은 야채 피자 주문

• 피자를 만들 때는 createPizza() 메소드가 호출되는데, 이 메소드는 PizzaStore 서브클래스인 NYPizzaStore와 ChicagoPizzaStore에 정의되어 있다. 어떤 서브클래스를 쓰든지 Pizza 객체가 orderPizza() 메소드로 리턴된다.

// 예시: ChicagoPizzaStore 내부
protected createPizza(type: string): Pizza {
  if (type === "cheese") return new ChicagoStyleCheesePizza();
  if (type === "veggie") return new ChicagoStyleVeggiePizza();
  throw new Error("없는 메뉴입니다");
}

// 예시: NYPizzaStore 내부
protected createPizza(type: string): Pizza {
  if (type === "cheese") return new NYStyleCheesePizza();
  if (type === "veggie") return new NYStyleVeggiePizza();
  throw new Error("없는 메뉴입니다");
}

• orderPizza() 메소드는 어던 스타일의 피자가 만들어졌는지 전혀 알지 못한다. 하지만 피자라는 건 알고 있어서, 그 피자를 준비하고, 굽고, 자르고, 포장하는 작업을 완료한다.

// PizzaStore 추상 클래스
orderPizza(type: string): Pizza {
  const pizza = this.createPizza(type);  // 어떤 스타일인지는 모르지만 피자임!

  pizza.prepare();
  pizza.bake();
  pizza.cut();
  pizza.box();

  return pizza;
}

🏭 Pizza 클래스 만들기

이제 피자 클래스를 만들어 보자.

abstract class Pizza {
  name: string = "";
  dough: string = "";
  sauce: string = "";
  toppings: string[] = [];

  prepare(): void {
    console.log(`\n🍕 ${this.name} 준비 중`);
    console.log(`- 도우 반죽: ${this.dough}`);
    console.log(`- 소스 추가: ${this.sauce}`);
    console.log(`- 토핑 추가: ${this.toppings.join(", ")}`);
  }

  bake(): void {
    console.log("🔥 175도에서 25분 간 굽기");
  }

  cut(): void {
    console.log("🔪 피자를 사선으로 자르기");
  }

  box(): void {
    console.log("📦 상자에 피자 담기");
  }

  getName(): string {
    return this.name;
  }
}

이제 구상 서브클래스를 만들어야 한다. 뉴욕 스타일 치즈 피자와 시카고 스타일의 치즈 피자를 만들어 보자.

class NYStyleCheesePizza extends Pizza {
  constructor() {
    super();
    this.name = "뉴욕 스타일 소스와 치즈 피자";
    this.dough = "씬 크러스트 도우";
    this.sauce = "마리나라 소스";
    this.toppings.push("잘게 썬 레지아노 치즈");
  }
}

class ChicagoStyleCheesePizza extends Pizza {
  constructor() {
    super();
    this.name = "시카고 스타일 딥 디쉬 치즈 피자";
    this.dough = "아주 두꺼운 크러스트 도우";
    this.sauce = "플럼 토마토 소스";
    this.toppings.push("잘게 조각낸 모짜렐라 치즈");
  }

	// cut 메소드 오버라이드
  cut(): void {
    console.log("🔪 네모난 모양으로 피자 자르기");
  }
}

🏭 최첨단 피자 코드 테스트

// 🍕 피자 가게 테스트 코드

const ethanStore = new NYPizzaStore();
const joelStore = new ChicagoPizzaStore();

const ethansPizza = ethanStore.orderPizza("cheese");
console.log(`에단이 주문한 ${ethansPizza.getName()}`);

const joelsPizza = joelStore.orderPizza("cheese");
console.log(`조엘이 주문한 ${joelsPizza.getName()}`);

🍕 뉴욕 스타일 소스와 치즈 피자 준비 중
- 도우 반죽: 씬 크러스트 도우
- 소스 추가: 마리나라 소스
- 토핑 추가: 잘게 썬 레지아노 치즈
🔥 175도에서 25분 간 굽기
🔪 피자를 사선으로 자르기
📦 상자에 피자 담기
에단이 주문한 뉴욕 스타일 소스와 치즈 피자

🍕 시카고 스타일 딥 디쉬 치즈 피자
- 도우 반죽: 아주 두꺼운 크러스트 도우
- 소스 추가: 플럼 토마토 소스
- 토핑 추가: 모짜렐라 치즈 슬라이스
🔥 175도에서 25분 간 굽기
🔪 피자를 사선으로 자르기
📦 상자에 피자 담기
조엘이 주문한 시카고 스타일 딥 디쉬 치즈 피자

🏭 팩토리 메소드 패턴 살펴보기

모든 팩토리 패턴은 객체 생성을 캡슐화한다. 팩토리 메소드 패턴은 서브클래스에서 어떤 클래스를 만들지 결정함으로써 객체 생성을 캡슐화한다.

[🔨 생산자 클래스: PizzaStore]   ← 추상 클래스 (Creator)
        │
        └── orderPizza() → 공통 조리 프로세스
                 │
                 ▼
        createPizza(type) ← **추상 메서드**
                 │
     ┌────────────┴────────────┐
     │                         │
[NYPizzaStore]         [ChicagoPizzaStore]
  createPizza()           createPizza()
      │                       │
      ▼                       ▼

[🍕 제품 클래스: Pizza]    ← 추상 클래스 (Product)
                 │
     ┌────────────┴────────────┐
     │                         │
[NYStyleCheesePizza]  [ChicagoStyleCheesePizza]

🔨 생산자 클래스 (Creator)

• PizzaStore가 생산자 클래스
• 핵심 메서드 orderPizza()는 피자를 주문받고 조리하는 공통 흐름을 담당
• 어떤 피자를 만들지는 모름 → createPizza()라는 추상 메서드로 위임

🍕 제품 클래스 (Product)

• Pizza는 모든 피자의 공통적인 동작을 정의하는 추상 클래스
  • prepare(), bake(), cut(), box() 등의 메서드 포함

🏭 병렬 클래스 계층구조 알아보기

구상 생산자별로 수많은 제품을 만들 수 있다. 시카고 피자 생산자는 여러가지 시카고 스타일 피자를, 뉴욕 피자 생산자는 여러가지 뉴욕 스타일 피자를 만드는 방식이다. 생산자 클래스와 거기에 대응되는 제품 클래스는 병렬 계층구조로 볼 수 있다. 2개의 병렬 클래스 계층구조를 나란히 놓고 어떤 방식으로 연관되는지 알아보자.

[🔨 생산자 계층]                         [🍕 제품 계층]
PizzaStore (추상 클래스)          <-->     Pizza (추상 클래스)
    │                                         │
    ├── NYPizzaStore                          ├── NYStyleCheesePizza
    │     └── createPizza("cheese") ─────────►└── NYStyleVeggiePizza
    │                                         │
    └── ChicagoPizzaStore                     ├── ChicagoStyleCheesePizza
          └── createPizza("cheese") ─────────►└── ChicagoStyleVeggiePizza

계층	클래스 예시	설명
생산자 계층	PizzaStore, NYPizzaStore, ChicagoPizzaStore	피자 주문 흐름을 제어. 어떤 스타일의 피자를 만들지는 서브클래스가 결정
제품 계층	Pizza, NYStyleCheesePizza, ChicagoStyleVeggiePizza	실제 피자 클래스. 지역 스타일에 따라 구성 요소(소스, 토핑 등)가 다름
연관	createPizza() 메서드를 통해 연결됨	생산자가 어떤 제품 클래스를 만들지 결정함

🏭 팩토리 메소드 패턴의 정의

팩토리 메소드 패턴에서는 객체를 생성할 때 필요한 인터페이스를 만든다. 어떤 클래스의 인스턴스를 만들지는 서브클래스에서 결정한다. 팩토리 메소드 패턴을 사용하면 클래스 인스턴스 만드는 일을 서브클래스에 맡기게 된다.

다른 팩토리를 쓸 때와 마찬가지로 팩토리 메소드 패턴으로 구상 형식 인스턴스를 만드는 작업을 캡슐화할 수 있다. 밑에 있는 다이어그램을 보면, Creator 추상 클래스에서 객체를 만드는 메소드, 즉 팩토리 메소드용 인터페이스를 제공한다는 사실을 알 수있다. Creator 추상 클래스에 구현되어 있는 다른 메소드는 팩토리 메소드에 의해 생산된 제품으로 필요한 작업을 처리한다. 하지만 실제 팩토리 메소드를 구현하고 제품(객체 인스턴스)을 만드는 일은 서브클래스에서만 할 수 있다.

팩토리 메소드 패턴에서는 어떤 클래스의 인스턴스를 만들지를 서브클래스에서 결정한다.

서브클래스에서 어떤 클래스의 인스턴스를 만들지를 결정해서가 아니라, 생산자 클래스가 실제 생산될 제품을 전혀 모르는 상태로 만들어지기 때문이다. 더 정확하게 말하면, 사용하는 서브클래스에 따라 생산되는 객체 인스턴스가 결정된다.

💡 진짜 쉬운 예비 비유: 마법 학교 🧙

상황:

• 마법 학교 본부에는 주문서 처리 시스템이 있다. (orderScroll())
• 주문서를 처리하려면 마법서를 만들어야 한다. (createScroll())
• 그런데 학교마다 사용하는 마법서 스타일이 다르다.

abstract class MagicSchool {
  orderScroll(type: string) {
    const scroll = this.createScroll(type); // 어떤 스크롤을 만드는지는 모르지만
    scroll.prepare();                       // 공통 로직은 여기서 처리
  }

  protected abstract createScroll(type: string): MagicScroll;
}

→ createScroll()이 바로 팩토리 메소드

→ 어떤 스크롤을 만들지는 HogwartsSchool, BeauxbatonsSchool 같은 서브클래스가 결정

🏭 의존성 뒤집기 원칙

디자인 원칙
추상화된 것에 의존하게 만들고 구상 클래스에 의존하지 않게 만든다.

이 원칙과 “구현보다는 인터페이스에 맞춰서 프로그래밍한다.” 라는 원칙이 똑같다는 생각이 들 수도 있다. 물론 비슷하긴 하지만 의존성 뒤집기 원칙에서는 추상화를 더 많이 강조한다. 이 원칙에는 고수준 구성 요소가 저수준 구성 요소에 의존하면 안 되며, 항상 추상화에 의존하게 만들어야 한다는 뜻이 담겨 있다.

의존성 뒤집기 원칙에 따르면, 구상 클래스처럼 구체적인 것이 아닌 추상 클래스나 인터페이스와 같이 추상적인 것에 의존하는 코드를 만들어야 한다. 이 원칙은 고수준 모듈과 저수준 모듈에 모두 적용될 수 있다. 그런데 이 원칙을 어떻게 적용할 수 있을까?

[고수준 모듈: PizzaStore]
           │
           ▼
  [NYStyleCheesePizza] [ChicagoStyleVeggiePizza] ...
      (저수준 모듈 - 실제 구현체)

심하게 의존적인 PizzaStore의 가장 큰 문제점은 PizzaStore가 모든 종류의 피자에 의존한다는 점이다.

        [🍽️ PizzaStore (고수준 모듈)]
                 │
                 ▼
 [🍕 Pizza (추상 제품 인터페이스/추상 클래스)]
                 ▲
                 │
  [NYStyleCheesePizza] [ChicagoStyleVeggiePizza] ...
      (저수준 모듈 - 실제 구현체)

팩토리 메소드 패턴을 적용하면 고수준 구성 요소인 PizzaStore와 저수준 구성 요소인 피자 객체 모두가 추상 클래스인 Pizza에 의존한다는 사실을 알 수 있다.

의존성 뒤집기 원칙에서 뭘 뒤집는다는 거죠?

의존성 뒤집기 원칙에 ‘뒤집기’ 라는 말이 들어있는 이유는 객체지향 디자인을 할 때 일반적으로 생각하는 방법과는 반대로 뒤집어서 생각해야 하기 때문이다. 고수준 모듈과 저수준 모듈이 둘 다 하나의 추상 클래스에 의존한다!

다음의 가이드라인을 따르면 의존성 뒤집기 원칙에 위배되는 객체지향 디자인을 피하는 데 도움이 된다.

• 변수에 구상 클래스의 레퍼런스를 저장하지 맙시다.
  • new 연산자를 사용하면 구상 클래스의 레퍼런스를 사용하게 된다. 그러니 팩토리를 써서 구상 클래스의 레퍼런스를 변수에 저장하는 일을 미리 방지하자.
• 구상 클래스에서 유도된 클래스를 만들지 맙시다.
  • 구상 클래스에서 유도된 클래스를 만들면 특정 구상 클래스에 의존하게 된다. 인터페이스나 추상 클래스처럼 추상회된 것으로부터 클래스를 만들어야 한다.
• 베이스 클래스에 이미 구현되어 있는 메소드를 오버라이드하지 맙시다.
  • 이미 구현되어 있는 메소드를 오버라이드한다면 베이스 클래스가 제대로 추상화되지 않는다. 베이스 클래스에서 메소드를 정의할 때는 모든 서브클래스에서 공유할 수 있는 것만 정의해야 한다.

🏭 원재료 종류 알아보기

최근 들어온 정보에 따르면, 새로운 프레임워크가 도입된 이후로 지점에서 우리가 정한 절차는 잘 따르는데, 몇몇 지점에서 자잘한 재료를 더 싼 재료로 바꿔서 마진을 높이고 있다고 한다. 이런 일이 계속되면 브랜드 이미지에 큰 타격이 올 수도 있기에 뭔가 조치를 취해야 한다.

원재료 품질 관리 방법

원재료를 생산하는 공장을 만들고 지점까지 재료를 배달하면 어떨까? 하지만 지점이 서로 멀리 떨어져 있고, 뉴욕의 레드 소스와 시카고의 레드 소스가 서로 다르다는 문제가 있다. 이 문제를 해결하려면 뉴욕과 시카고에 각기 다른 재료를 보낼 수 있어야 한다.

• 뉴욕 스타일 피자는 얇은 도우 + 마리나라 소스 + 레지아노 치즈
• 시카고 스타일 피자는 두꺼운 도우 + 플럼 토마토 소스 + 모짜렐라 치즈

🏭 원재료군으로 묶기

사로 다른 재료를 제공하려면 원재료군을 처리할 방법을 생각해 봐야 한다. 모든 피자는 같은 구성 요소(clams, sauce…)로 이루어지지만, 지역마다 구성 요소(frozenClams, freshClams…)를 다른 종류로 표현한다.

• 시카고
  • FrozenClams, PlumTomatoSauce, MozzarellaCheese…
• 뉴욕
  • FreshClams, MarinaraSauce, ReggianoCheese…

🏭 원재료 팩토리 만들기

우선 모든 원재료를 생산하는 팩토리용 인터페이스를 정의한다.

// 추상 재료 팩토리
interface PizzaIngredientFactory {
  createDough(): Dough;
  createSauce(): Sauce;
  createCheese(): Cheese;
  createVeggies(): Veggie[];
  createPepperoni(): Pepperoni;
  createClams(): Clams;
}

🏭 뉴욕 원재료 팩토리 만들기

이 팩토리에서는 마리나라 소스, 레지아노 치즈, 신선한 조개 등을 전문적으로 생산한다.

class NYPizzaIngredientFactory implements PizzaIngredientFactory {
  createDough(): Dough {
    return new ThickCrustDough();
  }

  createSauce(): Sauce {
    return new PlumTomatoSauce();
  }

  createCheese(): Cheese {
    return new MozzarellaCheese();
  }
  
  createVeggies(): Veggie[] {
    return [
      new Garlic(),
      new Onion(),
      new Mushroom(),
      new RedPepper(),
    ];
  }
  
  createPepperoni(): Pepperoni {
	  return new Slicedpepperoni();
  }
  
  createClams(): Clams {
	  return new FrozenClams();
  }
}

🏭 시카고 원재료 팩토리 만들기

class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {
  createDough(): Dough {
    return new ThinCrustDough();
  }

  createSauce(): Sauce {
    return new MarinaraSauce();
  }

  createCheese(): Cheese {
    return new ReggianoCheese();
  }
  
  createVeggies(): Veggie[] {
    return [
      new BlackOlives(),
      new Spinach(),
      new EggPlant(),
    ];
  }
  
  createPepperoni(): Pepperoni {
	  return new Slicedpepperoni();
  }
  
  createClams(): Clams {
	  return new FreshClams();
  }
}

🏭 Pizza 클래스 변경하기

Pizza 클래스가 팩토리에서 생산한 원재료만 사용하도록 코드를 고쳐보자.

abstract class Pizza {
  name: string = "";
  dough: string = "";
  sauce: string = "";
  vegie: string[] = [];
  cheese: string = "";
  pepperoni: string = "";
  clam: string = "";


  // 추상 메서드로 선언 → 서브클래스에서 반드시 구현해야 함
  abstract prepare(): void;

  bake(): void {
    console.log("🔥 175도에서 25분 간 굽기");
  }

  cut(): void {
    console.log("🔪 피자를 사선으로 자르기");
  }

  box(): void {
    console.log("📦 상자에 피자 담기");
  }

  getName(): string {
    return this.name;
  }
}

치즈 피자 코드는 다음과 같이 만들 수 있다.

• 피자의 원재료를 제공하는 팩토리가 필요하다. 각 피자 클래스는 생성자로부터 팩토리를 전달받고 그 팩토리를 인스턴스 변수에 저장한다.
• prepare() 메소드에서 치즈 피자를 만드는 각 단계를 처리한다. 재료가 필요할 때마다 팩토리에 있는 메소드를 호출해서 만든다.

class CheesePizza extends Pizza {
  constructor(private ingredientFactory: PizzaIngredientFactory) {
    super();
  }

  prepare(): void {
    console.log(`🍕 준비 중 ${this.name}`);
    this.dough = this.ingredientFactory.createDough();
    this.sauce = this.ingredientFactory.createSauce();
    this.cheese = this.ingredientFactory.createCheese();
  }
}

🏭 올바른 재료 공장 사용하기

class NYPizzaStore extends PizzaStore {
  protected createPizza(type: string): Pizza {
    // 뉴욕 지점에는 뉴욕 피자 원재료 팩토리를 전달해 줘야 한다.
    // 필요한 재료는 이 팩토리에서 공급한다.
    const ingredientFactory = new NYPizzaIngredientFactory();

    if (type === "cheese") {
      const pizza = new CheesePizza(ingredientFactory);
      pizza.setName("뉴욕 스타일 치즈 피자");
      return pizza;
    }
    .
    .
    .
  }
}

[PizzaStore]                 [Pizza]
     ▲                           ▲
[NYPizzaStore]             [CheesePizza]
     │                           ▲
     ▼                           │
[NYPizzaIngredientFactory] ─────┘
      └── createDough(), createSauce(), createCheese()

🏭 새로운 코드로 또 피자 주문하기

에단: 난 여전히 뉴욕 스타일이 좋더라

조엘: 난 그냥 시카고 스타일로 먹을래

• 주문 첫 단계는 바뀌지 않았으므로 우선 각각의 피자 가게가 필요하다.

const ethanStore = new NYPizzaStore(); // 에단: 뉴욕 스타일
const joelStore = new ChicagoPizzaStore(); // 조엘: 시카고 스타일

• 가게가 준비됐으므로 주문한다.

const ethansPizza = ethanStore.orderPizza("cheese");
const joelsPizza = joelStore.orderPizza("cheese");

• orderPizza() 메소드는 일단 createPizza() 메소드를 호출한다.

abstract class PizzaStore {
  orderPizza(type: string): Pizza {
    const pizza = this.createPizza(type); // ← 여기가 핵심!
    pizza.prepare();                      // 이후는 공통 로직
    pizza.bake();
    pizza.cut();
    pizza.box();
    return pizza;
  }

  protected abstract createPizza(type: string): Pizza;
}

• 원재료 팩토리를 사용하므로 여기서부터 달라진다. createPizza() 메소드가 호출되면 원재료 팩토리가 돌아가기 시작한다.

class NYPizzaStore extends PizzaStore {
  protected createPizza(type: string): Pizza {
    const ingredientFactory = new NYPizzaIngredientFactory();

    if (type === "cheese") {
      const pizza = new CheesePizza(ingredientFactory);
      pizza.setName("뉴욕 스타일 치즈 피자");
      return pizza;
    }

    throw new Error("해당 메뉴 없음");
  }
}

• 이제 피자를 준비한다. prepare() 메소드를 호출하면 팩토리에 원재료 주문이 들어간다.

class CheesePizza extends Pizza {
  constructor(private ingredientFactory: PizzaIngredientFactory) {
    super();
    this.setName("치즈 피자");
  }

  prepare(): void {
    console.log(`🍕 ${this.name} 준비 중`);
    this.dough = this.ingredientFactory.createDough();
    this.sauce = this.ingredientFactory.createSauce();
    this.cheese = this.ingredientFactory.createCheese();
  }
}

• 피자 준비 완료

pizza.bake(); // "🔥 175도에서 25분 간 굽기"
pizza.cut();  // "🔪 피자를 사선으로 자르기" 또는 네모 자르기
pizza.box();  // "📦 상자에 피자 담기"

🏭 추상 팩토리 패턴의 정의

추상 팩토리 패턴(Abstract Factory Pattern)은 구상 클래스에 의존하지 않고도 서로 연관되거나 의존적인 객체로 이루어진 제품군을 생산하는 인터페이스를 제공한다. 구상 클래스는 서브클래스에서 만든다.

추상 팩토리 패턴을 사용하면 클라이언트에서 추상 인터페이스로 일련의 제품을 공급받을 수 있다. 이때, 실제로 어떤 제품이 생산되는지는 전혀 알 필요가 없다. 따라서 클라이언트와 팩토리에서 생산되는 제품을 분리할 수 있다.

✅ 아주 쉽게 말하면?

“서로 관련된 객체들을 한꺼번에 일관된 방식으로 만들 수 있도록 도와주는 패턴”

🍕 피자 예시로 설명하면?

뉴욕 피자는 얇은 도우 + 마리나라 소스 + 레지아노 치즈

시카고 피자는 두꺼운 도우 + 플럼 토마토 소스 + 모짜렐라 치즈

🍕 스타일이 다르면 재료 전체가 세트로 바뀌어야 함

→ 그래서 재료를 한 번에 묶어서 생성할 수 있는 팩토리가 필요

→ 그게 바로 추상 팩토리 패턴!

   [👨‍🍳 PizzaIngredientFactory]        ← 추상 팩토리
    ├─ createDough(): Dough
    ├─ createSauce(): Sauce
    └─ createCheese(): Cheese

       ▲                         ▲
       │                         │
[NYPizzaIngredientFactory] [ChicagoPizzaIngredientFactory]
     └─ 얇은 도우                 └─ 두꺼운 도우
     └─ 마리나라 소스             └─ 플럼 토마토 소스
     └─ 레지아노 치즈             └─ 모짜렐라 치즈

               ↓ 사용
         [🍕 CheesePizza]
          └─ prepare()에서 재료 생성 요청

🏭 팩토리 메소드 패턴과 추상 팩토리 패턴

구분	팩토리 메소드	추상 팩토리
목적	한 가지 제품을 생성	여러 관련된 제품군 생성
확장	서브클래스에서 제품 결정	제품군 전체를 팩토리로 대체
예시	피자 종류만 다름	피자 재료까지 지역별로 다름
구조	상속 기반	구성 기반 (인터페이스 전달)

✨ 정리

• 추상 팩토리 패턴은 “제품군 전체를 한 번에 바꾸고 싶을 때” 유용함
• Pizza 클래스는 재료를 직접 new 하지 않음 → 재료 팩토리에 위임
• 지역별 재료가 다르면, 지역별 팩토리만 바꾸면 됨
• 코드 수정 없이, 제품군 교체 가능 (OCP 유지)