디자인패턴 - 팩토리 메소드(Factory Method)

팩토리 메소드 패턴(Factory Method Pattern)은 객체 생성에 대한 인터페이스를 정의하지만, 어떤 클래스의 인스턴스를 생성할지는 서브클래스에서 결정하도록 하는 디자인 패턴입니다. 이 패턴은 클라이언트 코드가 구체적인 클래스에 의존하지 않도록 하여, 객체 생성의 유연성과 확장성을 제공합니다.

 

Factory Method

주요 특징

1. 객체 생성의 캡슐화: 객체 생성 로직을 서브클래스에 위임하여, 클라이언트 코드에서 구체적인 클래스에 의존하지 않게 합니다.
2. 유연성: 새로운 제품을 추가할 때, 기존 코드를 수정하지 않고 새로운 서브클래스를 추가하여 쉽게 확장할 수 있습니다.
3. 일관성 유지: 동일한 인터페이스를 통해 다양한 객체를 생성할 수 있어, 일관된 방식으로 객체를 관리할 수 있습니다.

C++ 코드 예시

아래는 팩토리 메소드 패턴을 사용하여 서로 다른 종류의 차량을 생성하는 예시입니다.

#include <iostream>
#include <string>

// 제품 인터페이스
class Vehicle {
public:
    virtual void drive() = 0; // 순수 가상 함수
};

// 구체 제품 클래스
class Car : public Vehicle {
public:
    void drive() override {
        std::cout << "Driving a car." << std::endl;
    }
};

class Bike : public Vehicle {
public:
    void drive() override {
        std::cout << "Riding a bike." << std::endl;
    }
};

// 팩토리 인터페이스
class VehicleFactory {
public:
    virtual Vehicle* createVehicle() = 0; // 순수 가상 함수
};

// 구체 팩토리 클래스
class CarFactory : public VehicleFactory {
public:
    Vehicle* createVehicle() override {
        return new Car();
    }
};

class BikeFactory : public VehicleFactory {
public:
    Vehicle* createVehicle() override {
        return new Bike();
    }
};

// 클라이언트 코드
int main() {
    VehicleFactory* factory;

    // CarFactory를 사용하여 Car 객체 생성
    factory = new CarFactory();
    Vehicle* vehicle1 = factory->createVehicle();
    vehicle1->drive();
    delete vehicle1;
    delete factory;

    // BikeFactory를 사용하여 Bike 객체 생성
    factory = new BikeFactory();
    Vehicle* vehicle2 = factory->createVehicle();
    vehicle2->drive();
    delete vehicle2;
    delete factory;

    return 0;
}

 

설명 :

1. 제품 인터페이스: Vehicle 클래스는 차량의 인터페이스를 정의합니다. drive 메서드는 각 차량이 어떻게 운전되는지를 정의합니다.
2. 구체 제품 클래스: Car와 Bike 클래스는 Vehicle 인터페이스를 구현하여, 각기 다른 방식으로 drive 메서드를 정의합니다.
3. 팩토리 인터페이스: VehicleFactory 클래스는 차량 객체를 생성하는 메서드를 정의합니다.
4. 구체 팩토리 클래스: CarFactory와 BikeFactory는 VehicleFactory를 구현하여, 각각 Car와 Bike 객체를 생성합니다.
5. 클라이언트 코드: main 함수에서는 팩토리를 사용하여 Car와 Bike 객체를 생성하고, drive 메서드를 호출하여 각 차량의 동작을 출력합니다.

 

실행결과 :

Driving a car.
Riding a bike.

 

다른 예시 하나 더 갑니다.

#include <iostream>
#include <string>
using namespace std;

// Product interface
class Animal {
public:
    virtual void speak() const = 0; // Pure virtual function
    virtual ~Animal() {}
};

// Concrete Product: Dog
class Dog : public Animal {
public:
    void speak() const override {
        cout << "Woof! Woof!" << endl;
    }
};

// Concrete Product: Cat
class Cat : public Animal {
public:
    void speak() const override {
        cout << "Meow! Meow!" << endl;
    }
};

// Creator class
class AnimalFactory {
public:
    virtual Animal* createAnimal() const = 0; // Factory Method
    virtual ~AnimalFactory() {}
};

// Concrete Creator: DogFactory
class DogFactory : public AnimalFactory {
public:
    Animal* createAnimal() const override {
        return new Dog();
    }
};

// Concrete Creator: CatFactory
class CatFactory : public AnimalFactory {
public:
    Animal* createAnimal() const override {
        return new Cat();
    }
};

// Client code
int main() {
    // Create a Dog using DogFactory
    AnimalFactory* dogFactory = new DogFactory();
    Animal* dog = dogFactory->createAnimal();
    cout << "Dog says: ";
    dog->speak();

    // Create a Cat using CatFactory
    AnimalFactory* catFactory = new CatFactory();
    Animal* cat = catFactory->createAnimal();
    cout << "Cat says: ";
    cat->speak();

    // Clean up
    delete dog;
    delete dogFactory;
    delete cat;
    delete catFactory;

    return 0;
}

 

코드 설명 :

1. Animal 인터페이스 (Product):
   • Animal은 팩토리 메소드 패턴의 제품 인터페이스입니다.
   • 모든 동물 객체는 speak 메서드를 구현해야 합니다.
2. 구체적인 제품 클래스 (Dog와 Cat):
   • Dog 클래스와 Cat 클래스는 Animal 인터페이스를 상속받아 구체적인 제품을 정의합니다.
   • 각 클래스는 speak 메서드를 구현하여 각각 "Woof! Woof!"와 "Meow! Meow!"를 출력합니다.
3. 팩토리 인터페이스 (AnimalFactory):
   • createAnimal이라는 순수 가상 메서드를 포함하여, 객체 생성의 인터페이스를 정의합니다.
4. 구체적인 팩토리 클래스 (DogFactory와 CatFactory):
   • 각각 Dog와 Cat 객체를 생성하는 역할을 합니다.
   • createAnimal 메서드를 구현하여 특정 제품 객체를 반환합니다.
5. 클라이언트 코드:
   • 클라이언트는 팩토리 객체(DogFactory 또는 CatFactory)를 통해 createAnimal 메서드를 호출하여 제품 객체를 생성합니다.
   • 클라이언트는 제품 생성의 세부 사항을 몰라도 됩니다.

실행 결과 :

 

Dog says: Woof! Woof!
Cat says: Meow! Meow!

 

이와 같이 팩토리 메소드 패턴을 사용하면 객체 생성 로직을 캡슐화하여 클라이언트 코드의 복잡성을 줄이고, 새로운 객체 유형을 쉽게 추가할 수 있는 유연성을 제공합니다.