팩토리 패턴

팩토리 패턴

팩토리 패턴(factory pattern)은 객체를 사용하는 코드에서 객체 생성 부분을 떼어내 추상화한 패턴이자 상속 관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고, 하위 클래스에서 객체 생성에 관한 구체적인 내용을 결정하는 패턴이다.

상위 클래스와 하위 클래스가 분리되기 때문에 느슨한 결합을 가지며 상위 클래스에서는 인스턴스 생성방식에 대해 전혀 알 필요가 없기 때문에 더 많은 유연성을 갖게 된다. 그리고 객체 생성 로직이 따로 떼어져 있기 때문에 코드를 리팩터링하더라도 한 곳만 고칠 수 있게 되니 유지 보수성이 증가된다.

 

자바스크립트의 팩토리 패턴

자바스크립트에서 팩토리 패턴을 구현한다면 간단하게 enw Object()로 구현할 수 있다.

const num = new Object(42)
const str = new Object('abc')
num.constructor.name; // Number
str.constructor.name; // String

 

숫자를 전달하거나 문자열을 전달함에 따라 다른 타입의 객체를 생성하는 것을 볼 수 있다. 즉, 전달받은 값에 따라 객체를 생성하며 인스턴스의 타입 등을 정한다. 커피 팩토리를 기반으로 라떼 등을 생산하는 코드를 구축해보겠다.

class Latte {
  constructor() {
    this.name = "latte"
  }
}
class Espresso {
  constructor() {
    this.name = "Espresso"
  }
}

class LatteFactory {
  static createCoffee() {
    return new Latte()
  }
}
class EspressoFactory {
  static createCoffee() {
    return new Espresso()
  }
}
const factoryList = { LatteFactory, EspressoFactory }

class CoffeeFactory {
  static createCoffee(type) {
    const factory = factoryList[tyep]
    return factory.createCoffee()
  }
}
const main = () => {
  // 라떼 커피를 주문한다.
  const coffee = CoffeeFactory.createCoffee("LatteFactory")
  // 커피 이름을 부른다.
  console.log(coffee.name) // latte
}
main()

 

CoffeeFactory라는 상위 클래스가 중요한 뼈대를 결정하고 하위 클래스인 LatteFactory가 구체적인 내용을 결정하고 있다.

참고로 이는 의존석 주입이라고도 볼 수 있다. CoffeeFactory에서 LatteFactory의 인스턴스를 생성하는 것이 아닌 LatteFactory에서 생성한 인스턴스를 CoffeeFactory에 주입하고 있기때문이다.

또한, CoffeeFactory를 보면 static으로 createCoffee() 정적 메서드를 정의한 것을 알 수 있는데, 정적 메서드를 쓰면 클래스의 인스턴스 없이 호출이 가능하여 메모리를 절약할 수 있고 개별 인스턴스에 묶이지 않으며 클래스 내의 함수를 정의할 수 있는 장점이 있다.

 

자바의 팩토리 패턴

이를 자바로 구현하면 다음과 같다

abstract class Coffee{
  public abstract int getPrice();
  
  @Override
  public String toSTring() {
    return "Hi this coffee is " + this.getPrice();
  }
}

class CoffeeFactory {
  public static Coffee getCoffee(String type, int price) {
    if ("Latte".equalsIgnoreCase(type)) return new Latte(price);
    else if ("Americano".equalsIgnoreCase(type)) return new
Americano(price);
    else {
      return new DefaultCoffee();
    }
  }
}
class DefaultCoffee extends Coffee {
  private int price;
  
  public DefaultCoffee() {
    this.price = -1;
  }
  
  @Override
  public int getPrice() {
    return this.price;
  }
}
class Latte extends Coffee {
  private int price;
  
  public Latte(int price) {
    this.price = price;
  }
  @Override
  public int getPrice() {
    return this.price;
  }
}
class Americano extends Coffee {
  private int price;
  
  public Americano(int price) {
    this.price = price;
  }
  @Override
  public int getPrice() {
    return this.price;
  }
}
public class HelloWorld {
  public static void main(String[] args) {
    Coffee latte = CoffeeFactory.getCoffee("Latte", 4000);
    Coffee ame = CoffeeFactory.getCoffee("Americano", 3000);
    System.out.println("Factory latte ::" + latte);
    System.out.println("Factory ame ::" + ame);
  }
}
/*
Factory latte ::Hi this coffee is 4000
Factory ame ::Hi this coffee is 3000
*/

 

지금 보면 if ("Latte".equalsIgnoreCase(type))을 통해 문자열 비교 기반으로 로직이 구성됨을 볼 수 있는데, 이는 Enum 또는 Map을 이용하여 if 문을 쓰지 않고 매핑해서 할 수도 있다.

 

Enum이란?

Enum

상수의 집합을 정의할 때 사용되는 타입이다. 상수나 메서드 등을 집어넣어서 관리하며 코드를 리팩터링할 때 해당 집합에 관한 로직 수정 시 이 부분만 수정하면 되므로 코드 리팩터링 시 강점이 생긴다