02. 工厂设计模式

蔚落 2022-11-06 01:53 130阅读 0赞

### 工厂模式 ###

*  一、工厂方法模式（Factory method pattern）
 *   *  1. 概念
     *  2. 案例
     *  3. 实现代码
     *  4.工厂方法模式优缺点
     *  5. 变种
     *   *  5.1 工厂方法
         *  5.2 简单工厂
 *  二、抽象工厂模式（Abstract factory pattern）
 *   *  1. 概念
     *  2. 实现类图
     *   *  2.1 案例
         *  2.2 类图
     *  3. 实现代码
 *  三、结束

# 一、工厂方法模式（Factory method pattern） #

## 1. 概念 ##

创建一个对象常常需要复杂的过程，这些过程不适合包含在一个复合对象中。创建对象可能会导致大量的重复代码，可能会用到复合对象所访问不到的信息，工厂方法模式通过定义一个单独的创建对象的方法来解决这些问题。  
工厂方法模式（Factory method pattern）又称 虚拟构造函数（Virtual Constructor），是一种实现了“工厂”概念的面向对象设计模式。  
像其他[创建型模式][Link 1]一样，它也是处理在不指定对象具体类型的情况下创建对象的问题。它的实质就是：“定义一个创建对象的接口（接口或抽象类），但让实现了这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。” 说的白话一点就是，在父类中提供创建对象的方法，子类通过重写这个方法决定创建哪种类型的对象。

> 复合对象：是指对象的一个或者多个属性引用了其他对象。

## 2. 案例 ##

以下示例演示了如何使用工厂方法开发跨平台 UI （用户界面） 组件， 并同时避免客户代码与具体 UI 类之间的耦合。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RmZ2dmZmRk_size_16_color_FFFFFF_t_70]  
基础对话框类使用不同的 UI 组件渲染窗口。 在不同的平台下， 这些组件外观或许略有不同， 但其功能保持一致。 Windows 平台中的按钮在 Web 平台中仍然是按钮。

如果使用工厂方法， 就不需要为每种平台重写对话框逻辑。 我们只要在一个基本对话框类中声明创建按钮的工厂方法， 然后创建各平台对应的对话框子类，子类将继承对话框基础类的大部分代码, 并通过工厂方法返回对应平台样式按钮。

如需该模式正常工作， 基础对话框类必须使用抽象按钮 （例如基类或接口）， 以便将其扩展为具体按钮。 这样一来， 无论对话框中使用何种类型的按钮， 其代码都可以正常工作。

## 3. 实现代码 ##

本例中， 按钮担任产品的角色， 对话框担任创建者的角色。

不同类型的对话框需要其各自类型的元素。 因此我们可为每个对话框类型创建子类并重写其工厂方法。

现在， 每种对话框类型都将对合适的按钮类进行初始化。 对话框基类使用其通用接口与对象进行交互， 因此代码更改后仍能正常工作。

通用产品接口 Button

/** * 基础产品类：通用产品接口 * @author alonso */
    public interface Button { 
        /** * 渲染按钮 */
        void render();
    
        /** * 触发点击事件 */
        void onClick();
    }

具体产品接口 WindowButton

/** * 具体产品类 * @author alonso */
    public class WindowButton implements Button { 
        @Override
        public void render() { 
            System.out.println("<win_button>BUTTON</win_button>");
            onClick();
        }
    
        @Override
        public void onClick() { 
            System.out.println("Window Button Click.");
        }
    }

具体产品接口 WebButton

/** * 具体产品类 * @author alonso */
    public class WebButton implements Button { 
        @Override
        public void render() { 
            System.out.println("<web_button>BUTTON</web_button>");
            onClick();
        }
    
        @Override
        public void onClick() { 
            System.out.println("Web Button Click.");
        }
    }

基础创建者 Dialog

/** * 基础创建类（基础工厂类） * @author alonso */
    public abstract class Dialog { 
        public void renderDigLog() { 
            Button button = createButton();
            button.render();
        }
    
        /** * 工厂方法 * 子类将覆盖这个方法，以创建特定的按钮对象 * @return Button */
        public abstract Button createButton();
    }

具体创建者 WindowDialog

/** * Window具体创建者 * @author alonso */
    public class WindowDialog extends Dialog { 
        @Override
        public Button createButton() { 
            return new WindowButton();
        }
    }

具体创建者 WebDialog

/** * Web具体创建者 * @author alonso */
    public class WebDialog extends Dialog { 
        @Override
        public Button createButton() { 
            return new WebButton();
        }
    }

客户端测试 Client

package com.mobaii.study.blogpattern.factory;
    
    /** * 客户端代码 * @author alonso */
    public class Client { 
    
        private static Dialog dialog;
    
        public static void main(String[] args) { 
            configuration();
            runCode();
        }
    
        private static void configuration() { 
            String osName = System.getProperty("os.name");
            if ("Windows 10".equals(osName)) { 
                dialog = new WindowDialog();
            } else { 
                dialog = new WebDialog();
            }
        }
        private static void runCode() { 
            dialog.renderDigLog();
        }
    
    }

输出

<win_button>BUTTON</win_button>
    Window Button Click.

## 4.工厂方法模式优缺点 ##

优点：  
你可以避免创建者和具体产品之间的紧密耦合。  
单一职责原则。 你可以将产品创建代码放在程序的单一位置， 从而使得代码更容易维护。  
开闭原则。 无需更改现有客户端代码， 你就可以在程序中引入新的产品类型。

缺点：  
应用工厂方法模式需要引入许多新的子类， 代码可能会因此变得更复杂。 最好的情况是将该模式引入创建者类的现有层次结构中。

## 5. 变种 ##

### 5.1 工厂方法 ###

如果抛开设计模式的范畴，“工厂方法”这个词也可以指作为“工厂”的方法，这个方法的主要**目的就是创建对象，而这个方法不一定在单独的工厂类中**。这些方法通常作为静态方法，定义在方法所实例化的类中。  
很多编程语言中，构造方法必须和它所在的类具有相同的名称，这样的话，如果有多种创建对象的方式（重载）就可能导致歧义。工厂方法没有这种限制，所以可以具有描述性的名称。  
举个不太恰当的例子：ShapeGenerate 用不同的构造来初始化正方形和长方形，都是通过 new 构造函数的方式进行初始化，都不具有描述性，工厂方法没有这种限制，所以可以具有描述性的名称定义一个静态方法，如案例中的 initRectangle 方法。  
**当工厂方法起到这种消除歧义的作用时，构造方法常常被设置为私有方法。**

/** * @author alonso */
    public class ShapeGenerate { 
        /** * 高度 */
        private String lenght;
        /** * 宽度 */
        private String width;
    
        public ShapeGenerate() { }
    
        /** * 初始化长方形 * @param lenght 高度 * @param width 宽度 */
        public ShapeGenerate(String lenght, String width) { 
            this.lenght = lenght;
            this.width = width;
        }
    
        /** * 初始化正方形 * @param width 宽度 */
        public ShapeGenerate(String width) { 
            this.width = width;
        }
        
        /** * 更有描述性的方法，初始化长方形 * @param lenght 高度 * @param width 宽度 * @return */
        public static ShapeGenerate initRectangle(String lenght, String width) { 
            return new ShapeGenerate(lenght, width);
        }
    
        // getter/setter...
    
    }

### 5.2 简单工厂 ###

创建一个单一的工厂类,客户端代码根据参数的不同选择实现不同的具体对象。这个工厂类不需要由每个具体产品实现一个自己的具体的工厂类，所以可以将工厂方法设置为静态方法。 而且，工厂方法封装了对象的创建过程。如果创建过程非常复杂（比如依赖于配置文件或用户输入），工厂方法就非常有用了。 比如，一个程序要读取图像文件。程序支持多种图像格式，每种格式都有一个对应的ImageReader类用来读取图像。程序每次读取图像时，需要基于文件信息创建合适类型的ImageReader。这个选择逻辑可以包装在一个简单工厂中：

public class ImageReaderFactory { 
        public static ImageReader imageReaderFactoryMethod(InputStream is) { 
            ImageReader product = null;
    
            int imageType = determineImageType(is);
            switch (imageType) { 
                case ImageReaderFactory.GIF:
                    product = new GifReader(is);
                case ImageReaderFactory.JPEG:
                    product = new JpegReader(is);
                //...
            }
            return product;
        }
    }

看完后是不是觉得有点像 **3.实现代码** 中 Client 类中的 configuration 方法，根据条件参数来选择实现不同的具体对象。所以我们要根据实际情况灵活的搭配使用，简单工厂固然方便，但如果想要扩展，则必须添加条件。如果产品增加比较频繁，不建议使用 简单工厂 这种方式。

# 二、抽象工厂模式（Abstract factory pattern） #

## 1. 概念 ##

抽象工厂模式提供了一种方式，可以**将一组具有同一主题的单独的工厂封装起来**。在正常使用中，**客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为接口来创建这一主题的具体对象**。客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，因为客户端程序仅使用这些对象的通用接口。

## 2. 实现类图 ##

### 2.1 案例 ###

比如一个抽象工厂类叫做DocumentCreator（文档创建器），此类提供创建若干种产品的接口，包括createLetter()（创建信件）和createResume()（创建简历）。其中，createLetter()返回一个Letter（信件），createResume()返回一个Resume（简历）。系统中还有一些DocumentCreator的具体实现类，包括FancyDocumentCreator和ModernDocumentCreator。这两个类对DocumentCreator的两个方法分别有不同的实现，用来创建不同的“信件”和“简历”（用FancyDocumentCreator的实例可以创建FancyLetter和FancyResume，用ModernDocumentCreator的实例可以创建ModernLetter和ModernResume）。这些具体的“信件”和“简历”类均继承自抽象类，即Letter和Resume类。客户端需要创建“信件”或“简历”时，先要得到一个合适的DocumentCreator实例，然后调用它的方法。一个工厂中创建的每个对象都是同一个主题的（“fancy”或者“modern”）。客户端程序只需要知道得到的对象是“信件”或者“简历”，而不需要知道具体的主题，因此客户端程序从抽象工厂DocumentCreator中得到了Letter或Resume类的引用，而不是具体类的对象引用。

### 2.2 类图 ###

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

## 3. 实现代码 ##

1.  创建Letter接口

/** * @author alonso */
    public interface Letter { 
        void read();
    }

1.  为Resume创建接口

/** * @author alonso */
    public interface Resume { 
        void write();
    }

1.  创建FancyLetter

/** * @author alonso */
    public class FancyLetter implements Letter { 
    
        @Override
        public void read() { 
            System.out.println("FancyLetter.");
        }
    }

1.  创建FancyResume

/** * @author alonso */
    public class FancyResume implements Resume { 
    
        @Override
        public void write() { 
            System.out.println("FancyResume.");
        }
    }

1.  创建ModernLetter类

/** * @author alonso */
    public class ModernLetter implements Letter { 
    
        @Override
        public void read() { 
            System.out.println("ModernLetter.");
        }
    }

1.  创建ModernResume类

/** * @author alonso */
    public class ModernResume implements Resume { 
    
        @Override
        public void write() { 
            System.out.println("ModernResume.");
        }
    }

1.  创建DocumentCreator接口

/** * @author alonso */
    public interface DocumentCreatorFacatory { 
        /** * 创建信件方法 * @return */
        Letter createLetter();
    
        /** * 创建简历 * @return */
        Resume createResume();
    }

1.  创建FancyDocumentCreator类

/** * @author alonso */
    public class FancyDocumentCreator implements DocumentCreatorFacatory { 
        @Override
        public Letter createLetter() { 
            return new FancyLetter();
        }
        @Override
        public Resume createResume() { 
            return new FancyResume();
        }
    }

1.  创建ModernDocumentCreator类

/** * @author alonso */
    public class ModernDocumentCreator implements DocumentCreatorFacatory { 
        @Override
        public Letter createLetter() { 
            return new ModernLetter();
        }
        @Override
        public Resume createResume() { 
            return new ModernResume();
        }
    }

1.  创建DocumentCreatorTest类

/** * @author alonso */
    public class DocumentCreatorTest { 
        public static void main(String[] args) { 
            DocumentCreatorFacatory fancyDocumentCreator = new FancyDocumentCreator();
            Letter letter = fancyDocumentCreator.createLetter();
            Resume resume = fancyDocumentCreator.createResume();
            resume.write();
            letter.read();
            ModernDocumentCreator modernDocumentCreator = new ModernDocumentCreator();
            Letter letter1 = modernDocumentCreator.createLetter();
            Resume resume1 = modernDocumentCreator.createResume();
            resume1.write();
            letter1.read();
        }
    }

1.  输出结果

FancyResume.
    FancyLetter.
    ModernResume.
    ModernLetter.

抽象工厂模式适用于有多个产品族和产品类型的场景下，如以上的信件（Letter）和简历（Resume）可视为产品族，喜爱的（Fancy）和最近的（Modern）可视为类型，参考图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RmZ2dmZmRk_size_16_color_FFFFFF_t_70 2]  
按照以上案例，如果后续需要添加获取讨厌的（Sick）信件，讨厌的（Sick）简历 等功能，只需要对于的扩展 SickLetter 和 SickDocumentCreator 类即可，但是如果需要添加一个产品，则需要修改 DocumentCreatorFactory 及其实现类，违反开闭原则，所以抽象工厂只适用于产品不经常变动的场景。

# 三、结束 #

工厂模式非常灵活，它应作为我们在开发时调优代码的一种解决方案，而不是在看了几段相关的代码就开始生搬硬套近自己的代码中。  
如果多看一些相关的博客及教程，就会发现每个人说的写的多多少少都会有一些不同，但到最后表达的意思大致都是一致的，当你不再迷茫为什么这个博客这么写、那个文档那么说的时候，你就掌握它了。

[Link 1]: https://blog.csdn.net/dfggffdd/article/details/114482784
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RmZ2dmZmRk_size_16_color_FFFFFF_t_70]: /images/20221023/de8158df7e06479bb1499ba7290b3c31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RmZ2dmZmRk_size_16_color_FFFFFF_t_70 1]: /images/20221023/16d34f25e14841828b25215620b0e671.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RmZ2dmZmRk_size_16_color_FFFFFF_t_70 2]: /images/20221023/9659072142d645afbc08bc319923f2b6.png