[디자인 패턴] 팩토리 패턴(3) - 추상 팩토리 (Abstract Factory) 패턴

추상 팩토리 (Abstract Factory) 패턴

🔍 추상 팩토리 패턴

지난 글에서는 팩토리 메서드 패턴에 대해 알아봤다.

추상 팩토리 패턴은 팩토리 메서드 패턴과 유사해보일 수 있으나, 추상 팩토리 패턴의 경우 연관된 객체들을 모아 관리한다는 것에 큰 차이가 있다.

 

▶️ 추상 팩토리 패턴이란?

추상 팩토리 패턴은 연관된 객체들을 생성할 때 하나의 팩토리 클래스에서 생성을 한다는 특징이 있다.

 

예를 들어, 자동차의 부품을 생성하는 추상 팩토리 패턴을 만든다고 하자. 자동차 부품에 타이어와 엔진이 있다고 할 때, 각 부품에 대한 객체를 다른 팩토리 메서드에서 생성하는 게 아니라 동일한 팩토리 메서드에서 관리해야 한다. 타이어와 엔진은 둘 다 자동차 부품으로 연관된 객체들이기 때문이다.

 

🔑 예제 코드

각각의 차 종류에 대해 자동차 부품 객체를 생성하는 추상 팩토리 패턴 예제를 알아보자.

▶️ AbstractProduct: 차 부품 관련 인터페이스

// Abstract Product - Engine
public interface Engine {
    void start();
}

// Abstract Product - Tire
public interface Tire {
    void roll();
}

// Abstract Product - Seat
public interface Seat {
    void recline();
}

• 각각의 차 부품(Engine, Tire, Seat) 인터페이스 정의

 

▶️ Product: 차 부품들의 구체적인 구현체

// Concrete Product - SUV 부품
public class SUVEngine implements Engine {
    @Override
    public void start() {
        System.out.println("SUV Engine is starting.");
    }
}

public class SUVTire implements Tire {
    @Override
    public void roll() {
        System.out.println("SUV Tire is rolling.");
    }
}

public class SUVSeat implements Seat {
    @Override
    public void recline() {
        System.out.println("SUV Seat is reclining.");
    }
}

• SUV에 필요한 차 부품 구현체 정의

 

// Concrete Product - Truck 부품
public class TruckEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Truck Engine is starting.");
    }
}

public class TruckTire implements Tire {
    @Override
    public void roll() {
        System.out.println("Truck Tire is rolling.");
    }
}

public class TruckSeat implements Seat {
    @Override
    public void recline() {
        System.out.println("Truck Seat is reclining.");
    }
}

• Truck에 필요한 차 부품 구현체 정의

 

▶️ Abstract Factory: 부품들을 생성하는 추상 팩토리

// Abstract Factory - Car 부품을 생성하는 팩토리
public interface CarFactory {
    Engine createEngine();
    Tire createTire();
    Seat createSeat();
}

• 각 차에 필요한 부품(Engine, Tire, Steat)을 생성하는 메서드를 추상화한 인터페이스
• Concrete Factory에서 해당 인터페이스를 구현해 실제 부품들을 생성해야 한다. (하단의 SUVFactory, TruckFactory)

 

▶️ Concrete Factory: 각 차에 맞는 부품들을 생성하는 구체적인 팩토리

// Concrete Factory - SUV에 맞는 부품들을 생성
public class SUVFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new SUVEngine();
    }

    @Override
    public Tire createTire() {
        return new SUVTire();
    }

    @Override
    public Seat createSeat() {
        return new SUVSeat();
    }
}

• SUV에 맞는 부품 생성

 

// Concrete Factory - Truck에 맞는 부품들을 생성
public class TruckFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new TruckEngine();
    }

    @Override
    public Tire createTire() {
        return new TruckTire();
    }

    @Override
    public Seat createSeat() {
        return new TruckSeat();
    }
}

• Truck에 맞는 부품 생성

 

▶️ Client

public class Main {
    public static void main(String[] args) {
        // 팩토리 메서드를 사용하여 객체 생성
        CarFactory suvFactory = new SUVFactory();
        Engine suvEngine = suvFactory.createEngine();
        Tire suvTire = suvFactory.createTire();
        Seat suvSeat = suvFactory.createSeat();

        System.out.println("SUV Parts:");
        suvEngine.start(); // "SUV Engine is starting."
        suvTire.roll();    // "SUV Tire is rolling."
        suvSeat.recline(); // "SUV Seat is reclining."

        System.out.println();

        CarFactory truckFactory = new TruckFactory();
        Engine truckEngine = truckFactory.createEngine();
        Tire truckTire = truckFactory.createTire();
        Seat truckSeat = truckFactory.createSeat();

        System.out.println("Truck Parts:");
        truckEngine.start(); // "Truck Engine is starting."
        truckTire.roll();    // "Truck Tire is rolling."
        truckSeat.recline(); // "Truck Seat is reclining."
    }
}

 

💣 추상 팩토리 패턴의 한계

추상 팩토리 패턴은 팩토리 메서드 패턴과 유사한 장단점을 가지고 있다.

팩토리 메서드 패턴과 동일하게 심플 팩토리가 OCP를 위배한다는 단점을 추상 팩토리 패턴에서는 보완할 수 있다. 추가적으로 여러 개의 비슷한 객체를 하나의 팩토리 객체에 모아둘 수 있다.

 

하지만 새로운 구현클래스를 추가할 때마다 해당 객체에 대한 팩토리 클래스를 정의해야하기 때문에 코드량이 증가한다는 단점이 존재한다.