前言： 在前面的一篇文章中，我们了解什么是设计模式、单例模式是什么、怎样设计单例模式。那么今天我们开始来讲一讲什么是工厂模式以及怎样设计工厂模式。如果你的设计模式还没有开始入门的话，那么建议先从我的单例模式开始看，开始了解，因为我认为前面的单例模式会对我们今天讲解的工厂模式有一定的了解帮助。

1、什么是工厂模式？

我们都知道在 java 中，万物皆对象，这些对象都需要创建，如果创建的时候直接 new 该对象，就会对该对象耦合严重，假如我们要更换对象，所有 new 对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

我们这里从三个方面来循序渐进地进行讲解工厂模式：

• 简单工厂模式（不属于23种经典设计模式）
• 工厂方法模式
• 抽象工厂模式

2、简单工厂模式

• 简单工厂模式的介绍

我们上面介绍到了，如果直接通过 new 进行创建对象的话，那么显然耦合度极高，那么如果我们需要添加一定的类的话（也就是扩展一些类的话），会导致需要对相关的代码进行修改，这也就违背了软件设计的开闭原则。而在简单工产设计模式就是对其进行了封装，然后通过工厂进行生产对应的产品对象。其实它不是一种设计模式，反而比较像是一种编程习惯。

• 其中的角色

1. 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
2. 具体产品 ：实现或者继承抽象产品的子类
3. 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。

讲到这里，大家肯定还是迷迷糊糊的，那么接下来我们通过一个例子来进行讲解吧。

• Coffee

public abstract class Coffee {
    public abstract String getName();
    // 1. 加糖
    public void addSugar(){
        System.out.println("加糖");
    }
    // 2. 加奶
    public void addMilk(){
        System.out.println("加奶");
    }
}

• AmericanCoffee

public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

• LatteCoffee

public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

• CoffeeSimpleFactory

public class CoffeeSimpleFactory {
    public Coffee createCoffee(String type){
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        }else if("latte".equals(type)){
            coffee = new LatteCoffee();
        }else {
            throw new RuntimeException("对不起，您点的咖啡我们没有提供。");
        }
        // 加糖
        coffee.addSugar();
        // 加奶
        coffee.addMilk();
        return coffee;
    }
}

• 优点

通过上述例子我们都知道简单工厂类封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

• 缺点

但是如果我们需要增加新产品时还是需要修改工厂类的代码，所以它还是违背了 “开闭原则”。

• 扩展

public class SimpleCoffeeFactory {
    public static Coffee createCoffee(String type) {
        Coffee coffee = null;
        if("americano".equals(type)) {
            coffee = new AmericanoCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffe;
    }
}

这里的话，我们主要是在相应的创建咖啡的方法上加上了 static 关键字，它表明我们不需要创建对应的工厂对象，而是通过对应的类名就可以直接获取对应的咖啡对象。

3、工厂方法模式

• 工厂方法模式的介绍

其实，每一个新事物的产生都是有它的存在理由的，那么工厂方法模式的产生主要是由于简单工厂模式违背了 开闭原则。如果我们需要新增对应的新产品的话，那么会导致我们需要对对应的工厂类进行修改，那么肯定就需要修改对应的工厂类。所以引出了工厂方法模式，我们创建一个工厂的接口，然后根据不同的生产对象定义对应工厂接口的生产对象的实现类。

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

1. 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
2. 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
4. 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

那么下面我通过对应的例子来进行介绍一下它

• CoffeeFactory

public interface CoffeeFactory {
    // 生产咖啡
    Coffee createCoffee();
}

• AmericanCoffeeFactory

public class AmericanCoffeeFactory implements CoffeeFactory{
    // 生产美式咖啡
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}

• LatteCoffeeFactory

public class LatteCoffeeFactory implements CoffeeFactory{
    // 生产拿铁咖啡
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

从上述例子我们可以看出来，如果我们需要进行新增对应的产品的时候，我们只需要新增对应的产品对象，然后新增对应的生产对象工厂，这样我们就可以实现对应的扩展了。我们这里避免了对应的简单工厂模式里面的工厂类的修改。其满足 开闭原则，同时满足 扩展开放原则。

• 优点

1. 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
2. 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

• 缺点

1. 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

3、抽象工厂模式

• 抽象工厂模式介绍

同时抽象工厂模式的引出也是因为前面的所提出的新的工厂方法模式有一定的缺点，主要是因为工厂方法模式如果对应的产品类过多的话，那么会导致对应的具体工厂类也会过多。对应的开发者认识到了这个缺点，所以提出了抽象工厂模式，前面的工厂模式都是讨论的是一类产品的，而抽象工厂模式中主要是讨论的是同一产品族的产品。除了产品族，还有一个概念就是产品等级，不知道大家知道不知道这两个概念。下面我来介绍一下。将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

比如说，华为公司既生产手机，也生产电脑；小米公司既生产手机，也生产电脑。那么华为公司生产的手机和电脑就属于一个产品族，而华为公司生产的手机和小米公司生产的手机属于一个产品等级。经过这样一个介绍，想必大家应该对这两个概念都了解一些了吧。那么下面我们可以开始介绍抽象工厂模式了。

• 抽象工厂模式的主要角色

1. 抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
2. 具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
3. 抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
4. 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。

• DessertFactory

public interface DessertFactory {
    Coffee createCoffee();
    Dessert createDessert();
}

• AmericanDessertFactory

public class AmericanDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
    @Override
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}

• ItalyDessertFactory

public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    @Override
    public Dessert createDessert() {
        return new Tiramisu();
    }
}

这里我们对应的各自的咖啡和甜点属于一个产品族，这里我们通过编写对应的意大利甜点工厂和美式甜点工厂进行设计，如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

• 优点

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

• 缺点

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

• 使用场景

1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2. 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
3. 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

5、简单工厂+配置文件解除耦合

简单工厂 + 配置文件 该组合是目前比较主流的一种设计模式，想必大家在 spring 的底层也见到过这种设计组合。

• 配置文件

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

• 工厂类

public class CoffeeFactory {
    private static Map<String,Coffee> map = new HashMap();
    static {
        Properties p = new Properties();
        InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            p.load(is);
            //遍历Properties集合对象
            Set<Object> keys = p.keySet();
            for (Object key : keys) {
                //根据键获取值（全类名）
                String className = p.getProperty((String) key);
                //获取字节码对象
                Class clazz = Class.forName(className);
                Coffee obj = (Coffee) clazz.newInstance();
                map.put((String)key,obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Coffee createCoffee(String name) {
        return map.get(name);
    }
}

这里我们在初始化的时候，就会从对应的配置文件中加载到对应的类的相关数据，并生成好对应的对象，然后放置到对应的 map 集合中，那么就实现了加载一次的效果。

编写不易，如果你感觉对你有帮助的话，请你三连支持，后面的文章会一点点更新。