팩토리(Factory) 패턴

정의

• 인스턴스를 생성하는 인터페이스를 만들고, 그 인터페이스를 구현하는 서브 클래스에서 어떤 인스턴스를 만들지 결정하는 패턴이다. 즉, 클래스의 인스턴스를 만드는 일을 서브클래스에게 맡기는것이다.
• 팩토리 패턴은 '팩토리 메소드 패턴'과 '추상 팩토리 패턴'으로 나뉜다.
• 팩토리 메소드 패턴 : 인스턴스를 생성하기 위한 인터페이스를 정의하고, 어떤 클래스의 인스턴스를 만들지는 서브 클래스에서 결정한다.
• 추상 팩토리 패턴 : 추상 팩토리 패턴은 많은 수의 연관된 서브 클래스를 특정 그룹으로 묶어 한번에 교체할 수 있도록 만든 디자인 패턴이다.

 

장점

• 새로운 구현 클래스가 추가되어도 기존 Factory코드의 수정 없이 새로운 Factory를 추가하면 된다 -> OCP원칙을 지킬 수 있다.
• 구체적인 클래스를 추상화라는 특징을 제공해 사용자로부터 분리할 수 있다. ->사용자가 사용할 때는 인터페이스에 정의된 추상 메소드를 사용하기만 하면 된다.
• 객체간의 결합도를 낮출 수 있다.

 

*OCP(Open-Closed Principle)원칙 :

기존의 코드를 변경하지 않으면서 기능을 추가할 수 있도록 설계가 되어야한다는 원칙.

확장에 대해서는 개방적이고, 수정에 대해서는 폐쇄적이어야 한다. 수정에 대해서 폐쇄적이다는 말은 코드를 수정하지 않아도 모듈의 기능을 확장하거나 변경할 수 있어야한다는 말이다. 개방 폐쇄의 원칙 이라고도 한다.

 

단점

• 패턴을 구현할 많은 서브 클래스를 정의해야 하기 때문에 코드량이 증가할 수 있다.
• 새로운 종류의 객체를 제공하기 어렵다. 만약 Factory코드에 새로운 기능의 메소드가 추가된다면 Factory의 모든 서브구현체를 다시 수정해야한다.

 

팩토리 메소드 패턴 예제

public interface PhoneFactory {
    default Phone orderPhone() {
        Phone phone = createPhone();
        phone.complete();
        return phone;
    }
    Phone createPhone();
}

public class IPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new IPhone();
    }
}

public class AndroidPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new AndroidPhone();
    }
}

public interface Phone {
    void complete();
    void call();
}
public class IPhone implements Phone{
    @Override
    public void complete() { System.out.println("아이폰 완성"); }
    @Override
    public void call() { System.out.println("아이폰으로 전화를 한다"); }
}
public class AndroidPhone implements Phone{
    @Override
    public void complete() {System.out.println("안드로이드폰 완성");}
    @Override
    public void call() {System.out.println("안드로이드폰으로 전화를 한다");}
}

public class Practice {
    public static void main(String[] args){
        IPhoneFactory iPhoneFactory = new IPhoneFactory();
        Phone phone7 = iPhoneFactory.orderPhone();
        phone7.call();

        AndroidPhoneFactory androidPhoneFactory = new AndroidPhoneFactory();
        Phone phone2 = androidPhoneFactory.orderPhone();
        phone2.call();
    }
}

//결과
아이폰 완성
아이폰으로 전화를 한다
안드로이드폰 완성
안드로이드폰으로 전화를 한다

SimplePhoneFactory를 인터페이스화하고 서브클래스는 IPhoneFactory, AndroidPhoneFactory를 만든다. 서브클래스의 createPhone()을 통해 각자의 Factory에서 Phone 객체 생성 구현체를 만든다. 이렇게 Factory를 상속한 서브클래스에서 객체를 만들게끔 할 수 있다.

추후에 폰의 종류가 여러개로 늘어나도 Phone 서브 클래스를 만들고 createPhone()의 처리만 해주면 확장가능한 구조가 된다.(OCP를 따르게 된다)

 

추상 팩토리 패턴 예제

아이폰에 IOS를, 안드로이드폰에는 Google Os를 설치하는 기능을 추가하였다.

public interface PhoneFactoryOfFactory {
    PhoneFactory requestPhone(String company);
}
public class DefaultPhoneFactoryOfFactory implements PhoneFactoryOfFactory{
    @Override
    public PhoneFactory requestPhone(String company) {
        switch (company) {
            case "IPHONE":
                return new IPhoneFactory();
            case "ANDROID":
                return new AndroidPhoneFactory();
        }
        throw new IllegalArgumentException();
    }
}
///

///
public interface PhoneFactory {
    Phone createPhone();
    OS createOS();
}
public class IPhoneFactory implements PhoneFactory{
    @Override
    public Phone createPhone() {
        OS os = createOS();
        os.installOS();
        return new IPhone();
    }
    @Override
    public OS createOS() {
        return new IOS();
    }
}
public class AndroidPhoneFactory implements PhoneFactory{
    @Override
    public Phone createPhone() {
        OS os = createOS();
        os.installOS();
        return new AndroidPhone();
    }
    @Override
    public OS createOS() {
        return new GoogleOS();
    }
}
///

///
public interface OS {
    void installOS();
}
public class IOS implements OS {
    @Override
    public void installOS() {
        System.out.println("IOS 설치");
    }
}
public class GoogleOS implements OS {
    @Override
    public void installOS() {
        System.out.println("구글OS 설치");
    }
}
///

///
public interface Phone {
    public void call();
    public void playGame();
}
public class IPhone implements Phone{
    @Override
    public void call() {
        System.out.println("아이폰으로 전화하다");
    }

    @Override
    public void playGame() {
        System.out.println("아이폰으로 게임하다");
    }
}
public class AndroidPhone implements Phone{
    @Override
    public void call() {
        System.out.println("안드로이드로 전화하다");
    }

    @Override
    public void playGame() {
        System.out.println("안드로이드로 게임하다");
    }
}
///

public class Main {
    public static void main(String[] args) {
        PhoneFactoryOfFactory phoneFactoryOfFactory = new DefaultPhoneFactoryOfFactory();
        PhoneFactory iphoneFactory= phoneFactoryOfFactory.requestPhone("IPHONE");   //아이폰을 산다.
        Phone iphone = iphoneFactory.createPhone();
        iphone.call();
        iphone.playGame();

        PhoneFactory androidPhoneFactory = phoneFactoryOfFactory.requestPhone("ANDROID");   //안드로이드폰을 산다.
        Phone androidPhone = androidPhoneFactory.createPhone();
        androidPhone.call();
        androidPhone.playGame();
    }
}

//결과
IOS 설치
아이폰으로 전화하다
아이폰으로 게임하다
구글OS 설치
안드로이드로 전화하다
안드로이드로 게임하다

팩토리 메소드 패턴 예제 에서는 PhoneFactory의 서브클래스 IPhoneFactory, AndroidPhoneFactory가 각각 IPhone 객체 AndroidPhone 객체 하나씩 생성한다.

추상 팩토리 패턴 예제에선 하나의 PhoneFactory에서 여러개의 제품군(Phone, OS) 조합을 생성할 수 있게 해준다.

 

 

이해하는데 큰 도움을 준 게시글 :

https://cjw-awdsd.tistory.com/54

https://velog.io/@ellyheetov/Factory-Pattern