23种设计模式——工厂模式

23种设计模式——工厂模式

1、工厂模式概述

工厂模式的定义：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这满足创建型模式中所要求的“创建与使用相分离”的特点。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

2、简单工厂模式

• 在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

• 简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

• “工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

2.1、简单工厂模式的优缺点

优点：

1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。
3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

1. 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
2. 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
3. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
4. 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

应用场景

对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

2.2、简单工厂模式的结构

简单工厂模式的主要角色如下：

• 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
• 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
• 具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

其结构图如下图所示。

2.3、简单工厂模式的实现

抽象产品

public interface Car {
    void name();
}
1
2
3

具体产品

public class Lamborghini implements Car{
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}
1
2
3
4
5
6

public class Porsche implements Car{
    @Override
    public void name() {
        System.out.println("保时捷");
    }
}
1
2
3
4
5
6

简单工厂

//工厂类
public class CarFactory {
    //创建产品的方法
    public static Car getCar(String car){
        if ("保时捷".equals(car)){
           return new Porsche();
        }else if ("兰博基尼".equals(car)){
           return new Lamborghini();
        }else {
            return null;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

测试类测试：

public class Consumer {
    public static void main(String[] args) {

        //直接调用工厂类创建产品的方法，不需要知道具体的细节，只需要知道产品名就行
        Car car = CarFactory.getCar("兰博基尼");
        Car car1 = CarFactory.getCar("保时捷");

        car.name();//兰博基尼
        car1.name();//保时捷
    }
}
1
2
3
4
5
6
7
8
9
10
11

3、工厂方法模式

“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

3.1、工厂方法模式的优缺点

优点：

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
• 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
• 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景：

• 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

3.2、工厂方法模式的结构

工厂方法模式的主要角色如下。

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

结构图如下图所示：

3.3、工厂方法模式的实现

抽象产品

public interface Car {
    void name();
}
1
2
3

具体产品

public class Lamborghini implements Car{
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}
1
2
3
4
5
6

public class Porsche implements Car{
    @Override
    public void name() {
        System.out.println("保时捷");
    }
}
1
2
3
4
5
6

抽象工厂

//抽象工厂
public interface CarFactory {
    Car getCar();
}
1
2
3
4

具体工厂，它同具体产品之间一一对应

//具体工厂
public class LamborghiniFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Lamborghini();
    }
}
1
2
3
4
5
6
7

//具体工厂
public class PorscheFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Porsche();
    }
}
1
2
3
4
5
6
7

测试类测试：

public class Consumer {
    public static void main(String[] args) {
        //调用具体工厂，由具体工厂实现
        Car car = new LamborghiniFactory().getCar();
        Car car1 = new PorscheFactory().getCar();

        car.name();//兰博基尼
        car1.name();//保时捷

    }
}
1
2
3
4
5
6
7
8
9
10
11

4、抽象工厂模式

4.1、抽象工厂模式概述

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到**同族的不同等级的产品**的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

优缺点：
抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

产品等级与产品族：

抽象工厂模式的应用场景：

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

4.2、抽象工厂模式结构

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

抽象工厂模式的主要角色如下。

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

抽象工厂模式的结构图：

4.3、抽象工厂模式实现

抽象产品，定义了产品的规范，描述了产品的主要特性和功能

//手机产品接口
public interface IPhoneProduct {
    void start();

    void shutdown();

    void callup();

    void sendSMS();
}
1
2
3
4
5
6
7
8
9
10

//路由器产品接口
public interface IRouterProduct {
    void start();

    void shutdown();

    void openWifi();

    void setting();
}
1
2
3
4
5
6
7
8
9
10

抽象工厂，提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。

//抽象工厂
public interface IProductFactory {

    //手机是一个产品等级，路由器又是一个产品等级
    //生产手机
    IPhoneProduct iPhoneProduct();

    //生产路由器
    IRouterProduct iRouteProduct();
}
1
2
3
4
5
6
7
8
9
10

具体工厂，实现抽象工厂中的多个抽象方法，完成具体产品的创建。

//小米工厂，这是一个产品族
public class RedmiProduct implements IProductFactory{
    //下面是两个不同的产品等级
    @Override
    public IPhoneProduct iPhoneProduct() {
        return new RedmiPhone();
    }

    @Override
    public IRouterProduct iRouteProduct() {
        return new RedmiRouter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

//华为工厂，这又是一个产品族
public class HuaweiProduct implements IProductFactory{
    //下面是两个不同的产品等级
    @Override
    public IPhoneProduct iPhoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct iRouteProduct() {
        return new HuaweiRouter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

具体产品，实现了抽象产品所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

package com.cheng.factory.abstractFactory;

public class RedmiPhone 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("小米发短信");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package com.cheng.factory.abstractFactory;

public class RedmiRouter 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("小米路由器设置");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package com.cheng.factory.abstractFactory;

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("华为发短信");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package com.cheng.factory.abstractFactory;

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("华为路由器设置");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

最后测试类，进行测试：

public class Consumer {
    public static void main(String[] args) {
        System.out.println("===========小米产品系列===========");
        RedmiProduct redmiProduct = new RedmiProduct();
        //生产小米手机
        IPhoneProduct iPhoneProduct = redmiProduct.iPhoneProduct();
        //生产小米路由器
        IRouterProduct iRouterProduct = redmiProduct.iRouteProduct();

        iPhoneProduct.start();//小米开机
        iRouterProduct.start();//小米路由器开机


        System.out.println("===========华为产品系列===========");
        HuaweiProduct huaweiProduct = new HuaweiProduct();
        //生产华为手机
        IPhoneProduct iPhoneProduct1 = huaweiProduct.iPhoneProduct();
        //生产华为路由器
        IRouterProduct iRouterProduct1 = huaweiProduct.iRouteProduct();

        iPhoneProduct1.start();//华为开机
        iRouterProduct1.start();//华为路由器开机

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

抽象工厂模式模式的扩展：

抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

1. 当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
2. 当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。

另一方面，当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。