设计模式系列12—工厂模式

本片文章有点长,请做好心理准备...

1 工厂模式的定义与特点

1.1 定义

工厂模式是 Java 中最常用的设计模式之一,这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。

工厂模式根据抽象程度的不同分为三种:

  • 简单工厂模式(也叫静态工厂模式,因为工厂类定义了一个静态方法))
  • 工厂方法模式(也叫多形性工厂)
  • 抽象工厂模式(也叫工具箱)
    image.png

(1)简单工厂模式
实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。

(2)工厂方法模式
工厂方法是粒度很小的设计模式,因为模式的表现只是一个抽象的方法。 提前定义用于创建对象的接口,让子类决定实例化具体的某一个类,即在工厂和产品中间增加接口,工厂不再负责产品的创建,由接口针对不同条件返回具体的类实例,由具体类实例去实现。

(3)抽象工厂模式
当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品对象。它有多个抽象产品类,每个抽象产品类可以派生出多个具体产品类,一个抽象工厂类,可以派生出多个具体工厂类,每个具体工厂类可以创建多个具体产品类的实例。

1.2 特点

无论是简单工厂模式、工厂模式还是抽象工厂模式,它们本质上都是将不变的部分提取出来,将可变的部分留作接口,以达到最大程度上的复用。究竟用哪种设计模式更适合,这要根据具体的业务需求来决定。

2 简单工厂模式

简单工厂模式又叫静态方法模式(因为工厂类定义了一个静态方法),现实生活中,工厂是负责生产产品的;同样在设计模式中,简单工厂模式我们可以理解为负责生产对象的一个类,称为“工厂类”。
image

2.1 解决的问题

将“类实例化的操作”与“使用对象的操作”分开,让使用者不用知道具体参数就可以实例化出所需要的“产品”类,从而避免了在客户端代码中显式指定,实现了解耦。
即使用者可直接消费产品而不需要知道其生产的细节

2.2 简单工厂模式模式结构组成

组成(角色)关系作用
抽象产品(Product)具体产品的父类描述产品的公共接口
具体产品(Concrete Product)抽象产品的子类;工厂类创建的目标类描述生产的具体产品
工厂(Creator)被外界调用根据传入不同参数从而创建不同具体产品类的实例

UML类图如下:
image.png

2.3 简单工厂模式模式的实现

背景:

  • 背景:小成有一个塑料生产厂,用来做塑料加工生意
  • 目的:最近推出了3个产品,小成希望使用简单工厂模式实现3款产品的生产

使用步骤:

  • 创建抽象产品类 & 定义具体产品的公共接口;
  • 创建具体产品类(继承抽象产品类) & 定义生产的具体产品;
  • 创建工厂类,通过创建静态方法根据传入不同参数从而创建不同具体产品类的实例;
  • 外界通过调用工厂类的静态方法,传入不同参数从而创建不同具体产品类的实例

实现代码如下:

步骤1. 创建抽象产品类,定义具体产品的公共接口

abstract class Product{
    public abstract void Show();
}

步骤2. 创建具体产品类(继承抽象产品类),定义生产的具体产品

//具体产品类A
class  ProductA extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品类B
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

//具体产品类C
class  ProductC extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

步骤3. 创建工厂类,通过创建静态方法从而根据传入不同参数创建不同具体产品类的实例

class  Factory {
    public static Product Manufacture(String ProductName){
//工厂类里用switch语句控制生产哪种商品;
//使用者只需要调用工厂类的静态方法就可以实现产品类的实例化。
        switch (ProductName){
            case "A":
                return new ProductA();

            case "B":
                return new ProductB();

            case "C":
                return new ProductC();

            default:
                return null;

        }
    }
}

步骤4. 外界通过调用工厂类的静态方法,传入不同参数从而创建不同具体产品类的实例

//工厂产品生产流程
public class SimpleFactoryPattern {
    public static void main(String[] args){
        Factory mFactory = new Factory();

        //客户要产品A
        try {
//调用工厂类的静态方法 & 传入不同参数从而创建产品实例
            mFactory.Manufacture("A").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品B
        try {
            mFactory.Manufacture("B").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品C
        try {
            mFactory.Manufacture("C").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品D
        try {
            mFactory.Manufacture("D").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }
    }
}

结果输出:

生产出了产品A
生产出了产品C
生产出了产品C
没有这一类产品

2.4 简单工厂模式的优缺点

优点:

  • 将创建实例的工作与使用实例的工作分开,使用者不必关心类对象如何创建,实现了解耦;
  • 把初始化实例时的工作放到工厂里进行,使代码更容易维护。 更符合面向对象的原则 & 面向接口编程,而不是面向实现编程。

缺点:

  • 工厂类集中了所有实例(产品)的创建逻辑,一旦这个工厂不能正常工作,整个系统都会受到影响;
  • 违背“开放 - 关闭原则”,一旦添加新产品就不得不修改工厂类的逻辑,这样就会造成工厂逻辑过于复杂。
    简单工厂模式由于使用了静态工厂方法,静态方法不能被继承和重写,会造成工厂角色无法形成基于继承的等级结构。

2.5 简单工厂模式的应用场景

在了解了优缺点后,我们知道了简单工厂模式的应用场景:

  • 客户如果只知道传入工厂类的参数,对于如何创建对象的逻辑不关心时;
  • 当工厂类负责创建的对象(具体产品)比较少时。

3 工厂方法模式

工厂方法模式,又称工厂模式、多态工厂模式和虚拟构造器模式,通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。
主要作用是将类的实例化(具体产品的创建)延迟到工厂类的子类(具体工厂)中完成,即由子类来决定应该实例化(创建)哪一个类。

image.png

3.1 解决的问题

工厂一旦需要生产新产品就需要修改工厂类的方法逻辑,违背了“开放 - 关闭原则

  • 即简单工厂模式的缺点

之所以可以解决简单工厂的问题,是因为工厂方法模式把具体产品的创建推迟到工厂类的子类(具体工厂)中,此时工厂类不再负责所有产品的创建,而只是给出具体工厂必须实现的接口,这样工厂方法模式在添加新产品的时候就不修改工厂类逻辑而是添加新的工厂子类,符合开放封闭原则,克服了简单工厂模式中缺点

3.2 工厂方法模式结构组成

组成(角色)关系作用
抽象产品(Product)具体产品的父类描述具体产品的公共接口
具体产品(Concrete Product)抽象产品的子类;工厂类创建的目标类描述生产的具体产品
抽象工厂(Creator)具体工厂的父类描述具体工厂的公共接口
具体工厂(Concrete Creator)抽象工厂的子类;被外界调用描述具体工厂;实现FactoryMethod工厂方法创建产品的实例

其UML类图如下所示:
image.png

3.3 工厂方法模式实现

背景:

  • 背景:小成有一间塑料加工厂(仅生产A类产品);随着客户需求的变化,客户需要生产B类产品;
  • 冲突:改变原有塑料加工厂的配置和变化非常困难,假设下一次客户需要再发生变化,再次改变将增大非常大的成本;
  • 解决方案:小成决定置办塑料分厂B来生产B类产品;
    即工厂方法模式

使用步骤:

  • 步骤1: 创建抽象工厂类,定义具体工厂的公共接口;
  • 步骤2: 创建抽象产品类 ,定义具体产品的公共接口;
  • 步骤3: 创建具体产品类(继承抽象产品类) & 定义生产的具体产品;
  • 步骤4:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;
  • 步骤5:外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例

代码实现如下:
步骤1: 创建抽象工厂类,定义具体工厂的公共接口

abstract class Factory{
    public abstract Product Manufacture();
}

步骤2: 创建抽象产品类 ,定义具体产品的公共接口;

abstract class Product{
    public abstract void Show();
}

步骤3: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品B类
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

步骤4:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

步骤5:外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例

//生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();

        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

结果:

生产出了产品A
生产出了产品C

3.4 工厂方法模式优缺点

优点:

  • 更符合开-闭原则
    新增一种产品时,只需要增加相应的具体产品类和相应的工厂子类即可
    简单工厂模式需要修改工厂类的判断逻辑

  • 符合单一职责原则
    每个具体工厂类只负责创建对应的产品
    简单工厂中的工厂类存在复杂的switch逻辑判断

  • 不使用静态工厂方法,可以形成基于继承的等级结构。
    简单工厂模式的工厂类使用静态工厂方法

总结:工厂模式可以说是简单工厂模式的进一步抽象和拓展,在保留了简单工厂的封装优点的同时,让扩展变得简单,让继承变得可行,增加了多态性的体现。

缺点:

  • 添加新产品时,除了增加新产品类外,还要提供与之对应的具体工厂类,系统类的个数将成对增加,在一定程度上增加了系统的复杂度;同时,有更多的类需要编译和运行,会给系统带来一些额外的开销;
  • 由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。
  • 虽然保证了工厂方法内的对修改关闭,但对于使用工厂方法的类,如果要更换另外一种产品,仍然需要修改实例化的具体工厂类;
  • 一个具体工厂只能创建一种具体产品

3.5 工厂方法模式应用场景

在了解了优缺点后,我总结了工厂方法模式的应用场景:

  • 当一个类不知道它所需要的对象的类时
  • 在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可;
  • 当一个类希望通过其子类来指定创建对象时
  • 在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展。
  • 将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无须关心是哪一个工厂子类创建产品子类,需要时再动态指定,可将具体工厂类的类名存储在配置文件或数据库中。

4 抽象工厂模式

抽象工厂模式,即Abstract Factory Pattern,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类;具体的工厂负责实现具体的产品实例。

抽象工厂模式与工厂方法模式最大的区别:抽象工厂中每个工厂可以创建多种类的产品;而工厂方法每个工厂只能创建一类

其主要作用是允许使用抽象的接口来创建一组相关产品,而不需要知道或关心实际生产出的具体产品是什么,这样就可以从具体产品中被解耦。

image.png

4.1 解决的问题

每个工厂只能创建一类产品

  • 即工厂方法模式的缺点

4.2 抽象工厂模式结构组成

组成(角色)关系作用
抽象产品族(AbstractProduct)抽象产品的父类描述抽象产品的公共接口
抽象产品(Product)具体产品的父类描述具体产品的公共接口
具体产品(Concrete Product)抽象产品的子类;工厂类创建的目标类描述生产的具体产品
抽象工厂(Creator)具体工厂的父类描述具体工厂的公共接口
具体工厂(Concrete Creator)抽象工厂的子类;被外界调用描述具体工厂;实现FactoryMethod工厂方法创建产品的实例

其UML类图如下:
image.png

如何理解抽象产品族、抽象产品和具体产品的区别呢?请看下图
image.png

4.3 抽象工厂模式实现

背景:

  • 背景:小成有两间塑料加工厂(A厂仅生产容器类产品;B厂仅生产模具类产品);随着客户需求的变化,A厂所在地的客户需要也模具类产品,B厂所在地的客户也需要容器类产品;
  • 冲突:没有资源(资金+租位)在当地分别开设多一家注塑分厂
  • 解决方案:在原有的两家塑料厂里增设生产需求的功能,即A厂能生产容器+模具产品;B厂间能生产模具+容器产品。——即抽象工厂模式

使用步骤:

  • 步骤1: 创建抽象工厂类,定义具体工厂的公共接口;
  • 步骤2: 创建抽象产品族类 ,定义抽象产品的公共接口;
  • 步骤3: 创建抽象产品类 (继承抽象产品族类),定义具体产品的公共接口;
  • 步骤4: 创建具体产品类(继承抽象产品类) & 定义生产的具体产品;
  • 步骤5:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;
  • 步骤6:客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例

代码实现如下:
步骤1: 创建抽象工厂类,定义具体工厂的公共接口

abstract class Factory{
   public abstract Product ManufactureContainer();
    public abstract Product ManufactureMould();
}

步骤2: 创建抽象产品族类 ,定义具体产品的公共接口;

abstract class AbstractProduct{
    public abstract void Show();
}

步骤3: 创建抽象产品类 ,定义具体产品的公共接口;

//容器产品抽象类
abstract class ContainerProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

//模具产品抽象类
abstract class MouldProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

步骤4: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

//容器产品A类
class ContainerProductA extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品A");
    }
}

//容器产品B类
class ContainerProductB extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品B");
    }
}

//模具产品A类
class MouldProductA extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品A");
    }
}

//模具产品B类
class MouldProductB extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品B");
    }
}

步骤5:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

//A厂 - 生产模具+容器产品
class FactoryA extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductA();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductA();
    }
}

//B厂 - 生产模具+容器产品
class FactoryB extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductB();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductB();
    }
}

步骤6:客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例

//生产工作流程
public class AbstractFactoryPattern {
    public static void main(String[] args){
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.ManufactureContainer().Show();
        //A厂当地客户需要模具产品A
        mFactoryA.ManufactureMould().Show();

        //B厂当地客户需要容器产品B
        mFactoryB.ManufactureContainer().Show();
        //B厂当地客户需要模具产品B
        mFactoryB.ManufactureMould().Show();

    }
}

结果:

生产出了容器产品A
生产出了容器产品B
生产出了模具产品A
生产出了模具产品B

4.4 抽象工厂模式优缺点

优点:

  • 降低耦合
    抽象工厂模式将具体产品的创建延迟到具体工厂的子类中,这样将对象的创建封装起来,可以减少客户端与具体产品类之间的依赖,从而使系统耦合度低,这样更有利于后期的维护和扩展;

  • 更符合开-闭原则
    新增一种产品类时,只需要增加相应的具体产品类和相应的工厂子类即可
    简单工厂模式需要修改工厂类的判断逻辑

  • 符合单一职责原则
    每个具体工厂类只负责创建对应的产品
    简单工厂中的工厂类存在复杂的switch逻辑判断

  • 不使用静态工厂方法,可以形成基于继承的等级结构。
    简单工厂模式的工厂类使用静态工厂方法

缺点:

  • 抽象工厂模式很难支持新种类产品的变化。

这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了“开发——封闭”原则。

对于新的产品族符合开-闭原则;对于新的产品种类不符合开-闭原则,这一特性称为开-闭原则的倾斜性。

4.5 抽象工厂模式应用场景

在了解了优缺点后,我总结了工厂方法模式的应用场景:

  • 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达,这点也是所有工厂模式应用的前提。
  • 这个系统有多个系列产品,而系统中只消费其中某一系列产品
  • 系统要求提供一个产品类的库,所有产品以同样的接口出现,客户端不需要依赖具体实现。

5 工厂模式的常见问题

利用父类的向下转型(使用父类类型的引用指向子类的对象)是可以达到类似于工厂模式的效果的,那为什么还要用工厂模式呢?

把指向子类对象的父类引用赋给子类引用叫做向下转型,如:

Class Student extends Person     
Person s = new Student();    
s = (Student)person ;

使用向下转型在客户端实例化子类的时候,严重依赖具体的子类的名字。当我们需要更改子类的构造方法的时候,比如增加一个参数,或者更改了子类的类名,所有的new出来的子类都需要跟着更改。

但如果我们使用工厂模式,我们仅仅需要在工厂中修改一下new的代码,其余项目中用到此实例的都会跟着改,而不需要我们手动去操作。(???)

6 参考文献

更新时间:2020-08-28 16:41:12

本文由 清水河恶霸 创作,如果您觉得本文不错,请随意赞赏
采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名
原文链接:http://ql.magic-seven.top/2020/08/27/设计模式系列11工厂模式.html
最后更新:2020-08-28 16:41:12

评论

Your browser is out of date!

Update your browser to view this website correctly. Update my browser now

×