初探设计模式：抽象工厂模式

抽象工厂模式

在简单工厂模式的基础上，做深层思考：

一个接口，根据不同业务编码，我们建了一个工厂类来处理
如果有多个接口都是类似情况呢？有没有办法合并一下？
这个时候就要用到抽象工厂模式了

一、创建另一个业务接口，并定义一个业务实现方法

public interface OtherService {

    /**
     * 接口应用
     */
    void use();
}

二、创建实现该接口的各个实现类

public class OtherServiceOneImpl implements OtherService {

    /**
     * 接口应用一
     */
    @Override
    public void use() {
        System.out.println("接口应用一");
    }
}

三、为两种接口创建抽象工厂

public abstract class AbstractFactory {

    /**
     * 获取工厂
     * @param businessCode
     * @return
     * @throws Exception
     */
    public abstract BusinessService getBusinessService(String businessCode) throws Exception;

    /**
     * 获取工厂
     * @param businessCode
     * @return
     * @throws Exception
     */
    public abstract OtherService getOtherService(String businessCode) throws Exception;
}

四、创建扩展了抽象工厂的工厂类

public class BusinessServiceFactory extends AbstractFactory {

    /**
     * 获取工厂
     * @param businessCode
     * @return
     */
    @Override
    public BusinessService getBusinessService(String businessCode) throws Exception {
        if (businessCode == null) {
            return null;
        }

        switch (businessCode) {
            case "000001":
                return new BusinessServiceOneImpl();
            case "000002":
                return new BusinessServiceTwoImpl();
            case "000003":
                return new BusinessServiceThreeImpl();
            default:
                throw new Exception("暂不支持此业务编码【"+businessCode+"】");
        }
    }

    /**
     * 获取工厂
     *
     * @param businessCode
     * @return
     * @throws Exception
     */
    @Override
    public OtherService getOtherService(String businessCode) throws Exception {
        return null;
    }
}

public class OtherServiceFactory extends AbstractFactory {

    /**
     * 获取工厂
     * @param businessCode
     * @return
     */
    @Override
    public BusinessService getBusinessService(String businessCode) throws Exception {
        return null;
    }

    /**
     * 获取工厂
     * @param businessCode
     * @return
     * @throws Exception
     */
    @Override
    public OtherService getOtherService(String businessCode) throws Exception {

        if (businessCode == null) {
            return null;
        }

        switch (businessCode) {
            case "000001":
                return new OtherServiceOneImpl();
            default:
                throw new Exception("暂不支持此业务编码【"+businessCode+"】");
        }
    }
}

五、创建一个工厂创造器，通过接口类型获取工厂

public class FactoryProducer {

    /**
     * 根据接口编码获取接口对应工厂
     * @param choice
     * @return
     */
    public static AbstractFactory getFactory(String choice) throws Exception {

        if (choice == null) {
            return null;
        }

        switch (choice) {
            case "choice01":
                return new BusinessServiceFactory();
            case "choice02":
                return new OtherServiceFactory();
            default:
                throw new Exception("暂不支持此接口编码【"+choice+"】");
        }
    }
}

六、创建客户端，模拟业务请求

public class AbstractFactoryClient {

    /**
     * 服务消费者
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        use("choice01", "000001");
        use("choice01", "000002");

        use("choice02", "000001");

        use("choice03", "000001");
    }

    /**
     * 服务提供者
     * @param choice 接口类型
     * @param businessCode 业务编码
     * @throws Exception
     */
    public static void use(String choice, String businessCode) throws Exception {

        String choice01 = "choice01";
        String choice02 = "choice02";

        AbstractFactory factory = FactoryProducer.getFactory(choice);

        if (choice01.equals(choice)) {
            BusinessService service = factory.getBusinessService(businessCode);
            service.use();
        } else if (choice02.equals(choice)) {
            OtherService service = factory.getOtherService(businessCode);
            service.use();
        }
    }
}