GoF23:工厂模式(Factory)

核心本质：

实例化对象不使用new，用工厂方法代替
将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

工厂模式三种模式

简单工厂模式（静态工厂模式）
工厂方法模式
抽象工厂模式

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

用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有的代码，不符合开闭原则）

现在定义一种情景，就是消费者去买车，他可以自己组成车，也可以找一个工厂来生产几种不同类型的车，也可以到专门生产该车型的工厂买。

定义一个接口

public interface Car {
    void getName();
}

让两种不同的汽车类都去实现Car接口

public class Tesla implements Car{
    @Override
    public void getName() {
        System.out.println("特斯拉汽车");
    }
}

public class WuLing implements Car{
    @Override
    public void getName() {
        System.out.println("五菱汽车");
    }
}

在Consumer的主方法中的操作相当于是我们自己组成的对象（自己组车）：

public class Consumer {
    public static void main(String[] args) {
        // 原先我们要使用哪个对象，都是我们自己new出来的，相当于是自己创建的
        Car car1 = new WuLing();
        Car car2 = new Tesla();
        car1.getName();
        car2.getName();
    }
}

现在我们让一个工厂来生产我们所需要的对象，不需要我们自己去new了：

/**
 * 简单工厂模式,并不符合开闭原则，如果新增产品，就必须对原先的代码进行修改
 */
public class CarFactory {
    // 方式一：
    public static Car getCar(String name) {
        if ("五菱".equals(name)) {
            return new WuLing();
        } else if ("特斯拉".equals(name)) {
            return new Tesla();
        } else {
            return null;
        }
    }
    // 方式二：
    public static Car getWuLing() {
        return new WuLing();
    }
    public static Car getTesla() {
        return new Tesla();
    }
}

在Consumer的主方法中的操作相当于从工厂中获取我们需要的对象：

public class Consumer {
    public static void main(String[] args) {
        // 现在使用简单工厂模式，来获取我们需要的对象
        Car car1 = CarFactory.getCar("五菱");
        Car car2 = CarFactory.getCar("特斯拉");
        car1.getName();
        car2.getName();
    }
}

但是上面的简单工厂有一些弊端，如果我们需要新增一个类，就需要对工厂中的代码进行修改，这不符合开闭原则（对扩展是开放的，对修改是关闭的）

工厂方法模式

用来生产同一等级结构中的固定产品（支持增加任意）

工厂方法模式还是承接上面的情景，只不过每一个对象，即车，都有一个专门工厂去生产该对象。

public interface Car {
    void getName();
}

对原来的CarFactory进行提取，相当于是加上一层

public interface CarFactory {
    Car getCar();
}

public class WuLing implements Car {
    @Override
    public void getName() {
        System.out.println("五菱汽车");
    }
}

专门生产五菱汽车的工厂

public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

public class Tesla implements Car {
    @Override
    public void getName() {
        System.out.println("特斯拉汽车");
    }
}

专门生产特斯拉汽车的工厂

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

不去new我们需要的对象，而是new一个工厂对象去生产我们需要的对象

public class Consumer {
    public static void main(String[] args) {
        Car car1 = new WuLingFactory().getCar();
        Car car2 = new TeslaFactory().getCar();
        car1.getName();
        car2.getName();
    }
}

工厂方法模式就可以避免修改CarFactory中的代码，当我们需要新增一个对象时，只需要创建生产对象的工厂即可。符合开闭原则，但是无论在结构复杂度、管理复杂度……都是simple简单工厂占优势，因此在设计原则上：工厂方法模式，在实际业务中：简单工厂模式。

抽象工厂模式

围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

举例说明

UML类图：

Creator:产品族工厂，定义了一系列的产品生产行为
ConcreteCreator:具体的产品族工厂
Product:抽象产品接口
ProductA1/A2/B1/B2：都是具体的产品，实现了相应的产品接口

举个栗子:

手机是一个抽象的产品，手机有小米手机，华为手机，路由器也是一个抽象的产品，路由器有小米路由器，华为路由器。

具体的手机和抽象手机就构成了一个产品等级结构。

具体的路由器和抽象路由器就构成了另外一个产品等级结构。

实质上产品等级结构即产品的继承结构，即它们都实现了相同的接口。

划重点就是产品族中的产品都是由同一个工厂生产的，位于不同的产品等级结构。因为同一产品族中的各个产品，实现的不是相同的接口，所以不位于同一产品等级结构。

它们之间的关系如下图所示：

对上图的说明：

图中横坐标代表产品等级，新增产品等级为横坐标的增长，方向向右，具体表现为新增一列；
图中纵坐标为产品族等级，新增产品族为纵坐标的增长，方向向上，具体表现为新增一排；

对比一下工厂方法和抽象工厂方法：

工厂模式针对的是产品等级结构，定义一种生产该产品工厂的接口，让不同类型的厂商去分别实现它，每一个实现了接口的工厂专门用来生产这一种产品。

抽象工厂模式针对的是产品族等级结构，这个抽象工厂是用来生产工厂的，被生产的工厂再去生产它们各自产品族中的产品，这样，每一个实现类工厂都可以生产本产品族的不同产品。

如何选择：

在两者的使用选择，要结合实际业务，对于产品等级数量相对固定的产品族，可以优先考虑抽象工厂模式，但是如果频繁变动，则不大适用，因为在现有的产品族中新增产品等级时，就需要修改产品族工厂，也就违背了开闭原则；而对于新增产品族，只需实现相应的接口即可，不需要修改产品族工厂中的代码。

代码实现

这里以上面的手机和路由器为栗：

简要的实现说明：

定义抽象产品接口

//手机产品接口
public interface IPhoneProduct {
    //开机
    void start();
    //关机
    void shutdown();
    //拨打电话
    void callUp();
    //发送短信
    void sendSMS();
}


//路由器产品接口
public interface IRouterProduct {
    //开机
    void start();
    //关机
    void shutdown();
    //开启wifi
    void openWifi();
    //设置参数
    void setting();
}

定义小米品牌手机和路由器产品实现类、华为品牌手机和路由器产品实现类

//小米手机产品
public class XiaomiPhone implements IPhoneProduct {
    @Override
    public void start() {
        System.out.println("开启小米手机");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }
    @Override
    public void callUp() {
        System.out.println("用小米手机打电话");
    }
    @Override
    public void sendSMS() {
        System.out.println("用小米手机发短信");
    }
}

//小米路由器产品
public class XiaomiRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("启动小米路由器");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }
    @Override
    public void openWifi() {
        System.out.println("打开小米路由器的wifi功能");
    }
    @Override
    public void setting() {
        System.out.println("设置小米路由器参数");
    }
}

//华为手机产品
public class HuaweiPhone implements IPhoneProduct {
    @Override
    public void start() {
        System.out.println("开启华为手机");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }
    @Override
    public void callUp() {
        System.out.println("用华为手机打电话");
    }
    @Override
    public void sendSMS() {
        System.out.println("用华为手机发短信");
    }
}

//华为路由器产品
public class HuaweiRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("启动华为路由器");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }
    @Override
    public void openWifi() {
        System.out.println("打开华为路由器的wifi功能");
    }
    @Override
    public void setting() {
        System.out.println("设置华为路由器参数");
    }
}

定义一个抽象工厂接口，或者称之为抽象产品族工厂

//抽象产品工厂（定义了同一个产品族的产品生产行为）
public interface IProductFactory {
    //生产手机
    IPhoneProduct produceTelPhone();
    //生产路由器
    IRouterProduct produceRouter();
}

小米工厂和华为工厂的实现了

//小米产品工厂
public class XiaomiProductFactory implements IProductFactory {
    @Override
    public IPhoneProduct produceTelPhone() {
        System.out.println(">>>>>>生产小米手机");
        return new XiaomiPhone();
    }
    @Override
    public IRouterProduct produceRouter() {
        System.out.println(">>>>>>生产小米路由器");
        return new XiaomiRouter();
    }
}

//华为产品工厂
public class HuaweiProductFactory implements IProductFactory{
    @Override
    public IPhoneProduct produceTelPhone() {
        System.out.println(">>>>>>生产华为手机");
        return new HuaweiPhone();
    }
    @Override
    public IRouterProduct produceRouter() {
        System.out.println(">>>>>>生产华为路由器");
        return new HuaweiRouter();
    }
}

客户端

//客户端
public class Client {
    public static void main(String[] args) {
        System.out.println("===================小米系列产品=================");
        //小米产品工厂实例
        IProductFactory xiaomiProductFactory = new XiaomiProductFactory();
        //生产小米路由器
        IRouterProduct xiaomiRouter = xiaomiProductFactory.produceRouter();
        xiaomiRouter.start();
        xiaomiRouter.setting();
        xiaomiRouter.openWifi();
        xiaomiRouter.shutdown();
        //生产小米手机
        IPhoneProduct xiaomiPhone = xiaomiProductFactory.produceTelPhone();
        xiaomiPhone.start();
        xiaomiPhone.callUp();
        xiaomiPhone.sendSMS();
        xiaomiPhone.shutdown();
        System.out.println("===================华为系列产品=================");
        //华为产品工厂实例
        IProductFactory huaweiProductFactory = new HuaweiProductFactory();
        //生产华为路由器
        IRouterProduct huaweiRouter = huaweiProductFactory.produceRouter();
        huaweiRouter.start();
        huaweiRouter.setting();
        huaweiRouter.openWifi();
        huaweiRouter.shutdown();
        //生产华为手机
        IPhoneProduct huaweiPhone = huaweiProductFactory.produceTelPhone();
        huaweiPhone.start();
        huaweiPhone.callUp();
        huaweiPhone.sendSMS();
        huaweiPhone.shutdown();
    }
}

运行结果：

===小米系列产品=
>>>>>>生产小米路由器
启动小米路由器
设置小米路由器参数
打开小米路由器的wifi功能
关闭小米路由器
>>>>>>生产小米手机
开启小米手机
用小米手机打电话
用小米手机发短信
关闭小米手机
===华为系列产品=
>>>>>>生产华为路由器
启动华为路由器
设置华为路由器参数
打开华为路由器的wifi功能
关闭华为路由器
>>>>>>生产华为手机
开启华为手机
用华为手机打电话
用华为手机发短信
关闭华为手机

关系图：