寂然解读设计模式 - 工厂模式 - 抽象工厂模式

---

I walk very slowly, but I never walk backwards 

---

工厂模式 - 抽象工厂模式

---

​ 寂然

大家好~，我是寂然，本节课呢，我们接着来聊工厂模式的第三种，抽象工厂模式，以及工厂模式在 JDK源码中的应用，最后，我们明确几点工厂模式的注意事项，对工厂模式进行总结，那我们启程吧

基本介绍 - 抽象工厂模式

抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类

对象簇即一系列对象

抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合

案例回顾

怎么理解上面的几句话呢，首先，我们来回顾一下上节课的需求，然后我们通过类图来详细说明

有这样一个披萨店的需求，披萨的种类很多(比如 GreekPizz、CheesePizz 等)

披萨的制作有 prepare，bake，cut，box 等，而且客户在点披萨时，可以在不同城市点披萨， 比如北京点了芝士 pizza、水果 pizza 或者在上海点了芝士 pizza、水果 pizza等

要求：完成披萨店订购功能，便于披萨种类的扩展，便于维护

类图演示

OK，需求明确了，我们根据需求，绘制类图，分析抽象工厂模式的实现思路，类图如下图所示

---

---

为什么说抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合，首先仍然是简单工厂的思想，由工厂类封装实例化对象的行为，其次，createPizza()方法下沉到各个子类，又体现出工厂方法模式的特点

从设计层面看，抽象工厂模式就是对简单工厂模式的改进，或者称为进一步的抽象，将工厂抽象成两层，一个AbsFactory（抽象工厂）和 具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展

解决方案四：抽象工厂模式

根据上面类图的思路，我们对披萨订购项目再次进行重构，使用抽象工厂模式来完成功能，示例代码如下图所示

//披萨抽象类
public abstract class Pizza {

    //定义一个属性，披萨的名称，并给定set方法
    protected String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //认为不同的披萨，准备的原材料不同，所以定义成抽象方法
    public abstract void prepare();

    //烘焙方法
    public void bake() {

        System.out.println(name + "正在烘焙中");
    }

    //切割方法
    public void cut() {

        System.out.println(name + "正准备把披萨大卸八块");
    }

    //打包方法
    public void box() {

        System.out.println(name + "将披萨打包给顾客");
    }
}

//北京的水果披萨
public class BJFruitPizza extends Pizza {

    @Override
    public void prepare() {

        setName("北京的水果披萨");
        System.out.println("北京的水果披萨正在准备原材料");
    }
}

//北京的希腊披萨
public class BJGreekPizza extends Pizza {

    @Override
    public void prepare() {

        setName("北京的希腊披萨");
        System.out.println("北京的希腊披萨正在准备原材料");
    }
}

//上海的水果披萨
public class SHFruitPizza extends Pizza {

    @Override
    public void prepare() {

        setName("上海的水果披萨");
        System.out.println("上海的水果披萨正在准备原材料");
    }
}

//上海的希腊披萨
public class SHGreekPizza extends Pizza {

    @Override
    public void prepare() {

        setName("上海的希腊披萨");
        System.out.println("上海的希腊披萨正在准备原材料");
    }
}

//抽象工厂模式-  抽象接口
public interface AbsFactory {

    //让下面的工厂子类来具体实现
    public Pizza createPizza(String orderType);

}

//北京工厂子类
public class BJFactory implements AbsFactory{

    @Override
    public Pizza createPizza(String orderType) {

        Pizza pizza = null;

        if (orderType.equals("GreekPizza")){

            pizza = new BJGreekPizza();

        }else if (orderType.equals("FruitPizza")){

            pizza = new BJFruitPizza();
        }

        return pizza;
    }
}

//上海工厂子类
public class SHFactory implements AbsFactory{

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;

        if (orderType.equals("GreekPizza")){

            pizza = new SHGreekPizza();

        }else if (orderType.equals("FruitPizza")){

            pizza = new SHFruitPizza();
        }

        return pizza;
    }
}

//订购Pizza类
public class OrderPizza {

    //聚合抽象工厂接口
    AbsFactory absFactory;

    public OrderPizza(AbsFactory absFactory){

        setAbsFactory(absFactory);

    }

    public void setAbsFactory(AbsFactory absFactory) {

        Pizza pizza = null;

        String orderType = ""; //用户输入

        this.absFactory = absFactory;

        while (true){

            orderType = getType();

            pizza = absFactory.createPizza(orderType);

            if (pizza != null){  //订购成功，输出制作过程

                pizza.prepare();

                pizza.bake();

                pizza.cut();

                pizza.box();

            } else{

                System.out.println("订购失败，咱这没有，去别处把");

                break;
            }
        }
    }

    //定义方法获取客户希望订购的披萨种类
    private String getType(){

        System.out.println("你想订购那个种类的Pizza呢？");

        Scanner scanner = new Scanner(System.in);

        String str = scanner.next();

        return str;
    }
}

//客户端演示
public class PizzaStore {

    public static void main(String[] args) {

        System.out.println("请输入要订购披萨的地点");

        String address = new Scanner(System.in).next();

        if (address.equals("北京")){

            new OrderPizza(new BJFactory());

        }else if (address.equals("上海")){

            new OrderPizza(new SHFactory());

        }else{

            System.out.println("该地点暂未开通订购披萨功能");

        }
    }
}

案例解读

上面我们使用抽象工厂模式进行了代码重构，其实抽象工厂模式代码层面并不难，重点在于分析过程和类图的关系要清晰，其实这两种方式差别是有的，但是不大，核心思想大同小异，抽象工厂模式只不过把工厂抽象成了两层，而简单工厂模式就是一个工厂类，但是大多数情况下，一个工厂类很难满足复杂业务逻辑下多种不同类型的实例的创建，这个时候，使用抽象工厂模式搭建，会更显得得心应手，所以，虽然工厂模式有三种，但是大家要根据实际情况灵活运用，切忌不要为了用而用

JDK源码解析

Calendar 日历类中，就使用到了简单工厂模式，下面我们写一段建议代码，进入 getInstance() 进行查看

//JDK源码解析 - 工厂模式
public class Test {

    public static void main(String[] args) {

        Calendar calendar = Calendar.getInstance();

        System.out.println((calendar.get(Calendar.MONTH) + 1) + "月");//月份下标从0开始

        System.out.println(calendar.get(Calendar.DAY_OF_MONTH) + "日");

    }
}

可以看到，源码中首先定义 Calendar cal = null； 然后通过switch case语句，根据不同的种类，来创建不同的实例赋给 cal ，然后返回，和我们简单工厂模式中，根据客户输入类型的不同，订购不同的披萨实例是非常类似的，如图所示，所以JDK中 Calendar 类给我们返回对象实例就是经典的简单工厂模式

private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }

三种工厂模式对比

那到这里，三种工厂模式已经全部结束了，那下面，我把三种模式对比着进行总结与回顾，方便大家融会贯通

简单工厂模式

定义了一个创建对象的类，由这个类来封装实例化对象的行为，可以根据参数的不同返回不同类的实例

简单工厂模式最大的优点在于工厂类中包含了必要的判断逻辑，根据客户端的条件动态的实例化相关的类，对于客户端来说去除了对具体产品的依赖

工厂方法模式

定义一个创建对象的抽象方法，由子类决定要实例化的类，将对象的实例化推迟到子类

工厂方法使一个类的实例化，延迟到子类中去实现，可以在具体工厂产生实例的时候，做各种校验，和产生规则，避免了直接用new带来的不方便控制流程

抽象工厂模式

定义了一个 interface 用于创建相关或有依赖关系的一系列对象，而无需指明具体的类

进一步的抽象，将工厂抽象成两层，一个AbsFactory（抽象工厂）和 具体实现的工厂子类，可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展

工厂模式意义

将实例化对象的代码提取出来，放在一个类中统一维护和管理，达到和主项目的依赖关系的解耦，从而提高项目的扩展和可维护性，还是那句话，虽然工厂模式有三种，但是大家要根据实际情况灵活运用，切忌不要为了用而用

下节预告

OK，工厂模式的内容到了这里就告一段落了，下一节，我们从大家最感兴趣的简历入手，开启原型模式的学习，最后，希望大家在学习的过程中，能够感觉到设计模式的有趣之处，高效而愉快的学习，那我们下期见~

定义了一个 interface 用于创建相关或有依赖关系的一系列对象，而无需指明具体的类

进一步的抽象，将工厂抽象成两层，一个AbsFactory（抽象工厂）和 具体实现的工厂子类，可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展

工厂模式意义

将实例化对象的代码提取出来，放在一个类中统一维护和管理，达到和主项目的依赖关系的解耦，从而提高项目的扩展和可维护性，还是那句话，虽然工厂模式有三种，但是大家要根据实际情况灵活运用，切忌不要为了用而用

下节预告

OK，工厂模式的内容到了这里就告一段落了，下一节，我们从大家最感兴趣的简历入手，开启原型模式的学习，最后，希望大家在学习的过程中，能够感觉到设计模式的有趣之处，高效而愉快的学习，那我们下期见~