📗 Factory Method Pattern

객체의 생성 책임을 추상 클래스(or 인터페이스)의 메서드에 맡기는 패턴이다.

예를 들어 차를 만드는 공장이 있다. 최초에는 아반떼만 찍어냈었는데. 공장이 너무 잘돼서 G70, GV80 등 새로운 차 라인이 필요하다. 하지만 차는 기본적인 부품을 설정하는 것은 동일하다. 하지만 차량의 마크라던지 바퀴라던지 다르게 적용이 필요한 부분이 있다.

이를 코드로써 무식하게 해결하면

if(car.name.equals("아반떼")){
	...
}else if(car.name.equals("GV80")){
	...
}else if(car.name.equals("G70")){
	...
}

과 같거나 더 심각하게 분기처리되는 코드를 작성할지도 모른다.

하지만 이런 코드를 짜면 시대에 흐름에 맞게 네비게이션을 일괄적으로 적용한다던지 차의 로고를 변경한다던지 등의 작업이 생기면 코드가 모두 수정이 일어난다.

그래서 우리는 Factory Method Pattern을 이용하여 좀 더 OPC를 지키는 코드로 탄생시켜보자.

⌨️ 패턴이 적용되지 않은 코드

📄 코드 작성

public class Car {
    private String name;
    private String color;
    private String logo;
    private String engine;

    ... getter, setter, toString
}

Car라는 class를 만드려면 자동차 이름과 엔진을 정의해야한다고 하자.

public class AvanteFactory {

    public static Car createCar(String owner, String color){
        // validate
        if(owner.isEmpty()) throw new IllegalArgumentException("소유자를 입력해주세요.");
        if(color.isEmpty()) throw new IllegalArgumentException("색상을 입력해주세요.");

        System.out.println("Avante 생산을 시작합니다.");
        Car car = new Car();
        car.setOwner(owner);

        System.out.println("Avante 생산중...");
        car.setEngine("v1");
        car.setColor(color);
        car.setLogo("현대");
        car.setName("Avante");

        System.out.println("Avante를 만드는데 성공했습니다.");

        return car;
    }
}

public class GV80Factory {

    public static Car createCar(String owner, String color){
        // validate
        if(owner.isEmpty()) throw new IllegalArgumentException("소유자를 입력해주세요.");
        if(color.isEmpty()) throw new IllegalArgumentException("생삭을 입력해주세요.");

        System.out.println("GV80 생산을 시작합니다.");
        Car car = new Car();
        car.setOwner(owner);

        System.out.println("GV80 생산중...");
        car.setEngine("v1+");
        car.setColor(color);
        car.setLogo("제네시스");
        car.setName("GV80");

        System.out.println("GV80을 만드는데 성공했습니다.");

        return car;
    }
}

그리고 Car를 만들어서 반환시켜주는 factory class들을 정의했다.

public class Client {
    public static void main(String[] args) {
        Car car1 = AvanteFactory.createCar("최준호", "white");
        Car car2 = GV80Factory.createCar("최준호", "black");
        System.out.println(car1.toString());
        System.out.println(car2.toString());
    }
}

그리고 차를 만들면

다음과 같이 차량을 정상적으로 생산해낼 수 있다. 하지만 여기에는 문제가 있는데. 만약 네비게이션을 추가로 달아야할 경우 factory class마다 찾아가서 코드를 변경해야하며, 차량 생산을 위해 진행되는 과정이 중복되어 유지보수가 발생할 경우에도 모든 factory class에 코드에 수정이 발생한다는 점이다.

⌨️ 패턴을 적용시키는 코드

📄 공통 부분 interface로 빼기

public interface CarFactory {
    default Car orderCar(String owner, String color){
        validate(owner, color);
        Car car = createCar();
        prepare(car);
        settingCar(car, owner, color);
        complete(car);
        return car;
    }

    private void validate(String owner, String color){
        if(owner.isEmpty()) throw new IllegalArgumentException("소유자를 입력해주세요.");
        if(color.isEmpty()) throw new IllegalArgumentException("색상을 입력해주세요.");
    }

    private void prepare(Car car){
        System.out.println(car.getName()+" 생산을 시작합니다.");
        System.out.println(car.getName()+" 생산중...");
    }

    private void settingCar(Car car, String owner, String color){
        car.setOwner(owner);
        car.setColor(color);
    }

    private void complete(Car car){
        System.out.println(car.getName()+"을 만드는데 성공했습니다.");
    }

    // 구현해야하는 부분
    Car createCar();
}

다음과 같이 interface를 작성하며 코드 리팩토링을 진행해보았다. 중복처리 되는 부분은 모두 interface 내 method로 빼고 실제로 구현해야할 부분인 createCar() method만 구현 class에서 정의하면 된다.

interface에서 private method는 java9 이상에서 사용이 가능하므로 java 8을 사용한다면 중간에 interface를 구현하는 추상 클래스를 생성하여 넣어주어야한다. 그리고 그 추상 클래스를 다른 구현 클래스들이 다시 구현해주어야한다.

📄 AvanteV2 정의

public class AvanteV2 extends Car {
    public AvanteV2() {
        setName("Avante");
        setEngine("v2");
        setLogo("현대");
    }
}

public class AvanteFactoryV2 implements CarFactory{
    @Override
    public AvanteV2 createCar() {
        return new AvanteV2();
    }
}

그리고 AvanteFactoryV2는 CarFactory를 구현하는데 createCar만 구현해주면 된다. 물론 여기서는 AvanteV2를 반환시키면 되기 때문에 코드를 크게 작성할 필요는 없다.

public class Client {
    public static void main(String[] args) {
        Car car1 = new AvanteFactoryV2().orderCar("최준호", "white");
        System.out.println(car1.toString());
    }
}

그럼 실제로 orderCar() mehtod를 통해 실행을 해보면

이전과 동일하게 생산을 해낼 수 있다는 것을 확인할 수 있다.

그럼 이제 이 코드가 진짜로 OCP를 지킬 수 있을것인가? GV80을 생산해내며 확인해보자!

📄 GV80V2 정의

public class GV80V2 extends Car {
    public GV80V2() {
        setName("GV80");
        setEngine("v2+");
        setLogo("제네시스");
    }
}

public class GV80FactoryV2 implements CarFactory{
    @Override
    public Car createCar() {
        return new GV80V2();
    }
}

여기서 패턴의 힘을 느낄 수 있었는데. 그 어떤 코드의 수정도 없이 GV80V2 GV80FactoryV2 두개의 class만 추가하는 것으로 차량 생산 코드가 끝났다.

이를 통해 우리는 OCP를 잘 지킨 코드를 생산해냈다고 생각할 수 있다.

public class Client {
    public static void main(String[] args) {
        Car car1 = new AvanteFactoryV2().orderCar("최준호", "white");
        Car car2 = new GV80FactoryV2().orderCar("최준호", "white");
        System.out.println(car1.toString());
        System.out.println(car2.toString());
    }
}

이번엔 두 차량을 동시에 생산해보면

가장 처음에 무식하게 작성한 코드와 동일한 기능을 잘 실행해주는 것을 확인할 수 있다.

하지만 이 코드에서도 문제점이 있는데 차량 생산을 요청하는 Client 코드에서 각각의 Factory를 직접 지정해주어야 한다는 점이다.

📄 Client 코드 수정

public class Client {
    public static void main(String[] args) {
        order(new AvanteFactoryV2(), "최준호", "white");
        order(new GV80FactoryV2(), "최준호", "black");
    }
    private static void order(CarFactory carFactory, String owner, String color){
        Car car = carFactory.orderCar(owner, color);
        System.out.println(car.toString());
    }
}

Client의 코드까지 다음과 같이 수정하게 되면 중복되는 코드를 없앰과 동시에 main에서는 order에 맞는 factory와 구매자 정보만 넘겨주면 되는 코드로 리팩토링 된다.

📄 네비게이션 추가해보기

public class Car {
    private String owner;
    private String name;
    private String color;
    private String logo;
    private String engine;
    private String navi;

    ...
}

기본 구조가 되는 Car class에 navi를 추가해준다.

public interface CarFactory {
    
    ...
    
    private void settingCar(Car car, String owner, String color){
        car.setOwner(owner);
        car.setColor(color);
        car.setNavi("Kakao Navi");
    }
}

그 후에 나는 settingCar() method에 navi를 세팅할 수 있도록 수정했다.

그럼 결과로 모든 차량에 navigation이 추가된것을 확인해볼 수 있다!

이렇게 추가적인 사항이 생겨도 디자인 패턴을 적용해두니 코드의 수정이 너무 편해진것이다.

📗 정리

📄 Factory Method Pattern의 장점과 단점

장점 OCP를 지키는 코드를 생산해낼 수 있다. 또한 factory와 product간에 느슨한 결합을 유지할 수 있다.

단점 필요 class들의 수가 많아져 구조가 복잡해진다.

📄 OCP란?

Open Closed Principle의 줄임말로 변경에 닫혀있고 확장에 열려있다. 라는 의미이다. 우리가 적용한 디자인 패턴에서 보면 GV80이라는 확장에는 열려 있어 쉽게 추가가 가능했다. 하지만 기존의 Avante라는 기능에서는 전혀 코드가 수정되는 부분이 없이 기능을 추가했으므로 변경에는 닫혀있다고 볼 수 있다.

📄 interface의 default와 private method

기존의 interface에서는 추상 메서드만 정의가 가능했었지만, java8에서 Default method가 추가되었고 java9에서는 private method가 추가되었다.

default method는 interface에서 미리 method의 기능을 정의해두고 상속받은 class에서도 기능을 동일하게 사용할 수 있게끔 마치 extend한것과 동일하게 작동한다고 생각하면 쉬울것 같다.

private mehtod는 기존 interface는 내부 메서드를 정의할 수 없었지만 java9부터는 내부 메서드를 정의하여 default method와 함께 사용할 수 있게 된 method이다.