上帝视角俯视工厂设计模式

news2024/10/6 12:30:15
引言

本篇聊聊设计模式中的简单工厂、工厂方法、抽象工厂设计模式，争取在看完这篇后不会再傻傻分不清以及能够应用在实际项目中

背景

以一个咱们都熟悉的场景举个例子，我们平时都会戴口罩，用来过滤一些普通病毒，大致的设计如下图，每当有一个新的用户需要用到口罩时，都自己new一个普通口罩
在这里插入图片描述

那么现在新冠来了，经过研究发现N95口罩可以更好的抵御新冠，那么要怎么改呢，大致设计如下图
在这里插入图片描述

就是对每一个使用普通口罩的用户改为N95口罩。假设这里的用户很多有上百个，那对应到代码就是我们要去上百个地方进行代码改动，这个改动成本以及风险都是比较大的，如果后续又有效果更好的口罩呢，是不是这么一想就觉得头都大了，这些问题也是切切实实的发生在我们的工作中。以下是以Java实现的案例

对应的普通口罩实现

public class Main {
    public static void main(String[] args) {
        CommonFaceMask commonFaceMask1 = new CommonFaceMask();
        commonFaceMask1.filterViruses();

        CommonFaceMask commonFaceMask2 = new CommonFaceMask();
        commonFaceMask2.filterViruses();

        CommonFaceMask commonFaceMask3 = new CommonFaceMask();
        commonFaceMask3.filterViruses();
    }
}

class CommonFaceMask {
    public CommonFaceMask() {
        System.out.println("创建了一个新的口罩");
    }

    public void filterViruses() {
        System.out.println("过滤普通的病毒");
    }
}

对应的N95口罩实现

public class Main {
    public static void main(String[] args) {
        //CommonFaceMask commonFaceMask1 = new CommonFaceMask();
        N95FaceMask commonFaceMask1 = new N95FaceMask();
        commonFaceMask1.filterViruses();

        //CommonFaceMask commonFaceMask2 = new CommonFaceMask();
        N95FaceMask commonFaceMask2 = new N95FaceMask();
        commonFaceMask2.filterViruses();

        //CommonFaceMask commonFaceMask3 = new CommonFaceMask();
        N95FaceMask commonFaceMask3 = new N95FaceMask();
        commonFaceMask3.filterViruses();
    }
}

class N95FaceMask {
    public N95FaceMask() {
        System.out.println("创建了一个新的N95口罩");
    }

    public void filterViruses() {
        System.out.println("过滤新冠病毒");
    }
}

通过上述代码能够清晰的感知到，所有类似的变动可能会导致大幅的代码适配工作；但是别担心，让我们来看看三个不同的工厂模式分别是怎么解决这个问题的

简单工厂

通过思考我们能够发现，之所以会有这么大的改动是因为用户跟口罩之间是强依赖关系，口罩的变动会影响到每一个用户，解决强依赖的方式是什么？本质上都是通过在中间层加入一个代理也就是今天咱们要讨论的“工厂”，引入后的图如下
在这里插入图片描述

由上图能够清晰的看到用户不再依赖具体的口罩类型，只需要由工厂统一返回即可，工厂返回什么类型的口罩用户不关心，用户只需要按照口罩的“使用方式”来使用即可，这样如果口罩类型有变动，只需要通知这家工厂即可，无需影响到用户(本身也不需要)。

因此我们可知，在设计程序时我们不该面向实现细节，应该面向抽象，例如用口罩的时候其实我们关心的不是口罩是怎么制作、什么牌子的，只关心它能不能过滤病毒、细菌对吧？因此我们提炼抽象出一个口罩接口(也就是口罩的“使用方式”)，这个接口有一个filterViruses方法就是过滤病毒，所有口罩都要实现这个接口并实现改方法

public interface FaceMask {
    void filterViruses();
}

class N95FaceMask implements FaceMask {
    public N95FaceMask() {
        System.out.println("创建了一个新的N95口罩");
    }

    public void filterViruses() {
        System.out.println("过滤新冠病毒");
    }
}

class CommonFaceMask implements FaceMask {
    public CommonFaceMask() {
        System.out.println("创建了一个新的普通口罩");
    }

    public void filterViruses() {
        System.out.println("过滤普通的普通病毒");
    }
}

接下来看看工厂类的实现

public class FaceMaskFactory {
    //在某些场景就是要跟口罩的型号绑定，那么也可以通过指定口罩的名称来进行获取
    public FaceMask createFaceMask(String faceMaskName) {
        switch (faceMaskName) {
            case "Common":
                return new CommonFaceMask();
            case "N95":
                return new N95FaceMask();
            default:
                return new CommonFaceMask();
        }
    }

  	//这里根据读取配置动态决定，这里为了演示先硬编码为 N95
    public FaceMask createFaceMask() {
        String faceMaskName = "N95";
        switch (faceMaskName) {
            case "Common":
                return new CommonFaceMask();
            case "N95":
                return new N95FaceMask();
            default:
                return new CommonFaceMask();
        }
    }
}

再来看看具体使用方式

public class Main {
    public static void main(String[] args) {
        FaceMaskFactory faceMaskFactory = new FaceMaskFactory();

        FaceMask faceMask1 = faceMaskFactory.createFaceMask();
        faceMask1.filterViruses();

        FaceMask faceMask2 = faceMaskFactory.createFaceMask();
        faceMask2.filterViruses();

        FaceMask faceMask3 = faceMaskFactory.createFaceMask();
        faceMask3.filterViruses();
    }
}

以上就是简单工厂模式的实现，它实现了对象创建和使用的职责分离，或者说将对象创建的权力收敛到工厂类里面了。客户端不知道也不需要知道所获取的对象是怎么创建的以及怎么初始化的，只需要按照对象的接口规范进行使用即可，这个场景非常广泛，例如我们无需关心灯泡是什么品牌多少瓦，只要能按照规范拧进灯座就能亮，不需要知道汽车的发动机是怎么制造汽车是怎么设计只需要按照规范踩动油门汽车就能行驶等等

通过结合配置文件的方式，即便要替换新的口罩类型，可以在不修改客户端代码的情况下实现同时也在一定程度上提高了系统的灵活性，这也是工作中会经常用到的。除此之外通过工厂模式可以很好的进行监控以及管理对象。缺点是在产品类型比较多或者有些产品的创建/初始化逻辑比较多，可能会造成工厂逻辑过于复杂，不利于系统的拓展维护，为了解决这个问题出了工厂方法模式

痛点：简单工厂模式虽然实现简单理解简单且很好解耦了客户端跟对象的关系，但它将过多的逻辑集中在一个工厂类里，当这些逻辑扩张时，这个工厂类会变得很臃肿且难以维护，另一方面，在涉及到新建对象逻辑变动时会频繁的改动这里的代码，一旦出了问题影响的范围会很广泛

工厂方法

接下来看看工厂方法的实现，既然简单工厂方法的瓶颈在工厂类，那么对它进行抽象下，定义一个工厂接口，只负责工厂的定义，具体工厂的实现逻辑延迟到子类。这样本质上将一家工厂改为按业务划分为多家工厂，通过工厂接口定义了工厂生产什么，工厂实现类再做具体的实现逻辑
在这里插入图片描述

通过这种方式避免了过多逻辑集中在一个工厂类中，而是针对产品类型纬度进行划分，不同的产品类型有自己的独立工厂，这样即便后续有新的产品也不会影响到普通工厂和N95工厂，只需增加新的工厂实现类即可

代码实现如下

public interface FaceMask {
    void filterViruses();
}

class N95FaceMask implements FaceMask {
    public N95FaceMask() {
        System.out.println("创建了一个新的N95口罩");
    }

    public void filterViruses() {
        System.out.println("过滤新冠病毒");
    }
}

class CommonFaceMask implements FaceMask {
    public CommonFaceMask() {
        System.out.println("创建了一个新的普通口罩");
    }

    public void filterViruses() {
        System.out.println("过滤普通的普通病毒");
    }
}

工厂类的实现

public interface IFactory {
     FaceMask createFaceMask();
}

class N95Factory implements IFactory {
    @Override
    public FaceMask createFaceMask() {
        return new N95FaceMask();
    }
}

class CommonFactory implements IFactory {

    @Override
    public FaceMask createFaceMask() {
        return new CommonFaceMask();
    }
}

使用方式

public class Main {
    public static void main(String[] args) {
        IFactory iFactory1 = new N95Factory();
        FaceMask faceMask1 = iFactory1.createFaceMask();
        faceMask1.filterViruses();
        FaceMask faceMask2 = iFactory1.createFaceMask();
        faceMask2.filterViruses();
        FaceMask faceMask3 = iFactory1.createFaceMask();
        faceMask3.filterViruses();

        IFactory iFactory2 = new CommonFactory();
        FaceMask faceMask4 = iFactory2.createFaceMask();
        faceMask4.filterViruses();
        FaceMask faceMask5 = iFactory2.createFaceMask();
        faceMask5.filterViruses();
        FaceMask faceMask6 = iFactory2.createFaceMask();
        faceMask6.filterViruses();
    }
}

通过这里能够清晰的看到，已经创建好的工厂逻辑不会再进行变动，如果有新的产品，只需要根据工厂接口定义的规范实现对应产品的工厂类即可。这样设计符合开闭原则，面向修改关闭，面向拓展开放。将原来集中在一个工厂类的臃肿逻辑拆分到多个“各司其职”的工厂实现类中，提升了可读性以及可维护性，并大幅降低了由于新的改动影响之前实现逻辑的情况

痛点：虽然工厂方法模式解决了简单工厂模式的臃肿以及相互影响的问题，但是每次有新的产品时不仅要创建对应的产品类，还要创建对应的产品工厂类，也会导致过多的产品工厂类，增加系统的复杂度

以上就是工厂方法设计模式，我们想想，如果现在不仅要生产口罩，还要生产其他的例如消毒酒精的话要如何实现呢，如果还是基于工厂方法设计模式的话可能要单独给酒精创建工厂并针对不同的酒精创建对应的工厂实现类，那有同学要问了，能否复用下工厂呢？是可以的这也是接下来要聊的抽象工厂模式

抽象工厂模式

通过上述我们可以发现每一个产品都会有对应的产品对象类以及对应的工厂类，久而久之可能会诞生过多的工厂类增加系统的复杂度。那能不能做下“合并”呢，可以从业务场景出发进行划分，例如这里就按规格进行划分，高规格的工厂负责生产N95口罩和75度的酒精，低规格的工厂负责生产普通口罩和60度的酒精。这样划分是不是跟我们生活中的工厂更相似、效率更高些？
在这里插入图片描述

代码实现如下，首先是创建口罩相关的接口以及实现类

public interface FaceMask {
    void filterViruses();
}

class N95FaceMask implements FaceMask {
    public N95FaceMask() {
        System.out.println("创建了一个新的N95口罩");
    }

    public void filterViruses() {
        System.out.println("过滤新冠病毒");
    }
}

class CommonFaceMask implements FaceMask {
    public CommonFaceMask() {
        System.out.println("创建了一个新的普通口罩");
    }

    public void filterViruses() {
        System.out.println("过滤普通的普通病毒");
    }
}

接着是创建酒精相关的接口以及实现类

public interface Alcohol {
    void disinfect();
}

class Alcohol60 implements Alcohol {

    public Alcohol60() {
        System.out.println("创建了一个60度的酒精");
    }

    @Override
    public void disinfect() {
        System.out.println("开始消毒，能杀死普通的病毒");
    }
}


class Alcohol75 implements Alcohol {

    public Alcohol75() {
        System.out.println("创建了一个75度的酒精");
    }

    @Override
    public void disinfect() {
        System.out.println("开始消毒，能杀死新冠的病毒");
    }
}

再接下来是创建工厂以及工厂实现类

public interface IFactory {
    FaceMask createFaceMask();
    Alcohol createAlcohol();
}

class LowLevelFactory implements IFactory {

    @Override
    public FaceMask createFaceMask() {
        return new CommonFaceMask();
    }

    @Override
    public Alcohol createAlcohol() {
        return new Alcohol60();
    }
}

class HighLevelFactory implements IFactory {

    @Override
    public FaceMask createFaceMask() {
        return new N95FaceMask();
    }

    @Override
    public Alcohol createAlcohol() {
        return new Alcohol75();
    }
}

最后看看使用场景

public class Main {
    public static void main(String[] args) {
        IFactory iFactory1 = new LowLevelFactory();
        FaceMask faceMask1 = iFactory1.createFaceMask();
        Alcohol alcohol1 = iFactory1.createAlcohol();
        faceMask1.filterViruses();
        alcohol1.disinfect();
        System.out.println("=================");
        IFactory iFactory2 = new HighLevelFactory();
        FaceMask faceMask2 = iFactory2.createFaceMask();
        Alcohol alcohol2 = iFactory2.createAlcohol();
        faceMask2.filterViruses();
        alcohol2.disinfect();
    }
}
总结

是不是回过神来好奇为啥原先的new方式变成了这么复杂的方式，让咱们捋一捋，首先咱们内心要切记一件事，就是每一个设计都是为了解决一个问题，把问题捋清楚了就不怕了。大致的梳理如下
在这里插入图片描述

大致的演变方式如上图，无需死记硬背，理解就好

相同点

三个工厂模式的共同点就是解耦客户端和对象的创建关系，通过引入工厂这么一个中介，产品的创建/初始化逻辑不必再强依赖客户端并这些逻辑分散在项目的各个地方，所有产品创建的变动都不会导致客户端的改动，工厂已经将这些逻辑统一管理起来了，因此基本上所有变动例如增加新的产品、产品实现变更等只需要跟工厂打交道即可。客户端只需要按照这个产品的规范来用即可，这样客户端就能专注于自己的业务逻辑，对象创建相关的就想给工厂统一管理。这个设计不就像极了生活中的用户、工厂、产品之间的角色吗

场景

平时开发代码中像一些存数据的对象以及逻辑简单且不容易变动的场景，使用new即可

创建的对象逻辑比较复杂且可能会涉及到变动的时候，例如数据持久化逻辑的对象，可能是写本地磁盘、数据库或者通过网络存储这种，最好用用简单工厂类进行统一管理

当场景涉及比较复杂时，例如数据有可能存myql、也有可能存oracle或其他，同时还有很多复杂的操作，此时就该进行划分，针对不同的存储引擎设计对应的工厂类，方便后期的扩展以及维护

抽象工厂设计模式相对少见，具体参考上面的实例结合实际的场景权衡使用的利弊

以上就是工厂设计模式的全部，建议读者全部都自己实现一遍找找“感觉”和差异，如果有追求的朋友可以读读这几种工厂实现的源码，这样会对它们有更深刻的理解，码字画图不易，觉得写的不错的朋友别忘了点个赞，感谢

参考资料

  1. https://xie.infoq.cn/article/88c926822394aa1c80847dd2a

  2. https://refactoringguru.cn/design-patterns/abstract-factory

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1359770.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

操作系统期末复习知识点

操作系统期末复习知识点

目录 一.概论 1.操作系统的介绍 2.特性 3.主要功能 4.作用 二.进程的描述与控制 1.进程的定义 2.特性 3.进程的创建步骤 4.基本状态转化 5.PCB的作用 6.进程与线程的比较 三.进程同步 1.同步的概念（挺重要的） 2.临界区 3.管程和进程的区…
阅读更多...
AI日报：大型律师事务所首次推出人工智能工具撰写合同

AI日报：大型律师事务所首次推出人工智能工具撰写合同

欢迎订阅专栏 《AI日报》 获取人工智能邻域最新资讯 总览 英国的Allen&Overy推出了一款可以为律师撰写合同的人工智能工具，名为ContractMatrix。 它利用现有的合同模板起草新的合同，律师可以接受或修改。 1000多名律师正在使用该工具。今年1月&…
阅读更多...
LeetCode(39)组合总和⭐⭐

LeetCode(39)组合总和⭐⭐

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。 candidates 中的 同一个 数字可以 无限制重复被选取 。如…
阅读更多...
史上最牛逼的fiddler抓包操作，【工具】Fiddler使用教程

史上最牛逼的fiddler抓包操作，【工具】Fiddler使用教程

eb调试工具之一， 它能记录所有客户端和服务器的http和https请求。允许你监视、设置断点、甚至修改输入输出数据。Fiddler包含了一个强大的基于事件脚本的子系统，并且能使用.net语言进行扩展。换言之，你对HTTP 协议越了解，你就能越…
阅读更多...
033 - STM32学习笔记 - TIM定时器（一） - 高级定时器

033 - STM32学习笔记 - TIM定时器（一） - 高级定时器

033 - STM32学习笔记 - TIM定时器（一） - 高级定时器 上节内容学习了基本定时器，其功能比较简单，配置和使用也比较容易，今天在基本定时器的基础上学习一下高级控制定时器的内容。 在F429上一共有两个高级控制定时器和1…
阅读更多...
给新手的25个建议

给新手的25个建议

前言 最近知乎上，有一位大佬邀请我回答下面这个问题，看到这个问题我百感交集，感触颇多。 在我是新人时，如果有前辈能够指导方向一下，分享一些踩坑经历，或许会让我少走很多弯路，节省更多的学习的…
阅读更多...
每日一道算法题day-three(备战蓝桥杯)

每日一道算法题day-three(备战蓝桥杯)

哈喽大家好，今天来给大家带来每日一道算法题系列第三天，让我们来看看今天的题目，一起备战蓝桥杯 题目： 小 Y的桌子上放着 n 个苹果从左到右排成一列，编号为从 11 到 n。 小苞是小 Y 的好朋友，每天她都会…
阅读更多...
设计模式篇---命令模式(结合spring+动态代理实现开闭)

设计模式篇---命令模式(结合spring+动态代理实现开闭)

文章目录 概念结构实例总结 概念 命令模式：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。 现实生活中，我们用开关来控制一些电器的打开和关闭&am…
阅读更多...
NLP电影情绪分析项目

NLP电影情绪分析项目

https://machinelearningmastery.com/develop-word-embedding-model-predicting-movie-review-sentiment/ https://machinelearningmastery.com/prepare-movie-review-data-sentiment-analysis/ 本教程分为 5 个部分;他们是： 电影评论数据集数据准备训练嵌入层训练…
阅读更多...
解决报错Exception encountered during context initialization

解决报错Exception encountered during context initialization

推荐阅读 智能化校园：深入探讨云端管理系统设计与实现（一） 智能化校园：深入探讨云端管理系统设计与实现（二） 文章目录 推荐阅读报错解决 报错 今天在测试一个类时，突然间报了以下错误。 juni…
阅读更多...
调用第三方接口遇到的13大坑

调用第三方接口遇到的13大坑

前言 在实际工作中，我们经常需要在项目中调用第三方API接口，获取数据，或者上报数据，进行数据交换和通信。 那么，调用第三方API接口会遇到哪些问题？如何解决这些问题呢？ 这篇文章就跟大家一起聊…
阅读更多...
详解bookkeeper AutoRecovery机制

详解bookkeeper AutoRecovery机制

引言小故事 张三在一家小型互联网公司上班，由于公司实行的996，因此经常有同事“不辞而别”，为了工作的正常推进，团队内达成了某种默契，这种默契就是通过某个规则来选出一个同事，这个同事除了工作之余还有额…
阅读更多...
大数据毕业设计：python房源数据爬虫分析预测系统+可视化 +商品房数据（源码+讲解视频）✅

大数据毕业设计：python房源数据爬虫分析预测系统+可视化 +商品房数据（源码+讲解视频）✅

毕业设计：2023-2024年计算机专业毕业设计选题汇总（建议收藏） 毕业设计：2023-2024年最新最全计算机专业毕设选题推荐汇总 🍅感兴趣的可以先收藏起来，点赞、关注不迷路，大家在毕设选题&#xff…
阅读更多...
【算法】链表每k个节点反转 （js）

【算法】链表每k个节点反转 （js）

牛客链接：https://www.nowcoder.com/practice/b49c3dc907814e9bbfa8437c251b028e?tpId196&&tqId37080&rp1&ru/ta/job-code-total&qru/ta/job-code-total/question-ranking 本人题解： 有点绕，好好理解 /** function Li…
阅读更多...
Layui弹窗带标签可切换图表的应用Demo

Layui弹窗带标签可切换图表的应用Demo

提供Layui弹窗带页签的Demo写法 文章目录 前言一、展示效果二、详细代码1.代码2.简单释义 总结 前言 之前因为有需求，需要开发Layui的弹出框，同时弹窗框需要支持，页签点击切换内容，特此整理了这一篇文章，提供给需要的…
阅读更多...
D-Link DES-108 交换机

D-Link DES-108 交换机

D-Link DES-108 交换机 1. 百兆交换机 8 口References ​ D-Link Corporation is a Taiwanese multinational networking equipment manufacturing corporation headquartered in Taipei, Taiwan. Taiwanese：adj. 台湾的 n. 台湾人 headquarter [hedkwɔ:tə]&#…
阅读更多...
普中STM32-PZ6806L开发板(有点悲伤的故事)

普中STM32-PZ6806L开发板(有点悲伤的故事)

简介 关于我使用 普中STM32-PZ6806L做了做了一些实验, 不小心输入12V，导致核心板等被烧坏, 为了利用电路和资源, 搭建了STM32F103CBT6并使用普中STM32-PZ6806L上面没有烧坏的模块的故事。 普中STM32-PZ6806L开发板 这块的STM32F103ZET6部分算是Closed了, 不准备换核…
阅读更多...
OpenCASCADE MFC例子

OpenCASCADE MFC例子

OpenCASCADE MFC例子 说明 一直对OpenCASCADE一直都比较感兴趣，这个例子是我参考这位大神C幼儿园中班小朋友的专栏做出来的OpenCASCADE_C幼儿园中班小朋友的博客-CSDN博客 不过我用的是vcpkg的方式安装OpenCASCADE，这个需要注意一下，可能需…
阅读更多...
VM与欧姆龙PLC通讯设置

VM与欧姆龙PLC通讯设置

1、欧姆龙PLC 进行网口通讯，协议用的Fins tcp，也可以用Fins UDP。 2、主要步骤如下； step1：设置IP地址、端口号默认是9600，根据需要设置寄存器首地址和寄存器数量 step2：鼠标移动到某个地址下&#xff0c…
阅读更多...
Spring国际化的应用及原理详解

Spring国际化的应用及原理详解

1. 简介 Spring国际化（Spring Internationalization，简称i18n）是Spring框架提供的一种机制，用于支持多语言的应用程序。它使得开发者能够轻松地在应用程序中实现不同语言的支持，从而满足全球化的需求。通过Spring国际…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023