Factory Pattern

SimpleFactory 방식

public interface IProuduct {
    void doSomeThing();
}

public class ProductA implements IProuduct {
    @Override
    public void doSomeThing() {
        System.out.println("ProductA 입니다!");
    }
}

public class ProductB implements IProuduct {
    @Override
    public void doSomeThing() {
        System.out.println("ProductB 입니다!");
    }
}

public class SimpleFactory {
    static IProuduct makeProduct(String productName) {
        if ("ProductA".equals(productName)) {
            return new ProductA();
        } else if ("ProductB".equals(productName)) {
            return new ProductB();
        } else {
            return null;
        }
    }
}

public class Client {
    public static void main(String[] args) {
        // ProductB 만든다.
        IProuduct product = SimpleFactory.makeProduct("ProductB");
        product.doSomeThing();
    }
}

장점

SimpleFactory 패턴은 모델은 객체 생성 로직을 캡슐화하고 비즈니스 코드 로직과 객체 생성 로직을 분리 한다. 객체가 생성되는 로직을 변경할 때는 여러 service 파일에서 이 부분의 코드를 찾아서 수정해야 하지만 SimpleFactory패턴을 사용한 하면 SimpleFactory 에서 생성된 객체의 논리만 수정하면 되고, 업무 코드를 수정할 필요가 없음.

단점

특정 제품 카테고리의 추상 제품 카테고리가 증가할 때마다 SimpleFactory 카테고리에 새로운 제품 카테고리 객체 생성 방법을 추가해야 함. 추상 제품 종류가 많을 때, 추상 공장은 매우 비대해진다. 그리고 이 경우 SimpleFactory도 개폐 원칙에 부합하지 않음.

FactoryMethod 방식

public interface IFactory {
    IProduct makeProduct();
}

public interface IProduct {
    void doSomeThing();
}

public class ProductA implements IProduct {
    @Override
    public void doSomeThing() {
        System.out.println("ProductA 입니다!");
    }
}

public class ProductB implements IProduct {
    @Override
    public void doSomeThing() {
        System.out.println("ProductA 입니다!");
    }
}

public class FactoryA implements IFactory {
    @Override
    public IProduct makeProduct() {
        return new ProductA();
    }
}

public class FactoryB implements IFactory {
    @Override
    public IProduct makeProduct() {
        return new ProductB();
    }
}

public class Client {
    public static void main(String[] arges) {
        // ProductA 만듬.
        FactoryA factoryA = new FactoryA();
        factoryA.makeProduct().doSomeThing();
    }
}

장점

ProductC를 추가할 때 특정 제품 클래스 ProductC와 ProductC 생산을 담당하는 특정 공장 FactoryC를 생성하기만 하면 됨.개폐 원칙'에 부합하고 확장이 용이함.

단점

종류의 개수가 너무 많으면 복잡도가 증가한다. 추상적 공장 인터페이스를 실현하는 구체적인 공장은 하나의 제품만 생산할 수 있다(abstractor factory 방식으로 해결할 수 있다)

Abstractor Factory 방식

public interface AbstractFactory {
    Basketball makeBasketball();
    Football makeFootball();
}

public interface Basketball {
    void sayBasketball();
}

public interface Football {
    void sayFootball();
}

public class NikeBasketball implements Basketball {
    @Override
    public void sayBasketball() {
        System.out.println("나이키 농구공!");
    }
}

public class NikeFootball implements Football {
    @Override
    public void sayFootball() {
        System.out.println("나이키 축구공!");
    }
}

public class AdidasBasketball implements Basketball {
    @Override
    public void sayBasketball() {
        System.out.println("adidas 농구공!");
    }
}

public class AdidasFootball implements Football {
    @Override
    public void sayFootball() {
        System.out.println("adidas 농구공!");
    }
}

public class NikeFactoy implements AbstractFactory {
    @Override
    public Basketball makeBasketball() {
        return new NikeBasketball();
    }

    @Override
    public Football makeFootball() {
        return new NikeFootball();
    }
}

public class AdidasFactory implements AbstractFactory {
    @Override
    public Basketball makeBasketball() {
        return new AdidasBasketball();
    }

    @Override
    public Football makeFootball() {
        return new AdidasFootball();
    }
}

public class Client {
    public static void main(String[] args){
        // nike농구공 , adidas축구공 생산!
        NikeFactoy nikeFactoy = new NikeFactoy();
        AdidasFactory adidasFactory = new AdidasFactory();

        nikeFactoy.makeBasketball().sayBasketball();
        adidasFactory.makeFootball().sayFootball();
    }
}

소스코드