设计模式：工厂设计模式介绍及3种写法（简单工厂、工厂方法、抽象工厂）

Dear 丶 2022-11-26 07:51 140阅读 0赞

### 0、介绍 ###

**给一个背景：一个pizza订购项目，pizza本身的种类要便于扩展和维护，那么种类很多、制作过程也不少、还要完成订购的功能**。

按照一般的思路，类图设计如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70]  
其中：

1.  Pizza类按照面向对象的设计思路，制作过程对应的方法在其中实现；
2.  由于需要不同的类型 Pizza，而在 prepare 步骤不同，所以 Pizza 做成抽象类，而两个不同类型的 Pizza 去继承 Pizza 类；
3.  还需要一个的 OrderPizza 类，接受预定类型，完成对应的pizza类订购操作；
4.  然后提供一个入口 PizzaStore 去调用 OrderPizza 类，相当于客户端。

代码如下：

/*
    *  Pizza抽象类，让其他的继承
    */
    public abstract class Pizza {
        
        protected String name;//pizza名
        //不同pizza准备不同，所以留给实现类去实现
        public abstract void prepare();
        public void bake(){
        
            System.out.println(name + " baking");
        }
        public void cut(){
        
            System.out.println(name + " cutting");
        }
        public void box(){
        
            System.out.println(name + " boxing");
        }
        public void setName(String name){
        
            this.name = name;
        }
    }

/*
    *  奶酪pizza
    */
    public class CheesePizza extends Pizza {
        
        @Override
        public void prepare() {
        
            System.out.println("制作奶酪pizza准备材料ing");
        }
    }

/*
    *   希腊pizza
    */
    public class GreekPizza extends Pizza {
        
        @Override
        public void prepare() {
        
            System.out.println("给希腊pizza准备原材料ing");
        }
    }

/*
    *  pizza订购类
    */
    public class OrderPizza {
        
        //获取pizza订单
        private String getType(){
        
            try {
        
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("input pizza type");
                String type = br.readLine();
                return type;
            }catch (IOException e){
        
                e.printStackTrace();
                return "";
            }
        }
        //构造器
        public OrderPizza() {
        
            Pizza pizza = null;
            String orderType;//订购类型
            do {
        
                orderType = getType();
                if (orderType.equals("greek")){
        
                    pizza = new GreekPizza();
                    pizza.setName("希腊pizza");
                }else if (orderType.equals("cheese")){
        
                    pizza = new CheesePizza();
                    pizza.setName("奶酪pizza");
                }else{
        
                    break;
                }
                //方便调试，把制作过程打印
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }while (true);
        }
    }

/*
    *  客户端
    */
    public class PizzaStore {
        
        public static void main(String[] args) {
        
            new OrderPizza();
        }
    }

这样我们的一个 pizza 线上商店就全部完成了，似乎是一个很完美的过程呢。

**优点**：  
**传统思路，便于理解**  
**缺点**：  
**违反了在设计模式七大原则里面说过的 ocp 原则，即对扩展开放，对修改关闭**。

具体一些：Pizza 作为提供方，如果商店要增加一个种类，那么除了要**增加一个 Pizza 类**【提供方】之外，依赖的 Order 类也要**增加对于新 Pizza 的处理**【使用方】（甚至扩展起来，还有别的依赖于 Pizza 的使用方操作类，全部都要修改），而按照 Ocp 原则，使用方不应该修改，所以我们要避免这种情况。

### 一、简单工厂模式 ###

对于上面的缺点，我们把创建 Pizza 的过程封装到一个类里，然后以这个类为中介进行创建，而不是再在Order里面直接创建。这样增加【提供方】 Pizza 的时候，修改这个类就可以了。

**简单工厂模式（静态工厂模式）**：

1.  属于创建型模式，是工厂模式的一种，由一个工厂对象来决定创造出哪一种产品类的实例。他是工厂模式家族里最简单实用的模式；
2.  简单工厂模式定义了一个创建对象的类，由这个类来封装实例化对象的行为；
3.  在实际开发中，如果会用到大量创建某种对象时，就会用到工厂模式。

/*
        简单工厂类，根据类型创建pizza对象并返回
    */
    public class SimpleFactory {
        
        public Pizza createPizza(String orderType){
        
            System.out.println("使用简单工厂模式");
            Pizza pizza = null;
            if (orderType.equals("greek")){
        
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }else if (orderType.equals("cheese")){
        
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            }else if (orderType.equals("pepper")){
        
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
            }
            return pizza;
        }
    }

/*
    *  pizza订购类
    */
    public class OrderPizza {
        
        SimpleFactory factory;
        Pizza pizza = null;
        //构造器
        public OrderPizza(SimpleFactory factory) {
        
            setFactory(factory);
        }
        //创建过程改为调用工厂类
        public void setFactory(SimpleFactory factory){
        
            String orderType = "";
            this.factory = factory;
            do {
        
                orderType = getType();
                pizza = this.factory.createPizza(orderType);
                //打印制作过程
                if (pizza != null){
        
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                }else{
        
                    System.out.println("订购失败");
                    break;
                }
            }while (true);
        }
        //获取pizza种类
        private String getType() {
        
                //和前面一样
        }
    }

/*
    *  客户端
    */
    public class PizzaStore {
        
        public static void main(String[] args) {
        
    //        new OrderPizza();
            //使用简单那工厂模式
            new OrderPizza(new SimpleFactory());
            System.out.println("结束");
        }
    }

类图变成了这样：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 1]  
可以看到，复杂的依赖关系基本消失，**工厂类** 负责了所有对象的产生，因此他和使用方OrderPizza 的关系是聚合关系。

这样一来，如果有新增的 Pizza 类，除了类的创建之外，就**只用修改工厂类里面的新建方法**，而对于使用方，OrderPizza、或者即将使用 Pizza 类的其他增加进来的使用方，代码都不用修改，因为他们都是调用工厂类进行对象的创建。

（其实就是为了方便扩展，多抽象出来一层的思想）

**补充：**

**简单工厂模式之所以又叫静态工厂模式，就是因为可以直接把工厂类的 create 方法写成静态，这样的话，就不用 new 出工厂对象，而是只需要调用它的静态方法就可以。**

public OrderPizzaviaStatic() {
        
        String orderType = "";
        do {
        
            orderType = getType();
            pizza = SimpleFactory.createPizza(orderType);//静态方法
            if (pizza != null){
        
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
        
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

**使用静态与否，根据具体情况来修改**。

### 二、工厂方法模式 ###

工厂方法模式：**定义了一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类**。

思考这个**问题**：

如果新增了一个需求，对于pizza，每次要新加地域属性，比如现在还是3种pizza，但是有3个地方，各有这三种pizza。客户点单的时候也会输入地域属性。

*  **解决方法**：创建的时候利用简单工厂模式，新建不同地域的工厂，并且每个工厂里带上地域属性，其他不变，就可以实现扩展。
 *  但是这种方法不是最优，如果不同工厂很多的话，会需要多个工厂类。

其实把工厂类单独作为普通类来考虑，我们能想到的改进思路就是，在他们基础上，再提取公共接口或者抽象类。事实上，工厂方法模式的确是基于这种思路的。

**使用工厂方法模式，将实例化功能抽象成抽象方法（而不是像简单工厂模式那样直接实现），在不同地域点餐子类中实现抽象方法**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 2]  
根据这个类图很容易看得出来，其实只是对于Order部分做了一个抽象，其他的和之前的一般写法没有区别。

虽然没有出现factory字样，但是其实**两个Order子类充当了Factory的作用**：

*  Order 根据不同的 type 去调用不同的子 Order，做 create 的工作；
 *  每个 Pizza 类里什么也不做。

所以和上面简单工厂的区别就是，这个根据地域分别写了 Order 类，将 OrderPizza 作为抽象类去组织这几个。

因此这一版代码，一个抽象 Pizza 类和4个子 Pizza 类完全没有变化，剩下三个类的写法如下：

/*
        orderPizza类，根据type调用不同的工厂
    */
    public abstract class OrderPizza {
        
        //抽象方法，具体根据地域不同，让工厂子类去实现
        abstract Pizza createPizza(String orderType);
        //构造器
        public OrderPizza(){
        
            Pizza pizza = null;
            String orderType;
            do {
        
                orderType = getType();
                pizza = createPizza(orderType);//调用的是抽象方法
                if (pizza != null){
        
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                }else {
        
                    System.out.println("订购失败");
                    break;
                }
            }while (true);
        }
    
        private String getType() {
        
                //和之前一样
        }
    }

/*
        北京pizza工厂类
    */
    public class BJOrderPizza extends OrderPizza{
        
        @Override
        Pizza createPizza(String orderType) {
        
            Pizza pizza = null;
            if (orderType.equals("cheese")){
        
                pizza = new BJCheesePizza();
                pizza.setName("北京奶酪pizza");
            }else if (orderType.equals("pepper")){
        
                pizza = new BJPepperPizza();
                pizza.setName("北京胡椒pizza");
            }
            return pizza;
        }
    }

/*
        上海pizza工厂类
    */
    public class SHOrderPizza extends OrderPizza {
        
        @Override
        Pizza createPizza(String orderType) {
        
            Pizza pizza = null;
            if (orderType.equals("cheese")){
        
                pizza = new SHCheesePizza();
                pizza.setName("上海奶酪pizza");
            }else if (orderType.equals("pepper")){
        
                pizza = new SHPepperPizza();
                pizza.setName("上海胡椒pizza");
            }
            return pizza;
        }
    }

最后，我们还是用一个 PizzaStore 类模拟一下客户端，接受不同的输入，来调用不同的 Order 类就可以。

### 三、抽象工厂模式 ###

抽象工厂模式：

1.  **定义一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类**；
2.  **将简单工厂模式和工厂方法模式进行整合，其实相当于将简单工厂模式再网上抽象一层**；
3.  **包含AbstractFactory（抽象工厂）和具体实现工厂子类，根据需要的类型使用对应的子类，这样简单工厂类变成了工厂簇，更有助于代码维护**。

这种实现方式的类图是这样的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 3]

相比上面的工厂方法模式，**抽象模式抽象出来一个Factory接口，两个实现类分别作为具体的工厂去实现接口的方法，然后聚合到Order类上**，整体思路和上一种是一样的。

代码层面：

所有Pizza的内容都一样，BJFactory 和 SHFactory 和上面所说的，用工厂方法模式写的代码也一样，不过改成实现接口 AbstractFactory，而不是实现order抽象类。

AbstractFactory：

/*
        抽象工厂模式的抽象层：接口
    */
    public interface AbstractFactory {
        
        //让下面子类实现具体
        public Pizza createPizza(String orderType);
    }

OrderPizza 类和第二种模式的 OrderPizza 类基本是一样的；  
区别就在于，不是根据传入的 Pizza 的 type 直接 create，而是去调用 Factory 实现类，所以是和第一种模式代码一样。

/*
        聚合的order类，和工厂接口交互
    */
    public class OrderPizza {
        
        AbstractFactory factory;
        //构造器
        public OrderPizza(AbstractFactory factory){
        
            setFactory(factory);
        }
        //根据不同实现类进行构造
        private void setFactory(AbstractFactory factory){
        
            Pizza pizza = null;
            String orderType = "";
            this.factory = factory;
            do {
        
                orderType = getType();
                //factory是接受的不同factory，取决于不同实现类
                pizza = factory.createPizza(orderType);
                if (pizza != null){
        
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                }else{
        
                    System.out.println("订购失败");
                    break;
                }
            }while (true);
        }
    
        private String getType() {
        
        }
    }

最后，我们写上 Store类就可以，根据输入的不同，new出 Order 类，并且传入不同地域的工厂参数。

总结一下可以发现，这三种工厂模式，大同小异，就是对于简单工厂模式的不同程度的抽象。

### 四、工厂模式在JDK的应用 ###

jdk 的 Canlendar类中，使用的就是 简单工厂模式

当我们写下这行代码：

Calendar calendar = Calendar.getInstance();//静态方法

的时候，getInstance 方法去调用了

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 4]  
createCalendar 方法，返回一个 Canlendar 实例。

而在创建的方法里面如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 5]

做一系列判断，看里面获取的各种参数，相当于这个工厂根据不同的情况去决定选择哪一种（具体在这个类里是时区、地理位置之类的），最后将创建好的 calendar 返回。

也就是对应我们说的工厂模式第一种，简单工厂模式。

### 五、总结 ###

**工厂模式的意义**：

将实例化对象的代码提取出来，放到一个类里面统一管理和维护，达到各种依赖关系的解耦，从而提高项目的可扩展性和可维护性。（最后是达到设计模式的 ocp 原则）

工厂模式分为三种：

1.  **简单工厂模式**：如果要创建一种对象的行为比较多，将所有的工作放到一个工厂类里，每次调用这个类的方法就可以。
2.  **工厂方法模式**：如果创建的对象种类要增加，那就分类多写几个工厂类，让他们实现一个抽象方法，这样能够做了区分后调用不同的工厂类。
3.  **抽象工厂模式**：再加一层抽象工厂层，那么操作层面就只和固定的抽象工厂类交互，不用管有几种工厂实现类。

工厂模式体现的编码技巧：

*  创建对象实例的时候不要直接 new 类，而是要把这个动作交给一个工厂的方法里，并且返回。
 *  不要让类直接继承具体的类，而是继承抽象类或者实现接口。
 *  不要覆盖基类中已经实现的方法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70]: /images/20221124/d5897b3a3b7d437ab745769b45099f19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 1]: /images/20221124/cdab164990884f689ef1a9f06209dfd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 2]: /images/20221124/9ea7717433af4d9482ac76fb8443e7e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 3]: /images/20221124/990f212865794a96ab6baea2eba4e04d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 4]: /images/20221124/4632f9829f584b0c8bef1795ffca6aa4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70 5]: /images/20221124/35d957e9741249dbab80df8bf412b27f.png