[디자인 패턴] 생성 패턴 - 팩토리 메소드 패턴

팩토리 메소드 패턴이란?

• "객체 생성"을 별도의 클래스로 분리하여 생성하게 하는 디자인 패턴을 팩토리 메소드 패턴 이라고 합니다.
• 클라이언트에서 직접 new 키워드로 객체를 생성하는 것이 아닌 객체들을 도맡아 생성하는 클래스를 만들고, 이 클래스를 통해 객체를 생성하는 패턴으로, 해당 클래스는 "객체 생성"이라는 단 하나의 책임만 지는 것.

팩토리 메소드 패턴의 장점

1. 객체 생성을 별도의 클래스로 분리하였으니, 책임이 분리되고 객체지향적이라고 볼 수 있습니다. (단일 책임 원칙 , SRP 준수)
2. 객체 생성에 필요한 과정을 템플릿처럼 미리 구성해놓고, 객체 생성 과정을 다양하게 처리하여 객체를 유연하게 정할 수 있습니다.
3. 수정에 닫혀있고 확장에는 열려있는 OCP 원칙을 지킬 수 있다.
4. 캡슐화, 추상화를 통해 객체의 구체적인 타입을 감출 수 있음.
5. 추가적으로 팩토리 메소드를 통해 객체의 생성 후 객체들이 공통으로 할 일을 수행하도록 지정할 수 있음.

팩토리 메소드 패턴의 단점

1. 간단한 기능을 사용할 때보다 많은 클래스를 정의해야 하기 때문에 코드량이 증가합니다.

팩토리 메소드 패턴 예시 1

• Coffee : 팩토리 메소드가 생성할 객체의 공통 부모 클래스 또는 인터페이스.
• CoffeeFactory : 팩토리 메소드를 구현하는 클래스로 객체 생성에 집중하는 클래스.
• Latte, Espresso : 팩토리 메소드를 통해 생성할 클래스. 어떻게 생성하는지에 관한 방법은 CoffeeFactory 클래스의 팩토리 메소드인 createCoffee(String name) 에 정의됨.

public class Coffee {  
 
    protected String name;  
 
    public String getName() {  
        return name;  
    }  
}

public class Latte extends Coffee {  
 
    public Latte() {  
        name = "latte";  
    }  
}

public class Espresso extends Coffee {  
 
    public Espresso() {  
        name = "Espresso";  
    }  
}

abstract class CoffeeFactory {  
 
    public static Coffee createCoffee(String name) {  
        switch (name) {  
            case "Latte":  
                return new Latte();  
            case "Espresso":  
                return new Espresso();  
            default :  
                throw new IllegalArgumentException("INVALID COFFE NAME EXCEPTION");  
        }  
    }  
}

• CoffeeFactory 클래스에서 Latte 클래스와 Espresso 클래스의 공통 부모 클래스인 Coffee 클래스의 형을 생성하여 리턴하도록 하는 다형성을 이용하는 방식을 통해 String name의 값에 따라 서로 다른 클래스를 생성할 수 있습니다.

public class Main {  
    public static void main(String[] args) {  
        Coffee coffee = CoffeeFactory.createCoffee("Latte");  
        System.out.println(coffee.getName()); // "latte"  
        System.out.println(coffee.getClass()); // Latte  
    }  
}

팩토리 메소드 패턴 예시 2

• 팩토리 메소드 패턴을 사용하면 OCP를 잘 지킬 수 있다고 하는데, 이와 관련한 예시를 하나 들어보겠습니다.

다음과 같은 상황을 가정해봅시다.

예시1과 다른 점

• 객체 생성을 담당하는 AnimalFactory 클래스에서 Dog와 Cat을 생성하는 팩토리 메소드를 구현하지 않고, AnimalFactory 클래스를 추상 클래스로 변경하고, 팩토리 메소드를 추상 메소드로 변경
• AnimalFactory 클래스를 상속받는 DogFactory라는 클래스를 생성하여 Dog 클래스를 생성하는 역할을 별도로 분리.

public interface Animal {  
    void sound();  
}

public class Cat implements Animal {  
 
    @Override  
    public void sound() {  
        System.out.println("Meow!");  
    }  
}

public class Dog implements Animal {  
 
    @Override  
    public void sound() {  
        System.out.println("BOW WOW");  
    }  
}

public abstract class AnimalFactory {  
 
    public Animal newInstance() {  
        Animal animal = createAnimal();  
        animal.sound();  
        return animal;  
    }  
 
    protected abstract Animal createAnimal();  
}

public class DogFactory extends AnimalFactory {  
 
    @Override  
    protected Animal createAnimal() {  
        return new Dog();  
    }  
}

이러한 상황에서 Cat 클래스를 생성하는 팩토리 메소드를 구현하고 싶다면, DogFactory와 마찬가지로 기존 코드의 변경 없이 CatFactory를 추가하고 AnimalFactory 를 상속받아 createAnimal() 메소드를 구현할 수 있습니다. 즉 기존의 코드가 변경되지 않고 확장되어 OCP를 지킬 수 있습니다.

public class CatFactory extends AnimalFactory {  
 
    @Override  
    protected Animal createAnimal() {  
        return new Cat();  
    }  
}

public class Main {  
 
    public static void main(String[] args) {  
        AnimalFactory af = new CatFactory();  
        AnimalFactory af2 = new DogFactory();  
 
        Animal cat = af.newInstance();  
        Animal dog = af2.newInstance();  
 
        cat.sound(); // MEOW !  
        dog.sound(); // BOW WOW  
    }  
}

<참고 자료>