从零开始学习Java设计模式 | 创建型模式篇：工厂方法模式

比眉伴天荒 2023-01-23 10:48 13阅读 0赞

在本讲，我们来学习一下创建型模式里面的第二个设计模式，即工厂方法模式。

# 引子：咖啡店点餐系统 #

在学习工厂方法模式之前，我们先来看一个需求，设计一个咖啡店点餐系统。下面我们就来分析一下该需求。

咖啡店点餐系统点的肯定是咖啡，所以我们需要设计一个咖啡类（即Coffee），而咖啡它又有不同的品种：美式咖啡、拿铁咖啡等。这样，我们又得设计两个类，即美式咖啡类（即AmericanCoffee）和拿铁咖啡类（即LatteCoffee），很显然，我们得让这俩类去继承咖啡类，因为它俩可以向上抽取出共性的东西，而这些共性的东西可以放在咖啡类里面，用以提高代码的一个复用性。关于咖啡的这三个类设计完了之后，咱们还得设计一个咖啡店类，该类里面就具有点咖啡的功能，客户来了之后可以进行咖啡的一个点餐。

根据以上简单的分析，相信大家能画出下面这样的一个类图来。

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

先看以上类图的右边部分，顶层有一个父类，即咖啡类（Coffee），它里面定义有如下三个方法：

1.  getName方法：获取咖啡的名称。由于不同品种的咖啡返回的名称是不一样的，所以该方法应该是一个抽象的方法，要求子类自己去重写
2.  addMilk方法：加奶。几乎所有的咖啡都需要加奶
3.  addSugar方法：加糖。几乎所有的咖啡都需要加糖

再来看咖啡类下面的两个子类，一个是美式咖啡类（即AmericanCoffee），一个是拿铁咖啡类（即LatteCoffee），它俩都重写了父类中的getName方法。

然后，我们再来看一下以上类图的左边部分，有一个咖啡店类（即CoffeeStore），它里面只有一个orderCoffee方法，它是用来点咖啡的，并且它里面还有一个String类型的参数。该参数表示的是什么含义呢？客户要点什么咖啡，不管是美式咖啡还是拿铁咖啡，他是不是得告诉咖啡店的前台服务员啊，然后咖啡店的前台服务员再根据客户所点咖啡类型去点餐。如果客户点的是美式咖啡，那么他只须给咖啡店的前台服务员传递一个`american`字符串就行；如果客户点的是拿铁咖啡，那么他只须给咖啡店的前台服务员传递一个`latte`字符串就行。

以上就是我们对咖啡店点餐系统的设计类图的一个分析。分析完了之后，接下来，我们就要开始编写代码来实现了。

首先，打开咱们的maven工程，在com.meimeixia.pattern包下新建一个子包，即factory.before，我们是在该包中来编写以上咖啡店点餐系统的代码的。

然后，创建一个咖啡类，即Coffee。

package com.meimeixia.pattern.factory.before;
    
    /** * 咖啡类 * @author liayun * @create 2021-05-31 21:35 */
    public abstract class Coffee { 
        public abstract String getName();
    
        // 加糖
        public void addSugar() { 
            System.out.println("加糖");
        }
    
        // 加奶
        public void addMilk() { 
            System.out.println("加奶");
        }
    }

接着，我们再创建以上咖啡类的两个子类。先创建第一个子类，即美式咖啡类（AmericanCoffee），注意，该美式咖啡类要去继承Coffee类并重写里面的getName方法哟！

package com.meimeixia.pattern.factory.before;
    
    /** * 美式咖啡 * @author liayun * @create 2021-05-31 21:40 */
    public class AmericanCoffee extends Coffee { 
        @Override
        public String getName() { 
            return "美式咖啡";
        }
    }

再创建第二个子类，即拿铁咖啡类（LatteCoffee），同样，该类得去继承Coffee类并重写里面的getName方法。

package com.meimeixia.pattern.factory.before;
    
    /** * 拿铁咖啡 * @author liayun * @create 2021-05-31 21:53 */
    public class LatteCoffee extends Coffee { 
        @Override
        public String getName() { 
            return "拿铁咖啡";
        }
    }

至此，Coffee类以及它的子类就已经全部创建完毕了。

接下来，我们再创建一个咖啡店类，即CoffeeStore。根据以上设计类图，相信你能写出来下面这样一个类。

package com.meimeixia.pattern.factory.before;
    
    /** * 咖啡店 * @author liayun * @create 2021-05-31 21:54 */
    public class CoffeeStore { 
    
        public Coffee orderCoffee(String type) { 
            // 声明Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
            Coffee coffee = null;
            if ("american".equals(type)) { 
                coffee = new AmericanCoffee();
            } else if ("latte".equals(type)) { 
                coffee = new LatteCoffee();
            } else { 
                throw new RuntimeException("对不起，您所点的咖啡没有");
            }
            // 加配料
            coffee.addMilk();
            coffee.addSugar();
    
            return coffee;
        }
    
    }

最后，我们来创建一个测试类来测试一下。

package com.meimeixia.pattern.factory.before;
    
    /** * @author liayun * @create 2021-05-31 22:09 */
    public class Client { 
        public static void main(String[] args) { 
            // 1. 创建咖啡店类
            CoffeeStore store = new CoffeeStore();
            // 2. 点咖啡
            Coffee coffee = store.orderCoffee("american");
            System.out.println(coffee.getName());
        }
    }

运行以上测试类，发现控制台打印了如下内容，我们想点的是美式咖啡，结果打印的也是美式咖啡，还加奶、加糖了，这说明咱们写的代码是没有任何问题的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 1]

至此，以上咖啡店点餐系统的代码我们就已经实现完毕了。

接下来，我们来分析一下以上咖啡店点餐系统的实现代码有没有什么问题。

大家不妨再来看一下咖啡店类，该类里面的点咖啡功能是要依赖于美式咖啡类和拿铁咖啡类的，如果后期我们再加一种咖啡的品种的话，那么势必就要修改这个方法里面的代码了，那么这就违背软件设计原则里面的开闭原则（即对修改关闭）了，而我们现在是肯定要修改之前的代码的。

用更加专业一点的话说，就是在Java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，那么就会对该对象耦合严重，假如我们要更换对象，那么所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。

问题是知道了，那么如何进行解决呢？其实大家想一想现实生活中的场景就知道解决方案了。比如说，我现在要用一台电脑，那么我是自己去生产一台电脑吗？很显然不是，我们直接购买一台就行，那么电脑是由谁去生产的呢？由具体的电脑工厂去生产，是不是啊？手机也是一样的，我们用一个手机，并不需要自己去生产，而是直接去买一个就行，手机也是由具体的手机工厂去生产的。

所以我们要改进以上点咖啡的案例，就得去解除咖啡店和具体咖啡的一个耦合了，这样，我们就要引入工厂思想了，通过工厂来生产对象，而我们只需要通过工厂去获取对象就行了，也就是说，我们只需要和工厂打交道就行，如此一来，就彻底和对象解耦了，当然，这儿的对象指的就是具体的咖啡对象。如果要更换对象，那么直接在工厂里面更换该对象即可，于此，便能达到与对象解耦的目的了。所以说，工厂模式最大的优点就是**解耦**。

在本教程中我会向大家介绍三种工厂的使用，它们分别是：

1.  简单工厂模式：它并不属于GOF的23种经典设计模式，也即没被收录到里面，但是在真正的开发中也有很多人习惯去用简单工厂模式
2.  工厂方法模式
3.  抽象工厂模式

下面，我先来为大家介绍一下简单工厂模式。

# 简单工厂模式 #

## 概念 ##

简单工厂模式不是一种设计模式，反而比较像一种编程习惯，如果我们以后开发有遇到适用的场景，那么就可以使用简单工厂模式了。

## 结构 ##

简单工厂模式里面包含如下角色：

*  抽象产品：定义了产品的规范，描述了产品的主要特性和功能。上面点咖啡的案例中就用到了抽象产品这个角色，就是咖啡类（即Coffee），它里面定义了一套规范
 *  具体产品：实现或者继承抽象产品的子类。在上面点咖啡的案例中，具体产品指的就是拿铁咖啡、美式咖啡
 *  具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品

可以看到，如果我们现在使用简单工厂模式来改进以上点咖啡的案例的话，那么只需要多一个角色（即具体工厂）就行了。

接下来，我们就来看一下如何使用简单工厂模式来改进以上点咖啡的案例。

## 实现 ##

现在使用简单工厂模式对上面案例进行改进，类图设计如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 2]

可以看到，咖啡相关的类是没有发生任何变化的，而咖啡店类发生了一点变化，即该类里面的点咖啡功能发生了变化，现在我们是通过简单咖啡工厂来生产咖啡，而不用自己再去new对象了。此外，相比之前的类图，我们还加入了一个简单咖啡工厂类，它就是用来生产咖啡的。

分析完了之后，接下来，我们就要开始编写代码来实现了。

首先，在com.meimeixia.pattern.factory包下新建一个子包，即simple\_factory，我们是在该包中来编写以上点咖啡案例改进之后的代码的。

由于咖啡相关的类没有发生任何变化，所以我们可以将以上案例中的咖啡相关的类拷贝过来。

*  咖啡类
    
        package com.meimeixia.pattern.factory.simple_factory;
        
        /** * 咖啡类 * @author liayun * @create 2021-05-31 21:35 */
        public abstract class Coffee { 
            public abstract String getName();
        
            // 加糖
            public void addSugar() { 
                System.out.println("加糖");
            }
        
            // 加奶
            public void addMilk() { 
                System.out.println("加奶");
            }
        }
 *  美式咖啡类
    
        package com.meimeixia.pattern.factory.simple_factory;
        
        /** * 美式咖啡 * @author liayun * @create 2021-05-31 21:40 */
        public class AmericanCoffee extends Coffee { 
            @Override
            public String getName() { 
                return "美式咖啡";
            }
        }
 *  拿铁咖啡类
    
        package com.meimeixia.pattern.factory.simple_factory;
        
        /** * 拿铁咖啡 * @author liayun * @create 2021-05-31 21:53 */
        public class LatteCoffee extends Coffee { 
            @Override
            public String getName() { 
                return "拿铁咖啡";
            }
        }

然后，创建一个简单咖啡工厂类，即SimpleCoffeeFactory，该类是用来生产咖啡的。

package com.meimeixia.pattern.factory.simple_factory;
    
    /** * 简单咖啡工厂类，用来生产咖啡 * @author liayun * @create 2021-05-31 22:48 */
    public class SimpleCoffeeFactory { 
        public Coffee createCoffee(String type) { 
            // 声明Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
            Coffee coffee = null;
            if ("american".equals(type)) { 
                coffee = new AmericanCoffee();
            } else if ("latte".equals(type)) { 
                coffee = new LatteCoffee();
            } else { 
                throw new RuntimeException("对不起，您所点的咖啡没有");
            }
    
            return coffee;
        }
    }

可以看到，简单咖啡工厂类中的生产咖啡功能的实现逻辑和我们之前咖啡店类中的点咖啡功能的实现逻辑是一样的。

接着，再创建一个咖啡店类，即CoffeeStore。根据以上设计类图，相信你能写出来下面这样一个类。

package com.meimeixia.pattern.factory.simple_factory;
    
    /** * 咖啡店 * @author liayun * @create 2021-05-31 21:54 */
    public class CoffeeStore { 
    
        public Coffee orderCoffee(String type) { 
            SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
            // 调用生产咖啡的方法
            Coffee coffee = factory.createCoffee(type);
            // 加配料
            coffee.addMilk();
            coffee.addSugar();
    
            return coffee;
        }
    
    }

现在，对于咖啡店类来说，它是不是就不依赖于具体的咖啡产品对象了啊！这样，就解除了咖啡店和具体的咖啡产品对象之间的一个耦合。

最后，我们来创建一个测试类来测试一下。

package com.meimeixia.pattern.factory.simple_factory;
    
    /** * @author liayun * @create 2021-05-31 23:04 */
    public class Client { 
        public static void main(String[] args) { 
            // 创建咖啡店类对象
            CoffeeStore store = new CoffeeStore();
            Coffee coffee = store.orderCoffee("latte");
            System.out.println(coffee.getName());
        }
    }

运行以上测试类，发现控制台打印了如下内容，我们想点的是拿铁咖啡，结果打印的也是拿铁咖啡，还加奶、加糖了，这说明咱们写的代码是没有任何问题的。

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

接下来，我们不妨再来分析一下以上改进后的案例的代码。

上面我们引入了一个简单咖啡工厂类，它是用来处理创建对象的细节的，也就是说，我们把到底创建的是美式咖啡还是拿铁咖啡这段逻辑放在了该简单咖啡工厂类里面。如果我们以后要去创建具体的咖啡对象的话，那么直接从工厂中获取就行了，因为现在咖啡店类中的orderCoffee方法变成了工厂对象的客户。这样，便解除了咖啡店类和具体咖啡子类之间的一个耦合。

但同时它又产生了新的耦合，哪个耦合呢？现在工厂对象和具体的产品对象已经耦合死了。如果我们后期要添加一个新的咖啡的品种的话，那么我们还需要去修改简单工厂类里面的代码，这个就是一个新的耦合。

而且，如果我们后期要添加新的咖啡的品种的话，那么势必还要修改简单工厂类里面的代码，而这违背了**开闭原则（开闭原则指的就是对修改关闭，对扩展开放）**，现在很明显我们要修改原有的代码。

那么，使用简单工厂模式和我们之前的做法有什么区别呢？工厂类的客户端可能有很多（只是现在咱们工厂类的客户端只有一个，就是咖啡店），比如创建美团外卖、甜品店（甜品店也有卖咖啡）等，如果要是我们之前的做法，那么就得修改很多客户端的代码了，有咖啡店客户端的代码，有美团外卖客户端的代码，有甜品店客户端的代码。而如果我们要是引入了简单工厂类的话，那么我们只需要去修改简单工厂类的代码即可，省去了其他的修改操作，这就是使用简单工厂模式所带来的好处。

## 优缺点 ##

简单工厂模式有如下优缺点：

*  优点：封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑分开（现在的业务逻辑就是咖啡店点咖啡的这个业务，而该业务已经与具体的咖啡对象解除耦合了），这样以后就避免了修改客户端代码，如果要实现新产品，那么直接修改工厂类即可，而不需要再在原代码上进行修改了，这样就降低了客户端代码修改的可能性，更加容易扩展
 *  缺点：增加新产品时还是需要修改工厂类的代码，违背了开闭原则。虽然违背了开闭原则，但是比之前不用简单工厂模式还是要更好一些

## 扩展 ##

### 静态工厂模式 ###

在本小节，我们对简单工厂模式进行一个扩展，即静态工厂模式。

在以后真正的开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，注意了，它也不是23种设计模式中的，只不过是一种习惯的写法而已。

下面我们就使用静态工厂模式来实现以上案例。

实现非常简单，只需要把之前的工厂类（即SimpleCoffeeFactory）中的创建具体咖啡对象的方法定义为静态的就可以了，其他类的代码都不需要进行一个改动。

package com.meimeixia.pattern.factory.static_factory;
    
    /** * 简单咖啡工厂类，用来生产咖啡 * @author liayun * @create 2021-05-31 22:48 */
    public class SimpleCoffeeFactory { 
        public static Coffee createCoffee(String type) { 
            // 声明Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
            Coffee coffee = null;
            if ("american".equals(type)) { 
                coffee = new AmericanCoffee();
            } else if ("latte".equals(type)) { 
                coffee = new LatteCoffee();
            } else { 
                throw new RuntimeException("对不起，您所点的咖啡没有");
            }
    
            return coffee;
        }
    }

从上可以看到，我们在com.meimeixia.pattern.factory包下新建了一个子包，即static\_factory，也就是说，使用静态工厂模式实现以上案例的代码我们都放在了该包下。注意了，大家还要记得将其他的类都拷贝到static\_factory包下哟！

以上SimpleCoffeeFactory类修改完毕之后，客户端（即咖啡店类）也得稍微修改一下，即无需再去创建咖啡工厂对象，而只需要通过SimpleCoffeeFactory类调用它里面的静态方法去获取一个具体的咖啡对象就行了。

package com.meimeixia.pattern.factory.static_factory;
    
    /** * 咖啡店 * @author liayun * @create 2021-05-31 21:54 */
    public class CoffeeStore { 
    
        public Coffee orderCoffee(String type) { 
            /*SimpleCoffeeFactory factory = new SimpleCoffeeFactory(); // 调用生产咖啡的方法 Coffee coffee = factory.createCoffee(type);*/
            Coffee coffee = SimpleCoffeeFactory.createCoffee(type);
            // 加配料
            coffee.addMilk();
            coffee.addSugar();
    
            return coffee;
        }
    
    }

那么使用静态工厂模式有什么好处呢？使用静态工厂模式唯一的一个好处就是我们在其他的客户端，例如美团外卖，从工厂对象里面去获取咖啡对象时，就不需要再去创建咖啡工厂对象了，直接通过类名去调用它里面的方法就能获取到。

### 简单工厂模式 + 配置文件 ###

在本小节，我们再来学习一个简单工厂模式的扩展，即使用简单工厂模式+配置文件的方式来解除耦合，注意，这种方式可以完全的解除耦合哟！而且在真正的开发中，我们会经常使用这种固定的套路，并且使用的还比较多哟！对了，我们无比熟悉的Spring框架，其实它底层就用到了这种方式。

我们再来看一下更为专业的描述：

> 可以通过工厂模式+配置文件的方式解除工厂对象和产品对象之间的耦合。在工厂类中加载配置文件中的全类名（注意，配置文件只需要加载一次即可），并通过反射创建对象进行存储，客户端如果需要对象的话，那么直接进行获取即可。

看完上面这段描述之后，我们知道我们还得创建一个配置文件，并还需要在配置文件中去配置类的全类名。接下来，我就来教大家如何使用简单工厂模式+配置文件的方式来实现以上点咖啡的案例。

首先，在com.meimeixia.pattern.factory包下新建一个子包，即config\_factory，使用简单工厂模式+配置文件的方式来实现以上点咖啡案例的代码我们都放在了该包下。

然后，将咖啡类、美式咖啡类、拿铁咖啡类这三个类从上面拷贝到config\_factory包下，因为这三个类并不需要进行修改。本想着就不在这里贴出来这三个类的代码了，但转念一想，为了让大家看得更清楚，还是贴出来吧！

*  咖啡类
    
        package com.meimeixia.pattern.factory.config_factory;
        
        /** * 咖啡类 * @author liayun * @create 2021-05-31 21:35 */
        public abstract class Coffee { 
            public abstract String getName();
        
            // 加糖
            public void addSugar() { 
                System.out.println("加糖");
            }
        
            // 加奶
            public void addMilk() { 
                System.out.println("加奶");
            }
        }
 *  美式咖啡类
    
        package com.meimeixia.pattern.factory.config_factory;
        
        /** * 美式咖啡 * @author liayun * @create 2021-05-31 21:40 */
        public class AmericanCoffee extends Coffee { 
            @Override
            public String getName() { 
                return "美式咖啡";
            }
        }
 *  拿铁咖啡类
    
        package com.meimeixia.pattern.factory.config_factory;
        
        /** * 拿铁咖啡 * @author liayun * @create 2021-05-31 21:53 */
        public class LatteCoffee extends Coffee { 
            @Override
            public String getName() { 
                return "拿铁咖啡";
            }
        }

接着，在maven工程的`src > main > resources`目录下创建一个配置文件，为了演示方便，这里我们不妨使用properties文件来作为配置文件，文件名字就起为bean.properties，你看咋样？文件内容如下：

american=com.meimeixia.pattern.factory.config_factory.AmericanCoffee
    latte=com.meimeixia.pattern.factory.config_factory.LatteCoffee

紧接着，创建工厂类，当然了，这里我们创建的是静态工厂模式的工厂类。

package com.meimeixia.pattern.factory.config_factory;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.HashMap;
    import java.util.Properties;
    import java.util.Set;
    
    /** * @author liayun * @create 2021-06-01 22:26 */
    public class CoffeeFactory { 
        /** * 我们所要所做的事情，就是加载配置文件，然后去获取配置文件中配置的全类名，并创建该类的对象进行存储。 */
    
        // 1. 定义容器对象存储咖啡对象
        /* * 容器选择双列集合 * 键：（咖啡）名称 * 值：咖啡对象 */
        private static HashMap<String, Coffee> map = new HashMap<String, Coffee>();
    
        // 2. 加载配置文件中的全类名，并通过反射创建对象进行存储，注意，配置文件只需要加载一次。
        // 由于配置文件只需要加载一次，所以我们最好将代码写在静态代码块里面
        static { 
            // 2.1 创建Properties对象
            Properties p = new Properties();
            // 2.2 调用p对象的load方法进行配置文件的加载，注意，配置文件（即bean.properties）是在类路径下面哟！
            InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            try { 
                p.load(is);
                // 从p集合中获取全类名并创建对象
                Set<Object> keys = p.keySet();
                for (Object key : keys) { 
                    // 获取到全类名
                    String className = p.getProperty((String) key);
                    // 通过反射技术创建对象
                    Class clazz = Class.forName(className);
                    Coffee coffee = (Coffee) clazz.newInstance();
                    // 将名称和对象存储到容器中
                    map.put((String) key, coffee);
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        /** * 根据名称获取Coffee对象 * @param name：咖啡的名称 * @return */
        public static Coffee createCoffee(String name) { 
            return map.get(name);
        }
    
    }

从以上工厂类的代码中可以看到，静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象）的，读取配置文件以及创建对象的代码是写在静态代码块中的，目的就是只需要执行一次，也就是说配置文件只需要加载一次。

最后，我们创建一个测试类来测试一下。相信你能看懂下面的测试代码吧！非常简单。

package com.meimeixia.pattern.factory.config_factory;
    
    /** * @author liayun * @create 2021-06-01 22:47 */
    public class Client { 
        public static void main(String[] args) { 
            Coffee coffee = CoffeeFactory.createCoffee("american");
            System.out.println(coffee.getName());
    
            System.out.println("=====================");
            Coffee latte = CoffeeFactory.createCoffee("latte");
            System.out.println(latte.getName());
        }
    }

运行以上测试类看结果，如下图所示，分别打印了美式咖啡和拿铁咖啡，这说明咱们写的代码是没有任何问题的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 4]

至此，工厂模式+配置文件的这种方式我就给大家讲解完了。

现在，你是不是发现使用工厂模式+配置文件这种方式，扩展性更好啊！而且，它也符合开闭原则，这是因为如果我们此时再定义一个Coffee的子类（例如卡布基诺咖啡）的话，那么工厂类的代码是不需要改变的，我们只需要在配置文件里面再配置一行内容（即卡布基诺咖啡类的全类名）就行了。

最最后，我说一下，工厂模式+配置文件这种方式在开发中是比较常用的，所以大家需要去重点掌握一下。

# 工厂方法模式 #

虽然我们使用了简单工厂模式改进了以上点咖啡的案例，但是它依旧存在一个缺点，即违背了开闭原则。如果我们使用工厂方法模式，那么就可以解决这个问题了，因为它完全遵循开闭原则。

## 概念 ##

定义一个用于创建对象的接口（该接口就是工厂，里面并没有具体的去创建某一个产品对象），让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化（也即对象的创建）延迟到其工厂的子类中。

## 结构 ##

工厂方法模式的主要角色：

*  抽象工厂（Abstract Factory）：提供了创建产品的接口，它里面并没有创建任何产品对象。调用者通过它访问具体工厂（即抽象工厂的子类）的工厂方法来创建产品
 *  具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建
 *  抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能
 *  具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应

对于以上工厂方法模式的主要角色，可能有些同学不甚理解，没关系，下面我给大家举个简单的例子来解释一下。

假设现在有一个抽象工厂，而且该抽象工厂有多个子类，即具体工厂，那么每一个具体工厂都会去创建对应的产品对象，比如我们会定义一个工厂专门用于创建美式咖啡，再定义另外一个工厂专门去创建拿铁咖啡。也就是说，具体工厂主要是实现抽象工厂中的抽象方法以完成具体产品的一个创建。

现在大家该理解了抽象工厂和具体工厂这两个角色了吧！

## 实现 ##

经过上面的学习，相信大家对工厂方法模式有了一定的认识。接下来，我们再使用工厂方法模式对以上点咖啡案例进行一个改进，通过该案例，让大家对工厂方法模式有一个更深入的理解。

大家先看一下下面的类图，这是使用工厂方法模式对以上案例进行改进之后设计出来的类图。

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

从以上类图中可以看到，右边是咖啡类、美式咖啡类、拿铁咖啡类这三个类，而且它们也是父子类的关系，这和我们之前是一样的，所以我就不再过多的去强调了。中间是咖啡店类，它里面具有一个点咖啡的功能，而且它依赖于抽象（即Coffee），而没有依赖于具体，这就符合我们之前讲过的依赖倒转原则了。左边是一个接口（即CoffeeFactory），也就是抽象工厂，而且它里面有一个抽象的方法（即createCoffee）用于创建咖啡对象，这也就形成一套规范了，那么就要求子类必须去重写了。此外，CoffeeFactory接口下面还有两个子实现类，它们分别是：

*  美式咖啡生产工厂类（即AmericanCoffeeFactory），它是得要去重写父接口中的抽象方法的，很明显它是用来生产具体的美式咖啡的，所以它还得依赖于美式咖啡类
 *  拿铁咖啡工厂类（即LatteCoffeeFactory），它也需要重写父接口中创建咖啡的抽象方法，很明显它是用来生产具体的拿铁咖啡的，所以它还得依赖于拿铁咖啡类

分析完以上类图之后，接下来，我们就要开始编写代码来实现了。

首先，在com.meimeixia.pattern.factory包下新建一个子包，即factory\_method，使用工厂方法模式实现以上案例的代码我们都放在了该包下。

然后，将咖啡类、美式咖啡类、拿铁咖啡类这三个类从上面拷贝到factory\_method包下，因为这三类并不需要进行修改。

*  咖啡类
    
        package com.meimeixia.pattern.factory.factory_method;
        
        /** * 咖啡类 * @author liayun * @create 2021-05-31 21:35 */
        public abstract class Coffee { 
            public abstract String getName();
        
            // 加糖
            public void addSugar() { 
                System.out.println("加糖");
            }
        
            // 加奶
            public void addMilk() { 
                System.out.println("加奶");
            }
        }
 *  美式咖啡类
    
        package com.meimeixia.pattern.factory.factory_method;
        
        /** * 美式咖啡 * @author liayun * @create 2021-05-31 21:40 */
        public class AmericanCoffee extends Coffee { 
            @Override
            public String getName() { 
                return "美式咖啡";
            }
        }
 *  拿铁咖啡类
    
        package com.meimeixia.pattern.factory.factory_method;
        
        /** * 拿铁咖啡 * @author liayun * @create 2021-05-31 21:53 */
        public class LatteCoffee extends Coffee { 
            @Override
            public String getName() { 
                return "拿铁咖啡";
            }
        }

接着，根据以上类图去创建一个接口，即CoffeeFactory，它属于抽象工厂角色。

package com.meimeixia.pattern.factory.factory_method;
    
    /** * CoffeeFactory：抽象工厂 * @author liayun * @create 2021-06-01 17:08 */
    public interface CoffeeFactory { 
        // 创建咖啡对象的方法
        Coffee createCoffee();
    }

紧接着，创建以上CoffeeFactory接口的子实现类。这里我们先创建第一个类，即美式咖啡生产工厂类，记住，该类得实现CoffeeFactory接口并重写它里面的方法。

package com.meimeixia.pattern.factory.factory_method;
    
    /** * 美式咖啡工厂类，专门用来生产美式咖啡 * @author liayun * @create 2021-06-01 17:12 */
    public class AmericanCoffeeFactory implements CoffeeFactory { 
        @Override
        public Coffee createCoffee() { 
            return new AmericanCoffee();
        }
    }

再创建第二个类，即拿铁咖啡生产工厂类，同理，该类得实现CoffeeFactory接口并重写它里面的方法。

package com.meimeixia.pattern.factory.factory_method;
    
    /** * 拿铁咖啡工厂类，专门用来生产拿铁咖啡 * @author liayun * @create 2021-06-01 17:16 */
    public class LatteCoffeeFactory implements CoffeeFactory { 
        @Override
        public Coffee createCoffee() { 
            return new LatteCoffee();
        }
    }

不要忘了我们还得去创建一个咖啡店类哟！从以上类图中可以看到，它里面有一个点咖啡的功能，即orderCoffee，该方法与之前有点不一样，它并不需要参数，不需要参数的话，那么它就得根据具体的工厂去获取咖啡对象了。注意，在该方法里面，我们不再需要去创建具体的工厂对象了，而是会从客户端传递进来。

package com.meimeixia.pattern.factory.factory_method;
    
    /** * 咖啡店 * @author liayun * @create 2021-05-31 21:54 */
    public class CoffeeStore { 
    
        private CoffeeFactory factory; // 依赖于抽象（即CoffeeFactory），而没有依赖于具体
    
        public void setFactory(CoffeeFactory factory) { 
            this.factory = factory;
        }
    
        // 点咖啡功能。注意，这儿不再需要创建具体工厂对象了，而是会从客户端传递进来
        public Coffee orderCoffee() { 
            Coffee coffee = factory.createCoffee();
            // 加配料
            coffee.addMilk();
            coffee.addSugar();
            return coffee;
        }
    
    }

最后，我们来创建一个测试类来测试一下。如果我们现在想要点的是拿铁咖啡，那么测试代码就应该写成下面这样。

package com.meimeixia.pattern.factory.factory_method;
    
    /** * @author liayun * @create 2021-06-01 17:57 */
    public class Client { 
        public static void main(String[] args) { 
            // 创建咖啡店对象
            CoffeeStore store = new CoffeeStore();
            // 创建具体工厂对象
            // CoffeeFactory factory = new AmericanCoffeeFactory();
            CoffeeFactory factory = new LatteCoffeeFactory();
            store.setFactory(factory);
            // 点咖啡
            Coffee coffee = store.orderCoffee();
            System.out.println(coffee.getName());
        }
    }

现在很明显，我们在客户端传递的是拿铁咖啡工厂对象，所以应该生产的是拿铁咖啡，那么到底是不是这样呢？运行一下以上测试类便知道了，如下图所示，发现控制台打印了如下内容，我们想点的是拿铁咖啡，结果打印的也是拿铁咖啡，还加奶、加糖了，这说明咱们写的代码是没有任何问题的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 6]

如果现在你想点美式咖啡，那么想必你应该知道该怎么做了吧！

此时，大家不妨开动脑筋想一想，使用工厂方法模式有没有解决以上案例中所存在的违背开闭原则的缺点呢？很显然解决了，如果我们想要添加一种新的咖啡的品种的话，那么再定义一个Coffee类的子类即可，而且此时工厂类中的方法都不需要修改，现在只需要再创建一个新的咖啡工厂的子实现类就行了，这样就解决了简单工厂模式的缺点。

总结一下，**工厂方法模式是简单工厂模式的进一步抽象，由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点**。

## 优缺点 ##

工厂方法模式有如下优缺点：

**优点：**

*  用户只需要知道具体工厂的名称就可以得到所要的产品，无须知道产品的具体创建过程，产品的具体创建过程被封装到了具体的工厂里面
 *  在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足了开闭原则，因为我们只是新添加了类，并没有去修改之前类中的代码

**缺点：**

*  每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。如果产品类特别特别多，那么就会产生类爆炸现象，也即系统里面的类特别特别多

## 工厂方法模式在源码中的体现 ##

在本小节，我们就来看一下在JDK源码中哪个地方用到了工厂方法模式。

这里，我就直接告诉大家吧！其实，单列集合里面获取迭代器的方法，即Collection.iterator，底层用的就是工厂方法模式。

为什么我会这么说呢？我们先来看下面这段代码，相信大家对这段代码是再熟悉不过了，就是使用迭代器遍历集合，并获取集合中的元素。

public class Demo { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList<>();
            list.add("令狐冲");
            list.add("风清扬");
            list.add("任我行");
    
            // 获取迭代器对象
            Iterator<String> it = list.iterator();
            // 使用迭代器遍历
            while (it.hasNext()) { 
                String ele = it.next();
                System.out.println(ele);
            }
        }
    }

从以上代码中可以看到，我们首先创建了一个List集合，并向其里面存储了三个元素，然后再通过List集合里面的iterator方法获取到迭代器对象，获取到迭代器对象之后，就可以使用它里面的方法获取集合中的元素了，也即遍历集合。

看到这里，不知大家知不知道单列集合获取迭代器的方法（即Collection.iterator）获取的到底是哪个类的对象呢？相信你之前应该从来没有去关注过这点，不过不知道也没关系，下面我就会为大家揭秘。

其实，单列集合获取迭代器的方法（即Collection.iterator）使用到了工厂方法模式，大家要是忘了的话，不妨再简单地去回顾一下。回顾起来之后，我们再来好好看看下面这张类图。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 7]

仔细看以上类图，然后再对应一下工厂方法模式里面的角色，你就能知道，Iterator接口表示的是抽象产品这一角色，ArrayList类中的Iter内部类表示的是具体产品这一角色，而且可以很明显地看到它俩是属于实现关系。

接着，我们再来看以上类图的左边部分，有一个Collection接口，它是单列集合顶层接口，它表示的是抽象工厂这一角色。而且，该接口还有一个子实现类，即ArrayList，该类表示的是具体工厂这一角色，从以上类图中也能很明显看出它俩是实现关系。其实，如果你去看源码的话，那么你会发现ArrayList类与Collection接口之间是有很多类的，也即ArrayList类的父类是蛮多的，如下图所示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 8]

但现在我们并不关注，我们关注的是Collection.iterator方法使用到的工厂方法模式，所以我画的类图是比较简单的，并没有把其它的一些类给画进来。

分析完以上类图之后，大家一定要清楚，根据工厂方法模式的学习，我们是不是应该在具体的工厂类中去创建具体的产品类对象啊？OK，下面我们就走一遭源码，亲眼看看，毕竟事实胜于雄辩。

首先进入Collection接口的源码里面，注意了，它表示的是抽象工厂这一角色，可以看到它里面有一个iterator方法，并且返回值类型是Iterator（接口），而Iterator表示的正是抽象产品这一角色。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 9]

也就是说，在单列集合顶层接口里面定义了创建Iterator对象的方法，当然了，该方法肯定是一个抽象方法，即它定义的就是一种规范，是要求子类必须实现的。

然后再进入ArrayList类的源码里面，注意看啊，它里面重写了iterator方法，如下图所示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 10]

上面我也已经说过，我们应该在具体的工厂类中去创建具体的产品类对象，而从以上类图中可知，具体产品类指的就是ArrayList类中的Iter内部类，所以，你才会看到在ArrayList类的已经重写过的iterator方法中new了一个具体的产品类对象，并返回了出去。不知大家看到没有，就在ArrayList类的iterator方法下面，Iter内部类赫然在列，该内部类正实现了Iterator接口，所以，大家看出来了没有，这就是工厂方法模式啊！

最后，我总结一下，如下：

![在这里插入图片描述][20210719224143819.png_pic_center]

最最后，我再说一点，在JDK的源码里面有很多地方都用到了工厂方法模式，例如：

1.  DateFormat类中的getInstance方法用到了工厂方法模式
2.  Calendar类中的getInstance方法也用到了工厂方法模式

不过，在这里我们就不分析了，大家重点把单列集合获取迭代器的方法（即Collection.iterator）使用到的工厂方法模式分析清楚就可以了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center]: /images/20221004/b81b11773e58456985cc8c2e364b1e96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221004/79c6a3698b61400f8b0b4dc0d4dfe46a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221004/ea9f5681908848c1b599675dbdf01e76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221004/6b6ffa5bce4540fb939b142d89999d48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221004/cd6b1c9eb8be40de948578db86b246e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221004/4450a7b9f0b840de866f4884ceed90a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221004/fc478db5373e4a7da3db9052518278c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221004/b29c62fbfc2c4481b44a7a60c84ae9eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221004/5ffff1fdf6a94ceda65d76576c7b4b76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221004/29f103aa377c4813b153ea354705a150.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221004/d33edf9717ab488d9af826fd9c6688cf.png
[20210719224143819.png_pic_center]: /images/20221004/db27f017126a4338b40012ca1dd9d393.png