[Design Pattern] 추상 팩토리 패턴(Abstract Factory Pattern)

 

 

안녕하세요 취업길잡이 Coy입니다

 

오늘은 추상팩토리 패턴에 대해서 알아보도록 하겠습니다

 

추상 팩토리 패턴이란

추상 팩토리 패턴은 객체 생성에 관한 패턴 중 하나로, 관련된 객체들의 집합을 통째로 묶어서 생성하는 방식을 제공합니다. 이는 팩토리 메서드 패턴과 비슷하지만, 한 단계 더 추상화된 형태입니다.

일반적으로 객체 생성을 위한 인터페이스를 제공하고, 구체적인 객체 생성을 담당하는 팩토리 클래스를 만듭니다. 이 때, 여러 종류의 객체들을 묶어서 관리하는 추상 팩토리 클래스를 만들어서 관련 객체 집합을 생성합니다.

예를 들어, 전자제품을 생산하는 공장에서는 모니터, 키보드, 마우스와 같은 여러 부품들을 함께 생산해야 할 수 있습니다. 이런 경우, 추상 팩토리 패턴을 사용하여 각 부품들을 생성하는데 필요한 로직을 담은 클래스를 만들 수 있습니다.

클라이언트는 구체적인 클래스를 직접 생성하는 대신, 추상 팩토리를 통해 필요한 객체 집합을 생성할 수 있습니다. 이렇게 함으로써 클라이언트 코드와 객체 생성 로직이 분리되어 유지보수와 확장이 용이해집니다. 또한, 추상 팩토리 패턴을 사용하면 클라이언트는 구체적인 클래스에 대한 의존성을 줄일 수 있어 코드의 유연성을 높일 수 있습니다.

 

 

사용하는 목적

1. 유연성과 확장성: 추상 팩토리 패턴은 객체 생성과 관련된 코드를 추상화하고, 클라이언트에게는 구체적인 클래스 대신 추상 팩토리 인터페이스를 제공함으로써 유연성을 제공합니다. 새로운 종류의 객체를 추가하거나 기존 객체를 변경할 때, 기존 코드를 수정하지 않고도 새로운 팩토리 구현체를 추가할 수 있습니다.
2. 캡슐화: 클라이언트는 구체적인 클래스의 생성 로직을 알 필요 없이 추상화된 인터페이스를 통해 객체를 생성할 수 있습니다. 이는 객체 생성 로직을 외부에 노출시키지 않고, 객체 생성과 사용을 캡슐화할 수 있도록 합니다.
3. 의존성 관리: 추상 팩토리 패턴은 클라이언트가 객체를 생성할 때 객체의 구체적인 클래스에 대한 의존성을 줄입니다. 이는 객체 간의 의존성을 낮추고, 코드의 유연성과 재사용성을 높입니다.
4. 교체 가능한 구현: 클라이언트는 추상 팩토리 인터페이스를 통해 객체를 생성하므로, 클라이언트 코드는 구체적인 구현체와 직접적으로 결합되지 않습니다. 따라서 추상 팩토리를 통해 다양한 구현체를 전환하거나 교체할 수 있습니다.
5. 유사한 객체 집합 생성: 객체들이 관련성이 있는 집합을 형성할 때 추상 팩토리 패턴은 특히 유용합니다. 이는 예를 들어, 여러 종류의 GUI 요소를 생성할 때나 여러 종류의 DB 연결을 처리할 때 유용합니다. 이런 경우에 추상 팩토리 패턴을 사용하면 일관성 있고 관련된 객체 집합을 생성할 수 있습니다.

이러한 이유로 추상 팩토리 패턴은 객체 생성과 관련된 코드의 유연성과 관리성을 향상시키며, 시스템의 독립성과 확장성을 증진시킵니다.

 

 

 

 

​

구조

 

 

 

 

예제코드

// 부품을 생성하는 인터페이스
interface Engine {
    void createEngine();
}

interface Tire {
    void createTire();
}

interface Headlight {
    void createHeadlight();
}

// BMW 브랜드의 부품 구현체
class BMWEngine implements Engine {
    @Override
    public void createEngine() {
        System.out.println("BMW Engine created");
    }
}

class BMWTire implements Tire {
    @Override
    public void createTire() {
        System.out.println("BMW Tire created");
    }
}

class BMWHeadlight implements Headlight {
    @Override
    public void createHeadlight() {
        System.out.println("BMW Headlight created");
    }
}

// Audi 브랜드의 부품 구현체
class AudiEngine implements Engine {
    @Override
    public void createEngine() {
        System.out.println("Audi Engine created");
    }
}

class AudiTire implements Tire {
    @Override
    public void createTire() {
        System.out.println("Audi Tire created");
    }
}

class AudiHeadlight implements Headlight {
    @Override
    public void createHeadlight() {
        System.out.println("Audi Headlight created");
    }
}

// 추상 팩토리 인터페이스
interface CarFactory {
    Engine createEngine();
    Tire createTire();
    Headlight createHeadlight();
}

// BMW 팩토리 구현체
class BMWFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new BMWEngine();
    }

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

    @Override
    public Headlight createHeadlight() {
        return new BMWHeadlight();
    }
}

// Audi 팩토리 구현체
class AudiFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new AudiEngine();
    }

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

    @Override
    public Headlight createHeadlight() {
        return new AudiHeadlight();
    }
}

// 클라이언트 코드
public class Main {
    public static void main(String[] args) {
        // BMW 차량 부품 생성
        CarFactory bmwFactory = new BMWFactory();
        Engine bmwEngine = bmwFactory.createEngine();
        Tire bmwTire = bmwFactory.createTire();
        Headlight bmwHeadlight = bmwFactory.createHeadlight();

        // Audi 차량 부품 생성
        CarFactory audiFactory = new AudiFactory();
        Engine audiEngine = audiFactory.createEngine();
        Tire audiTire = audiFactory.createTire();
        Headlight audiHeadlight = audiFactory.createHeadlight();
    }
}

 

- CarFactory: 이 클래스는 추상 팩토리의 역할을 합니다. 즉, 자동차 부품을 생성하는 인터페이스를 정의합니다. 이 인터페이스에는 createEngine(), createTire(), createHeadlight() 메서드가 있습니다. 이 클래스는 구체적인 자동차 브랜드에 대한 팩토리 클래스들의 공통적인 인터페이스를 제공합니다.

 

- BMWFactory: BMWFactory 클래스는 CarFactory 인터페이스를 구현하는 클래스입니다. 따라서 BMWFactory 클래스는 Engine, Tire, Headlight 인터페이스를 생성하는 메서드를 구현해야 합니다. 즉, createEngine(), createTire(), createHeadlight() 메서드를 구체화해야 합니다. 이 클래스는 BMW 브랜드에 대한 부품 생성을 담당합니다.

 

- AudiFactory: AudiFactory 클래스도 CarFactory 인터페이스를 구현하는 클래스입니다. BMWFactory와 마찬가지로 Engine, Tire, Headlight 인터페이스를 생성하는 메서드를 구현합니다. 즉, createEngine(), createTire(), createHeadlight() 메서드를 구현해야 합니다. 이 클래스는 Audi 브랜드에 대한 부품 생성을 담당합니다.

 

- Engine, Tire, Headlight: 각각 Engine, Tire, Headlight 클래스는 자동차 부품을 생성하는 인터페이스입니다. 각각의 인터페이스에는 해당 부품을 생성하는 메서드가 정의되어 있습니다.

 

- BMWEngine, BMWTire, BMWHeadlight, AudiEngine, AudiTire, AudiHeadlight: 이 클래스들은 각 부품에 대한 구체적인 구현체입니다. 예를 들어, BMWEngine 클래스는 Engine 인터페이스를 구현하여 BMW 브랜드의 엔진을 생성합니다. AudiEngine 클래스도 마찬가지로 Engine 인터페이스를 구현하여 Audi 브랜드의 엔진을 생성합니다. 이러한 클래스들은 실제 부품을 구현하고, 실제 부품을 생성하는 메서드를 구현합니다.

 

 

 

 

장단점

장점

1. 유연성(Flexibility): 추상 팩토리 패턴은 클라이언트가 구체적인 클래스에 의존하지 않고도 객체 생성을 요청할 수 있도록 합니다. 이는 시스템의 유연성을 높여 새로운 객체를 쉽게 추가하거나 기존 객체를 변경할 수 있게 합니다.
2. 교체 가능성(Replaceability): 추상 팩토리 패턴은 객체 생성 코드를 클라이언트 코드로부터 분리시킴으로써 객체 생성 방식을 변경하거나 다른 구현체로 교체하는 것을 용이하게 합니다. 이는 시스템을 확장하거나 유지보수하는 동안 변경이 발생할 때 유용합니다.
3. 캡슐화(Encapsulation): 추상 팩토리 패턴은 객체 생성 로직을 팩토리 클래스에 캡슐화하여 클라이언트 코드로부터 감춥니다. 이는 객체 생성과 사용을 분리함으로써 코드의 응집도를 높이고 코드의 복잡성을 낮출 수 있습니다.
단점

 

단점

1. 복잡성(Complexity): 추상 팩토리 패턴을 도입하면 객체 생성에 관한 여러 개의 인터페이스와 클래스가 추가될 수 있습니다. 이는 코드의 복잡성을 증가시킬 수 있으며, 작은 규모의 프로젝트에서는 오버엔지니어링으로 이어질 수 있습니다.
2.확장성 한계(Scalability Limitation): 새로운 종류의 객체를 추가할 때마다 팩토리 인터페이스와 구현체를 추가해야 합니다. 이는 시스템이 많은 종류의 객체를 지원해야 할 때 확장성이 제한될 수 있습니다.
3. 의존성 증가(Dependency Increase): 추상 팩토리 패턴을 사용하면 클라이언트 코드가 팩토리 인터페이스에 의존하게 됩니다. 이는 객체 생성 로직에 변경이 발생할 때 클라이언트 코드도 수정해야 한다는 것을 의미합니다. 따라서 의존성이 증가할 수 있습니다.

 

컬럼으로 다루어 주면 좋겠다 싶은 주제가 있으면 댓글로 알려주세요

 

도움이 필요하시면 사연을 메일로 보내주세요

 

jek300300@gmail.com

 

도움이 되셨다면 공감과 구독 부탁드립니다

 

읽어주셔서 감사합니다

 

당신의 취업이 성공할 때까지 같이 하겠습니다! by 취업길잡이 Coy