팩토리 (Factory)

출처 : https://refactoring.guru/design-patterns/factory-method

 

객체 생성을 처리하기 위한 디자인 패턴 중 하나로, 객체를 생성하는 코드를 캡슐화하고 클라이언트 코드로부터 객체 생성 로직을 분리하는데 사용
객체 생성을 추상화하며, 클라이언트는 어떤 구체적인 클래스의 인스턴스를 생성하는지에 대한 세부 정보를 알 필요가 없음

 

• Factory (공장) 인터페이스 또는 추상 클래스: 객체를 생성하기 위한 메서드를 정의
• Concrete Factories (구체적인 공장 클래스): Factory 인터페이스를 구현하여 객체를 실제로 생성하는 클래스
• Product (제품) 인터페이스 또는 추상 클래스: 공장이 생성할 객체의 유형을 정의
• Concrete Products (구체적인 제품 클래스): Product 인터페이스를 구현하여 실제 객체를 나타냄

 

// 1. Product 인터페이스
interface Product {
    void create();
}

// 2. Concrete Products
class ConcreteProductA implements Product {
    @Override
    public void create() {
        System.out.println("Product A created.");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void create() {
        System.out.println("Product B created.");
    }
}

// 3. Factory 인터페이스
interface Factory {
    Product createProduct();
}

// 4. Concrete Factories
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Main {
    public static void main(String[] args) {
        // Factory A로부터 Product A 생성
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.create();

        // Factory B로부터 Product B 생성
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.create();
    }
}

 

팩토리 메서드 패턴 (Factory Method Pattern)과 추상 팩토리 패턴 (Abstract Factory Pattern)

팩토리 메서드 패턴은 단일 클래스 내에서 객체 생성 메서드를 가지고 있고, 하위 클래스에서 이 메서드를 구현하여 객체를 생성하고 추상 팩토리 패턴은 여러 종류의 팩토리 클래스가 있고, 각각의 팩토리 클래스는 관련된 객체 집합을 생성. 인터페이스를 통해 관련된 객체 집합을 생성하는 팩토리를 선택

// Factory Method Pattern
// Creator 클래스 (추상 클래스)
public abstract class Creator {
    public abstract Product factoryMethod();
}

// ConcreteCreator 클래스 (하위 클래스)
public class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// Product 인터페이스
public interface Product {
    void operation();
}

// ConcreteProductA 클래스
public class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}

//Abstract Factory Pattern
// AbstractFactory 인터페이스
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// ConcreteFactory1 클래스
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// ConcreteFactory2 클래스
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// ProductA 인터페이스
public interface ProductA {
    void operationA();
}

// ConcreteProductA1, ConcreteProductA2 클래스 (구체적인 제품 A)
// ProductB 인터페이스와 ConcreteProductB1, ConcreteProductB2 클래스도 동일하게 정의됨