[디자인패턴] 팩토리 패턴 (Factory Pattern)

💡 팩토리 메소드 패턴 (Factory Method Pattern)
객체를 생성하기위한 인터페이스를 정의하는데, 어떤 클래스의 인스턴스를 만들어지는 서브클래스에서 정하게 만든다. 즉, 팩토리 메소드 패턴을 이용하면 클래스의 인스턴스를 만드는 일을 서브클래스에게 맡기는 것

💡 추상 팩토리 패턴 (Abstract Factory Pattern)
인터페이스를 이용하여 서로 연관된, 또는 의존하는 객체를 구상 클래스를 지정하지 않고도 생성

1. 간단한 팩토리 (Simple Factory)

1) 문제인식

다음과 같이 new 키워드를 이용하면 인터페이스가 아닌 특정 구현을 사용하게 된다.

Pizza pizza = new CheesePizza();
// Pizza pizza : 인터페이스를 써서 유연하게 만드려고 한다.
// new CheesePizza(); : 그럼에도 불구하고 구상클래스의 인스턴스를 만들어야 한다.

여러개의 다양한 구상 클래스가 존재하면 다음과 같은 코드를 만들어야 하는 경우도 생긴다.

public Pizza orderPizza (String type) {  // 어떤 피자를 조리할지 type 을 이용하여
    Pizza pizza;
    if(type.equals("cheese")) {    // 각 피자에 해당하는 객체 생성
        pizza = new CheesePizza();
    } else if (type.equals("hawaiian")) {
        pizza = new HwaiianPizza();
    } else if (type.equals("pepperoni")) {
        pizza = new PepperoniPizza();
    }
    // 피자 조리 메소드들.. 생략
    return pizza;
}

이 경우 변경 또는 확장을 할 때 오류가 발생할 가능성이 커지는 문제가 있다. 코드 수정이 필연코 발생하기 때문이다.

즉, "변화" 되는 것 때문에 new 의 사용을 주의해야 할 필요가 있다.

이 때문에 인터페이스에 맞춰서 코딩하라는 말을 하고는 한다. 인터페이스를 바탕으로 코드를 만들면, 다형성 때문에 어떤 클래스든 특정 인터페이스만 구현하면 사용할 수 있기 때문이다. 반대로, 구상 클래스를 많이 사용하면 새로운 구상 클래스가 추가될 때마다 코드를 고쳐야 하기 때문에 이 과정에서 많은 문제가 발생할 수 있다.

다시말하면 인터페이스에 맞춰 코딩하면 변화에 대해 닫혀 있는 코드가 된다. OCP 원칙을 준수한다는 의미이다.

📌 디자인 원칙
OCP (Open - Closed Principle) 원칙 , 개방 폐쇄 원칙
확장에 대해 열려 있어야 하고, 수정에 대해서는 닫혀 있어야 한다는 원칙
확장에 대해서는 Open , 변경에 대해서는 Closed 하라는 원칙

위의 pizza 클래스 생성과정을 통해 구상 클래스를 바탕으로 코딩을 하면 나중에 코드를 수정해야할 가능성이 높아지고, 유연성이 떨어진다는 것을 확인했다. 그렇다면 피할수 있는 방법은 없을까?

" 바뀔 수 있는 부분을 찾아내서 바뀌지 않는 부분하고 분리시켜야 한다 "

2) 문제를 해결해보기

객체 인스턴스를 생성하는 (new 키워드를 사용하는) 부분을 별도의 인터페이스로 분리하자.

(1) PizzaStore

public class PizzaStore {

    SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }

    public Pizza orderPizza(String type) {
        Pizza pizza;

        // 어떤 피자 만들지 공장에서 (Factory) 생성
        pizza = factory.createPizza(type);

        // 피자 조리
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

(2) 팩토리 (Factory) 생성 : SimplePizzaFactory

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        // 객체생성을 캡슐화한다. 결합도를 낮추는 방식이다.
        if (type.equals(PizzaType.CHEESE)) {
            pizza = new CheesePizza();
        } else if (type.equals(PizzaType.HAWAIIAN)) {
            pizza = new HawaiianPizza();
        } else if (type.equals(PizzaType.PEPPERONI)) {
            pizza = new PepperoniPizza();
        } else if (type.equals(PizzaType.VEGGIE)) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}
public class PizzaType {
    public static final String CHEESE = "cheese";
    public static final String HAWAIIAN = "hawaiian";
    public static final String PEPPERONI = "pepperoni";
    public static final String VEGGIE = "veggie";
}

(3) Pizza 추상 클래스

public abstract class Pizza {

    String name; // 피자이름
    String dough; // 도우
    String sauce; // 소스
    List<String> toppings = new ArrayList<>(); // 토핑

    public String getName() {
        return name;
    }

    public void prepare() {
        System.out.println("preparing... " + name);
    }

    public void bake() {
        System.out.println("baking... " + name);
    }

    public void cut() {
        System.out.println("cutting... " + name);
    }

    public void box() {
        System.out.println("boxing... " + name);
    }

    @Override
    public String toString() {
        // 피자 정보 표시
        StringBuilder sb = new StringBuilder();
        sb.append("===== " + name + " 피자 정보 =====\n");
        sb.append("dough = " + dough + "\n");
        sb.append("sauce = " + sauce + "\n");
        for (String topping : toppings) {
            sb.append("toppings = " + topping + "\n");
        }
        return sb.toString();
    }
}

(4) Pizza 추상 클래스를 구현

// 페페로니 피자
public class PepperoniPizza extends Pizza {
    public PepperoniPizza() {
        name = "Pepperoni Pizza";
        dough = "Crust";
        sauce = "Marinara sauce";
        toppings.add("Sliced Pepperoni");
        toppings.add("Sliced Onion");
        toppings.add("Grated parmesan cheese");
    }
}
// 그외 피자들..

(5) 실행

@Test
void simplePizza() {
    SimplePizzaFactory factory = new SimplePizzaFactory();
    PizzaStore pizzaStore = new PizzaStore(factory);
    pizza = pizzaStore.orderPizza(PizzaType.PEPPERONI);
    System.out.println(pizza.getName() + " 를 주문합니다.");
    System.out.println(pizza.toString());
}

(6) 결과 확인

preparing... Pepperoni Pizza
baking... Pepperoni Pizza
cutting... Pepperoni Pizza
boxing... Pepperoni Pizza
Pepperoni Pizza 를 주문합니다.
===== Pepperoni Pizza 피자 정보 =====
dough = Crust
sauce = Marinara sauce
toppings = Sliced Pepperoni
toppings = Sliced Onion
toppings = Grated parmesan cheese

간단한 팩토리 (Simple Factory) 는 이렇게 객체를 생성하는 작업을 분리해서 이용하는 것으로 디자인 패턴이라고 할 수는 없다. 프로그래밍을 하는데 있어서 자주 쓰이는 관용구에 가깝다고 할 수 있다.

3) 문제가 생겼다.

이 피자가게가 인기가 생겨 프랜차이즈화 되어 다른 지역에도 지점을 내게됐고, 각 지역별로 고유 스타일의 피자를 만들어 팔게 되었다. 모든 분점에서 PizzaStore 코드를 사용한다.

간단한 팩토리 (Simple Factory) 를 이용해서 만들어보자.

// SimplePizzaFactory를 빼고 각각의 지점별 팩토리를 만들었다.
PizzaStore seoulStore = new PizzaStore(new SeoulPizzaFactory());
seoulStore.orderPizza("cheese");

PizzaStore busanStore = new PizzaStore(new BusanPizzaFactory());
busanStore.orderPizza("cheese");

PizzaStore suwonStore = new PizzaStore(new SuwonPizzaFactory());
suwonStore.orderPizza("cheese");

위와 같은 구현으로 각 팩토리를 가진 분점들이 각자의 방식으로 피자를 만들어 팔 수 있게 되었다. 예를들어 피자를 굽는 방식이나 컷팅방식의 차이 등이다. 그러나 이런 방식으로는 지점마다 팩토리를 만들어야 한다. 지점이 늘어날수록 코드가 방대해져버리니 당연히 좋은 방법이 될 수 없다.

피자 제작활동은 모두 PizzaStore 클래스에 위임하면서도 고유의 스타일을 살릴 수 있도록 피자가게 (PizzaStore) 와 제작과정 ( prepare() → bake() → cut() → box() ) 을 하나로 묶어주는 프레임워크를 만들 필요가 생겼다.

2. 팩토리 메소드 패턴

(1) 피자가게 PizzaStore 추상 클래스 : 피자 제작활동을 모두 위임하면서도 고유스타일은 팩토리에서 해결하도록한다.

public abstract class PizzaStore {
    // Pizza 인스턴스를 만드는 일은 팩토리 역할을 하는 인스턴스에서
    public abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type) { // 팩토리 메소드에의해 생산된 제품가지고 작업처리
        Pizza pizza = createPizza(type); // 실제 팩토리 메소드 구현은 제품 만드는 서브클래스에서
        System.out.println("==== " + pizza.getName() + " 제작 ====");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

(2) PizzaStore 를 상속해서 각 지점 피자가게 서브 클래스를 만들어주고 지점에서 스타일을 결정하도록 한다.

// 서울 피자 지점
public class SeoulPizzaStore extends PizzaStore {
    @Override
    public Pizza createPizza(String type) {
        if (type.equals(PizzaType.CHEESE)) {
            return new SeoulStyleCheesePizza();
        } else if (type.equals(PizzaType.HAWAIIAN)) {
            return new SeoulStyleHawaiianPizza();
        } else if (type.equals(PizzaType.PEPPERONI)) {
            return new SeoulStylePepperoniPizza();
        } else if (type.equals(PizzaType.VEGGIE)) {
            return new SeoulStyleVeggiePizza();
        } else {
            return null;
        }
    }
}
// 부산지점
public class BusanPizzaStore extends PizzaStore {
    @Override
    public Pizza createPizza(String type) {
        if (type.equals(PizzaType.CHEESE)) {
            return new BusanStyleCheesePizza();
        } else if (type.equals(PizzaType.HAWAIIAN)) {
            return new BusanStyleHawaiianPizza();
        } else if (type.equals(PizzaType.PEPPERONI)) {
            return new BusanStylePepperoniPizza();
        } else if (type.equals(PizzaType.VEGGIE)) {
            return new BusanStyleVeggiePizza();
        } else {
            return null;
        }
    }
}

그림으로 표현하면 다음과 같은 구조를 갖는다.

(3) Pizza 클래스

public abstract class Pizza {

    String name; // 피자이름
    String dough; // 도우
    String sauce; // 소스
    List<String> toppings = new ArrayList<>();  // 토핑

    public void prepare() {
        System.out.println("preparing... " + name);
        System.out.println("tossing dough...");
        System.out.println("adding sauce...");
        System.out.println("adding toppings...");
        for (String topping : toppings) {
            System.out.println("    " + topping);
        }
    }

    public void bake() {
        System.out.println("baking... 350도에서 25분정도 구웁니다.");
    }

    public void cut() {
        System.out.println("cutting... 피자를 커팅합니다.");
    }

    public void box() {
        System.out.println("boxing... 박스에 넣습니다.");
    }

    public String getName() { return name; }

    @Override
    public String toString() {  // 피자 정보 표시
        StringBuilder sb = new StringBuilder();
        sb.append("===== " + name + " =====\n");
        sb.append("dough = " + dough + "\n");
        sb.append("sauce = " + sauce + "\n");
        for (String topping : toppings) {
            sb.append("toppings = " + topping + "\n");
        }
        return sb.toString();
    }
}

(4) Pizza 클래스를 상속받아 각 지점별 고유 스타일 피자 구현

// 서울 스타일 하와이안 피자
public class SeoulStyleHawaiianPizza extends Pizza {
    public SeoulStyleHawaiianPizza() {
        name = "Seoul Style Hawaiian Pizza";
        dough = "Thin Crust";
        sauce = "Marinara Sauce";
        toppings.add("Pineapple");
        toppings.add("Pepperoni");
        toppings.add("Italian Sausage");
    }
}
// 부산 스타일 페페로니 피자
public class BusanStylePepperoniPizza extends Pizza {
    public BusanStylePepperoniPizza() {
        name = "Busan Style Pepperoni Pizza";
        dough = "Crust";
        sauce = "Marinara sauce";
        toppings.add("Sliced Double Pepperoni");
        toppings.add("Grated parmesan cheese");
    }

    @Override
    public void cut() { // 제작과정도 각 스타일에 맞게 구현가능
        System.out.println("cutting.. square cut!");
    }
}

(5) 실행

@Test
void simpleExtend() {
    // 객체 생성을 캡슐화        
    PizzaStore seoulStore = new SeoulPizzaStore();
    PizzaStore busanStore = new BusanPizzaStore();
    
    System.out.println("서울지점 1번 손님 주문");
    Pizza fistPizza = seoulStore.orderPizza(PizzaType.HAWAIIAN);
    System.out.println("부산지점 2번 손님 주문");
    Pizza secondPizza = busanStore.orderPizza(PizzaType.PEPPERONI);
}

(6) 출력결과 확인

서울지점 1번 손님 주문
==== Seoul Style Hawaiian Pizza 제작 ====
preparing... Seoul Style Hawaiian Pizza
tossing dough...
adding sauce...
adding toppings...
    Pineapple
    Pepperoni
    Italian Sausage
baking... 350도에서 25분정도 구웁니다.
cutting... 피자를 커팅합니다.
boxing... 박스에 넣습니다.

부산지점 2번 손님 주문
==== Busan Style Pepperoni Pizza 제작 ====
preparing... Busan Style Pepperoni Pizza
tossing dough...
adding sauce...
adding toppings...
    Sliced Double Pepperoni
    Grated parmesan cheese
baking... 350도에서 25분정도 구웁니다.
cutting.. square cut!
boxing... 박스에 넣습니다.

각 지점 스타일에 맞게 제작되는 것을 확인할 수 있다.

① 생산자 클래스 PizzaStore : 객체를 생산

② 제품 클래스 Pizza : 제품을 생산

생산을 담당하는 PizzaStore 추상 클래스에서 객체를 만들기위한 메소드 createPizza() 를 제공해준다. 즉, 팩토리 메소드를 위한 인터페이스를 제공한다.

PizzaStore 에 구현되어 있는 다른 메소드 orderPizza() 에서는 팩토리 메소드에 의해 생산된 제품을 가지고 필요한 작업을 처리한다. 하지만 실제 팩토리 메소드를 구현하고 제품 (객체 인스턴스) 을 만들어 내는 일은 서브클래스에서만 할 수 있다.

→ concrete class 에 대한 의존성을 줄이는 것이 좋다.

■ 의존성 뒤집기 원칙

📌 디자인 원칙
의존성 뒤집기 원칙 (Dependency Inversion Principle)
추상화된 것에 의존하도록 만들어라. 구상 클래스 (concrete class) 에 의존하도록 만들지 않도록 한다.

PizzaStore : 추상 클래스 (abstract class)
Pizza 클래스에만 의존한다.
Pizza : 추상 클래스 (abstract class)
XxxStyleXxxPizza : 구상 클래스 (Concrete class)
각 구상 클래스 역시 Pizza 추상 클래스에 의존한다.
Pizza 인터페이스를 구현하고 있기 때문이다.

왜 '의존성 뒤집기 원칙'인가?

【적용 전】	【적용 후】
PizzaStore → SeoulStyleCheesePizza PizzaStore → BusanStylePepperoniPizza	PizzaStore → Pizza Pizza ← SeoulStyleCheesePizza Pizza ← BusanStylePepperoniPizza

위와 같이 의존관계가 뒤집어지기 때문에 의존성 뒤집기 원칙이라 한다.

팩토리 메소드 패턴을 적용하고 나면 고수준 구성요소 (PizzaStore) 와 저수준 구성요소(SeoulStyleCheesePizza, BusanStylePepperoniPizza, ...) 들이 모두 추상클래스 Pizza 에 의존하게 된다. (고수준 모듈과 저수준 모듈이 모두 하나의 추상 클래스에 의존한다.)

참고로 팩토리 메소드 패턴이 의존성 뒤집기 원칙을 준수하기 위해 쓰는 유일한 기법은 아니다.

🔑 의존성 뒤집기 원칙에 위배되는 객체지향 디자인을 피하는데 도움이 되는 가이드
1. 어떤 변수에도 구상 클래스에 대한 레퍼런스를 지정하지 않는다.
new 를 사용하면 레퍼런스를 사용하게 되는 것이다.
2. 구상 클래스에서 유도된 클래스를 만들지 않는다.
구상 클래스에서 유도된 클래스를 만들면 특정 구상 클래스에 의존하게 된다.
추상화 된 것을 사용하도록 해야 한다.
3. 베이스 클래스에 이미 구현되어 있던 메소드를 오버라이드 하지 않는다.
이미 구현된 메소드를 오버라이드 한다는 것은 애초부터 베이스 클래스가 제대로 추상화되지 않은 것이다.
베이스 클래스에서 메소드를 정의할 때는 모든 서브 클래스에서 공유할 수 있는 것만 정의해야 한다.

정리하면 만들고 있는 클래스가 바뀔 가능성이 있다면 팩토리 메소드 패턴 같은 기법을 써서 변경될 수 있는 부분을 캡슐화 하여야 한다.

3. 추상 팩토리 패턴

디자인 원칙도 지켜가면서 유연한 프레임워크를 만들었다. 각 지점들이 잘 운영되는 것 같았다. 그런데, 몇몇 지점들이 재료를 더 싼 것으로 바꿔서 원가를 절감해 마진을 남기고 있었다. 그래서 원재료의 품질까지 관리하는 방법이 필요해졌다.

원재료 군을 만들어 파악해보자. 제품에 들어가는 재료군 (반죽, 소스, 치즈, 야채, 고기 등) 은 같지만, 지역마다 재료의 구체적인 특징이 조금씩 달랐다.

(1) 원재료

대표적으로 Cheese, Dough, Sauce, Pepperoni, Fruits, Veggies 로 구분하고 각 상세 클래스를 만들어준다.

// Cheese 의 경우
public interface Cheese {
    String toString();
}
public class MozzarellaCheese implements Cheese { // 각 Cheese 구현
    public String toString() { return "mozzarella cheese"; }
}
// Dough 의 경우
public interface Dough {
    String toString();
}
public class ThinCrustDough implements Dough { // 각 Dough 구현
    public String toString() { return "thin crust dough"; }
}
// Sauce, Veggies, Pepperoni, Fruits .. 이하생략

(2) 원재료 공장을 만들자.

① 지역별로 공장 (factory) 을 만들어 각 생성 메소드를 구현하는 PizzaIngredientFactory 클래스를 만들자.

public interface PizzaIngredientFactory {
    public Dough createDough();
    public Cheese createCheese();
    public Fruits createFruits();
    public Pepperoni createPepperoni();
    public Veggies[] createVeggies();
    public Sauce createSauce();
}

② 각 지점의 원재료 공장 (factory) 를 구현

// 서울 지점 원재료 공장
public class SeoulIngredientFactory implements PizzaIngredientFactory {

    @Override
    public Dough createDough() {
        return new ThickCrustDough();
    }

    @Override
    public Cheese createCheese() {
        return new ParmesanCheese();
    }

    @Override
    public Fruits createFruits() {
        return new Pineapple();
    }

    @Override
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    @Override
    public Veggies[] createVeggies() {
        Veggies[] veggies = {new Garlic(), new Spinach(), new BlackOlives()};
        return veggies;
    }

    @Override
    public Sauce createSauce() {
        return new TomatoSauce();
    }
}
// 부산 지점 원재료 공장
public class BusanIngredientFactory implements PizzaIngredientFactory {

    @Override
    public Dough createDough() {
        return new ThinCrustDough();
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

    @Override
    public Fruits createFruits() {
        return new Pineapple();
    }

    @Override
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    @Override
    public Veggies[] createVeggies() {
        Veggies[] veggies = {new Onion(), new Spinach(), new Mushroom()};
        return veggies;
    }

    @Override
    public Sauce createSauce() {
        return new MarinaraSauce();
    }
}

(3) 피자 추상 클래스, 각 피자 구현

// 피자 추상 클래스
public abstract class Pizza {
    public String name; // 피자이름
    public Dough dough; // 도우
    public Cheese cheese; // 치즈
    public Fruits fruits; // 과일
    public Pepperoni pepperoni; // 페페로니
    public Sauce sauce; // 소스
    public Veggies[] veggies; // 야채들

    public abstract void prepare(); // point : 추상메소드로 변경됨!!

    public void bake() {
        System.out.println("baking... 350 도에서 25분");
    }

    public void box() {
        System.out.println("boxing... 박스에 포장");
    }

    public void cut() {
        System.out.println("cutting... 커팅");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("===== " + name + " =====\n");
        if (dough != null) {
            sb.append(dough);
            sb.append("\n");
        }
        if (sauce != null) {
            sb.append(sauce);
            sb.append("\n");
        }
        if (cheese != null) {
            sb.append(cheese);
            sb.append("\n");
        }
        if (pepperoni != null) {
            sb.append(pepperoni);
            sb.append("\n");
        }
        if (fruits != null) {
            sb.append(fruits);
            sb.append("\n");
        }
        if (veggies != null) {
            for (Veggies veg : veggies) {
                sb.append(veg);
                sb.append(", ");
            }
                sb.append("\n");
        }
        return sb.toString();
    }
}
// 각 피자 구현
public class PepperoniPizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

    public PepperoniPizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    public void prepare() {
        System.out.println("preparing... " + name);
        dough = ingredientFactory.createDough();
        pepperoni = ingredientFactory.createPepperoni();
        cheese = ingredientFactory.createCheese();
        sauce = ingredientFactory.createSauce();
        veggies = ingredientFactory.createVeggies();
    }
}
// 부산스타일 페페로니 피자 구현
public class BusanStylePepperoniPizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

    public BusanStylePepperoniPizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    public void prepare() {
        System.out.println("preparing... " + name);
        dough = ingredientFactory.createDough();
        pepperoni = ingredientFactory.createPepperoni();
        cheese = ingredientFactory.createCheese();
        sauce = ingredientFactory.createSauce();
        veggies = ingredientFactory.createVeggies();
    }

    @Override
    public void box() {
        System.out.println("부산 이벤트 박스에 넣습니다.");
    }
}

(4) 만든 원재료 공장을 PizzaStore 에서 사용하도록 함으로써 하나로 묶자

// 서울지점
public class SeoulPizzaStore extends PizzaStore {

    @Override
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        // 원재료 공장
        PizzaIngredientFactory ingredientFactory = new SeoulIngredientFactory();

        if (item.equals(PizzaType.PEPPERONI)) {
            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("서울 스타일 페페로니 피자");
        } else if (item.equals(PizzaType.HAWAIIAN)) {
            pizza = new HawaiianPizza(ingredientFactory);
            pizza.setName("서울 스타일 하와이안 피자");
        } else if (item.equals(PizzaType.VEGGIE)) {
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("서울 스타일 베지테리안 피자");
        }
        return pizza;
    }
}
// 부산지점
public class BusanPizzaStore extends PizzaStore {

    @Override
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new BusanIngredientFactory();

        if (item.equals(PizzaType.PEPPERONI)) {
            pizza = new BusanStylePepperoniPizza(ingredientFactory);
            pizza.setName("부산 스타일 페페로니 피자");
        } else if (item.equals(PizzaType.HAWAIIAN)) {
            pizza = new HawaiianPizza(ingredientFactory);
            pizza.setName("부산 스타일 하와이안 피자");
        } else if (item.equals(PizzaType.VEGGIE)) {
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("부산 스타일 베지테리안 피자");
        }
        return pizza;
    }
}

(5) 실행

@Test
void abstractFactoryTest() {
    PizzaStore seoulStore = new SeoulPizzaStore(); // 서울지점 생성
    PizzaStore busanStore = new BusanPizzaStore(); // 부산지점 생성
    
    System.out.println("서울 피자 주문 1");
    Pizza seoul1 = seoulStore.orderPizza(PizzaType.PEPPERONI); // 서울지점 주문1
    System.out.println("서울 피자 주문 2");
    Pizza seoul2 = seoulStore.orderPizza(PizzaType.VEGGIE); // 서울지점 주문2
    System.out.println("부산 피자 주문 1");
    Pizza busan1 = busanStore.orderPizza(PizzaType.PEPPERONI); // 부산지점 주문1
    System.out.println("부산 피자 주문 2");
    Pizza busan2 = busanStore.orderPizza(PizzaType.VEGGIE); // 부산지점 주문2
}

(6) 결과확인

서울 피자 주문 1
===== 서울 스타일 페페로니 피자 제작 =====
preparing... 서울 스타일 페페로니 피자
baking... 350 도에서 25분
cutting... 커팅
boxing... 박스에 포장

서울 피자 주문 2
===== 서울 스타일 베지테리안 피자 제작 =====
preparing... 서울 스타일 베지테리안 피자
baking... 350 도에서 25분
cutting... 커팅
boxing... 박스에 포장

부산 피자 주문 1
===== 부산 스타일 페페로니 피자 제작 =====
preparing... 부산 스타일 페페로니 피자
baking... 350 도에서 25분
cutting... 커팅
부산 이벤트 박스에 넣습니다.

부산 피자 주문 2
===== 부산 스타일 베지테리안 피자 제작 =====
preparing... 부산 스타일 베지테리안 피자
baking... 350 도에서 25분
cutting... 커팅
boxing... 박스에 포장

4. 정리하면

📌 추상 팩토리 패턴
제품군을 생성하기 위한 인터페이스를 생성 그 인터페이스를 구성하여 사용할수 있게끔 하는것

📌 추상 메소드 패턴
하나의 추상클래스에서 추상 메소드를 만들고 서브클래스들이 그 추상메소드를 구현 하여 인스턴스를 만들게끔 하는것

참고
헤드 퍼스트 디자인 패턴 (Head First Design Patterns) - 에릭 프리먼,엘리자베스 롭슨,케이시 시에라,버트 베이츠

1. 간단한 팩토리 (Simple Factory)

1) 문제인식

2) 문제를 해결해보기

(1) PizzaStore

(2) 팩토리 (Factory) 생성 : SimplePizzaFactory

(3) Pizza 추상 클래스

(4) Pizza 추상 클래스를 구현

(5) 실행

(6) 결과 확인

3) 문제가 생겼다.

2. 팩토리 메소드 패턴

(1) 피자가게 PizzaStore 추상 클래스 : 피자 제작활동을 모두 위임하면서도 고유스타일은 팩토리에서 해결하도록한다.

(2) PizzaStore 를 상속해서 각 지점 피자가게 서브 클래스를 만들어주고 지점에서 스타일을 결정하도록 한다.

(3) Pizza 클래스

(4) Pizza 클래스를 상속받아 각 지점별 고유 스타일 피자 구현

(5) 실행

(6) 출력결과 확인

■ 의존성 뒤집기 원칙

3. 추상 팩토리 패턴

(1) 원재료

(2) 원재료 공장을 만들자.

(3) 피자 추상 클래스, 각 피자 구현

(4) 만든 원재료 공장을 PizzaStore 에서 사용하도록 함으로써 하나로 묶자

(5) 실행

(6) 결과확인

4. 정리하면

티스토리툴바