추상(Abstract) 팩토리(factory) 패턴

선수 지식 : 팩토리-factory-패턴이란

1. Abstract Factory Pattern

추상 팩토리 패턴은 많은 수의 연관된 서브 클래스를 특정 그룹으로 묶어 한번에 교체할 수 있도록 만든 디자인 패턴 입니다. 추상 팩토리 패턴은 팩토리 메서드 패턴과 유사합니다. 하지만 한가지 다른 것은 팩토리를 만드는 상위 팩토리(super-factory) 클래스가 존재 합니다.

즉, Abstract Factory는 구체적인 클래스를 지정하지 않고 관련성을 갖는 객체들의 집합을 생성하거나 서로 독립적인 객체들의 집합을 생성할 수 있는 인터페이스를 제공하는 패턴 입니다.

2. 팩토리 메서드 패턴을 사용할 경우

팩토리 메서드 패턴와 추상 팩토리 패턴으로 구현의 차이점을 알아보기 위해서 팩토리 메서드 패턴의 경우를 먼저 알아보겠습니다.

클래스 간 종속성은 그래프로 표시한 것 입니다.

1. 키보드 관련 클래스

LGKeyboard와 SamsugKeyboard 클래스를 정의하고, 이를 캡슐화하는 Keyboard 인터페이스를 정의합니다. 그리고 KeyboardFactory 클래스에서 입력 값에 따라 LGKeyboard 객체를 생성할지, SamsungKeyboard를 생성할지 결정합니다.

public interface Keyboard {}

public class LGKeyboard implements Keyboard {
    public LGKeyboard() {
        System.out.println("LG 키보드 생성");
    }
}

public class SamsungKeyboard implements Keyboard {
    public SamsungKeyboard() {
        System.out.println("Samsung 키보드 생성");
    }
}

public class KeyboardFactory {
    public Keyboard createKeyboard(String type){
        Keyboard keyboard = null;
        switch (type) {
            case "LG":
                keyboard = new LGKeyboard();
                break;

            case "Samsung":
                keyboard = new SamsungKeyboard();
                break;
        }
        return keyboard;
    }
}

2. Mouse 관련 클래스

public interface Mouse {}

public class LGMouse implements Mouse {
    public LGMouse() {
        System.out.println("LG 마우스 생성");
    }
}

public class SamsungMouse implements Mouse {
    public SamsungMouse() {
        System.out.println("Samsung 마우스 생성");
    }
}

public class MouseFactory {
    public Mouse createMouse(String type) {
        Mouse mouse = null;
        switch (type) {
            case "LG":
                mouse = new LGMouse();
                break;

            case "Samsung":
                mouse = new SamsungMouse();
                break;
        }
        return mouse;
    }
}

3. ComputerFactory 클래스

public class ComputerFactory {
    public void createComputer(String type){
        KeyboardFactory keyboardFactory = new KeyboardFactory();
        MouseFactory mouseFactory = new MouseFactory();

        keyboardFactory.createKeyboard(type);
        mouseFactory.createMouse(type);
        System.out.println("--- " + type + " 컴퓨터 완성 ---");
    }
}

4. Client 클래스

public class Client {
    public static void main(String args[]){
        ComputerFactory computerFactory = new ComputerFactory();
        computerFactory.createComputer("LG");
    }
}

3. 추상 팩토리 패턴 적용

1. ComputerFactory 인터페이스

SamsungComputerFactory, LGComputerFactory 클래스를 정의하고, 이들을 캡슐화하는 ComputerFactory 인터페이스를 정의합니다. 각 클래스는 자신의 제조사 부품 객체를 생성합니다. 예를 들어, SamsungComputerFactory 클래스는 삼성 키보드, 마우스를 가지므로 SamsungKeyboard, SamsungMouse 객체를 생성합니다.

public interface ComputerFactory {
    public Keyboard createKeyboard();
    public Mouse createMouse();
}

public class SamsungComputerFactory implements ComputerFactory {
    public SamsungKeyboard createKeyboard() {
        return new SamsungKeyboard();
    }

    public SamsungMouse createMouse() {
        return new SamsungMouse();
    }
}

public class LGComputerFactory implements ComputerFactory {
    public LGKeyboard createKeyboard() {
        return new LGKeyboard();
    }

    public LGMouse createMouse() {
        return new LGMouse();
    }
}

2. FactoryOfComputerFactory 클래스

이 클래스는 패턴 적용 전 ComputerFactory 클래스와 하는일이 같습니다.
입력값에 따라 객체 생성을 분기해서 어떤 제조사 컴퓨터 객체를 생성할지 결정합니다. 그런데, 부품이 아니라 컴퓨터 객체를 생성한다는 점에서 차이점이 있습니다.

public class FactoryOfComputerFactory {
    public void createComputer(String type){
        ComputerFactory computerFactory= null;
        switch (type){
            case "LG":
                computerFactory = new LGComputerFactory();
                break;

            case "Samsung":
                computerFactory = new SamsungComputerFactory();
                break;
        }

        computerFactory.createKeyboard();
        computerFactory.createMouse();
    }
}

3. Client 클래스

public class Client {
    public static void main(String args[]){
        FactoryOfComputerFactory factoryOfComputerFactory = new FactoryOfComputerFactory();
        factoryOfComputerFactory.createComputer("LG");
    }
}

요약

AbstractFactory

실제 팩토리 클래스의 공통 인터페이스

ConcreteFactory

구체적인 팩토리 클래스로 AbstractFactory 클래스의 추상 메서드를 오버라이드함으로써 구체적인 제품을 생성.

AbstractProduct

제품의 공통 인터페이스

ConcreteProduct

구체적인 팩토리 클래스에서 생성되는 구체적인 제품

4. 총 정리

추상 팩토리 패턴은 연관된 객체들의 집합을 형성할 때 이용하는 디자인 패턴 입니다. 객체들의 집합을 추상화시키고 클라이언트에게 추상화된 인터페이스를 제공합니다. 이렇게 하면 클라이언트에서는 일관되게 객체를 전달 받아 사용할 수 있게 됩니다.

팩토리 메서드 패턴과 추상 팩토리 패턴 차이점

1. 팩토리 메서드 패턴

• 상속을 통해 객체를 만든다.
• 객체 생성을 담당하는 팩토리가 서브 클래스에 구현되어 있다.
• 일반적으로 한 가지 객체를 생성할 때 사용한다.

2. 추상 팩토리 패턴

• 연관된 객체들의 집합을 만들기 위한 추상 형식을 제공한다.
• 제품이 생상되는 방법은 추상 형식의 서브 클래스에 정의된다.
• 여러 객체를 하나의 응집화된 군을 만들 때 사용한다.

팩토리 메서드 패턴과 추상 팩토리 패턴은 객체 생성을 캡슐화 한다는 공통점이 있습니다. 이러한 디자인 패턴을 활용하여 객체 간의 느슨한 결합 관계를 만들고, 특정 구현에 의존하지 않는 설계를 할 수 있습니다.

5. reference

https://refactoring.guru/design-patterns/abstract-factory
https://victorydntmd.tistory.com/300