디자인 패턴 / 팩토리 패턴(Factory Pattren)

 

- 팩토리 패턴은 객체 생성을 전담하는 팩토리 클래스를 두고 , 이 팩토리를 통해 객체를 생성하는 방법이다.

  즉, 객체 생성 로직을 클라이언트 코드에서 분리하여 관리하는 기법이다. (new 인스턴스를 바꿔가며 사용한다.)

 

필요한 이유

 

1. 객체 생성 로직의 중복 제거

 

  - 다양한 객체를 생성할 때, new를 직접 쓰면 코드 곳곳에 생성 로직이 퍼진다.

  - 나중에 객체 생성 방법이 바뀌면, 해당 바뀐 객체의 new 부분을 모두 수정해야 한다 (와우....)

 

2. 의존성 감소

 

  - 클라이언트는 어떤 클래스가 생성되는지 몰라도 된다.

  - 팩토리가 대신 결정하니까, 클라이언트는 인터페이스만 알면 된다.

 

3. 확장성

 

  -  새로운 타입의 객체를 추가할 때, 팩토리만 수정하면 된다.

  - 클라이언트 코드는 그대로 둘 수 있다.

 

 팩토리 패턴 장점

 

  - 객체 생성 로직과 사용 로직 분리 , 코드가 깔끔해진다.

  - 의존성이 감소된다, 유지보수가 쉬워진다.

  - 새로운 클래스 추가 시 유연하게 대응 가능하다. (팩토리만 수정하면 됨)

 

 팩토리 패턴 단점 

 

  - 팩토리 클래스가 비대해질 수 있음 (if-else 인스턴스 수만큼 많아짐)

  - 단순한 경우에는 오히려 코드가 복잡해질 수 있다.

 

스프링 에서의 팩토리 패턴

 

  - 스프링은 팩토리 패턴을 한 단계 더 발전시켜서, BeanFactory라는 객체 컨테이너를 제공한다.

  - 스프링의 IoC 컨테이너는 팩토리 패턴을 발전시킨 것이다. (팩토리 패턴  + DI(의존성 주입) + 라이프사이클 관리)

 

1. 개발자가 new 하지 않는다. @Bean을 하면 @Autowired 선언으로 인스턴스를 자동 주입 받을 수 있다.

2. 스프링 컨테이너(BeanFactory)가 대신 객체(Bean)를 만들고 관리한다.

3. 필요한 객체는 스프링에 요청만 한다.

 

팩토리 패턴 예제 코드

// 1. 동물 인터페이스
 
interface Animal(){
    void speak();
}
 
// 멍멍이 클래스
class Dog implements Animal {
    public void speak() {
        System.out.println("멍멍!!!!!!");
    }
}
 
// 야옹이 클래스
class Cat implements Animal {
    public void speak(){
        System.out.println("야옹~~~");
    }
}
 
// Factory 클래스
class AnimalFactory {
    public static Animal createAnimal(String type) {
        if (type.equalsIgnoreCase('dog')){
            return new Dog();
        } else if (type.equalsIgnoreCase('cat')){
            return new Cat();
        } else {
            throw new IllegalArgumentException("Unknown aimal type: " + type);
        }
    }
}
 
// client 코드
public class FactoryPatternExample {
    public static void main(String[] args) {
        Animal dog = AnimalFactory.createAnimal("dog"); // 팩토리에서 static 으로 선언해서 클래스명.메서드명으로 호출가능
        dog.speak(); // 멍멍!!!!!!
 
        Animal cat = AnimalFactory.createAnimal("cat"); // 팩토리에 인스턴스를 클라이언트에서 주문!!! 야옹이를 주세요....
        cat.speack(); // 야옹~~~~~~
    }
}