对工厂模式一次感悟

这篇具有很好参考价值的文章主要介绍了对工厂模式一次感悟。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

从开始接触设计模式的“什么都可以用设计模式去设计”,到接触一段时间之后的“用什么设计模式,直接莽就是了”。一直到现在,对设计模式的认知一直都处在一个模糊的状态。之前虽然也自己尝试在项目中使用一些设计模式,但总是体会不到设计模式在实际使用中的好处,直到最近,接触到了一种业务场景,非常适合使用工厂模式去实现的业务场景,着实耐不住心中的激动,一定要记录下来。。。

之前对工厂设计模式的认知一直是:这不就是简单的i根据不同的f--else的分支,创建不同的实现类嘛,如果需要扩展,根据不同的情况再去扩展不同的实现类而已嘛,这有什么难的嘛...,想来,这样的理解倒也不能说错,只是感觉非常的假大空。

接下来 我们从业务角度出发,设身处地的去感受使用设计模式和不使用设计模式的区别。

假设:我们的业务场景如下

/**
     * 既定业务场景:
     * 前情提要:
     *  我们需要做一个文件上传解析的功能,假设现在文件已经上传上来,我们需要对数据进行解析,将数据拆解
     *  
     * 需求:
     *  假设是一个目录结构,按照章节的不同,我们总共分为700章,每一章的目录结构层级都不相同。
     *  例200章如下所示:
     *      名称:200章-架构-思想-设计模式-工厂模式
     *      code:200-JG-SX-SJMS-GCMS
     *  例100章如下所示:
     *      名称:100章-技术-C#-委托
     *      code:100-JS-C#-Delegate
     *      
     *  假设用户上传的时候,只会传进来Code,我们需要根据Code获取到章节、类别。
     *  现知道规则如下:
     *      1.所有的章节code,第一个字符为章节
     *      2.200章倒数第二,第三位为类别,100章倒数第三位为类别。
     */

我们现在只有一百章和二百章的数据结构和处理规则,但是领导说,我们这个东西,肯定是要把所有的章节都进行处理的。我们先来看一下不使用设计模式的处理方式

 1  List<string> codeList = new List<string>();
 2             codeList.Add("200-JG-SX-SJMS-GCMS");
 3             codeList.Add("100-JS-C#-Delegate");
 4             foreach (var code in codeList)
 5             {
 6                 string Chapter = code.Split('-')[0];
 7                 if (Chapter.Equals("100"))
 8                 {
 9                     string chapter100 = code.Split('-')[0];
10                     string Type100 = code.Split('-')[1];
11                     Console.WriteLine($"code:{code},章节:{chapter100},类型:{Type100}");
12                 }
13                 else if (Chapter.Equals("200"))
14                 {
15                     string chapter400 = code.Split('-')[0];
16                     string Type400 = $"{code.Split('-')[2]}-{code.Split('-')[3]}";
17                     Console.WriteLine($"code:{code},章节:{chapter400},类型:{Type400}");
18                 }
19             }

处理思路是先循环集合,然后拆出来章节。根据章节去选择不同的分支。假设我们再有不同的章节,再添加elseIf就可以了。这个例子处理比较简单,代码看起来也不是很乱,但是如果我们的每一个章节的处理逻辑都比较复杂的时候,代码会乱成一团,首先不美观,其次。我们如果要新增不同的分支,在原有代码上再加分支,分支变多以后,代码会变得很长,别人会难以理解。好处是代码结构清晰,便于理解

如果我使用工厂模式去创建:

    public interface Idisassemble
    {
        /**
         * 拆解的接口,包含拆解的基本方法,包含获取章节和类别
         */


        string GetChapter(string code);

        string GetType(string code);

    }

    /// <summary>
    /// 100章截取工厂
    /// </summary>
    public class DisassembleOneChapter : Idisassemble
    {
        public string GetChapter(string code)
        {
            string Chapter= code.Split('-')[0];
            return Chapter;
        }

        public string GetType(string code)
        {
            string Chapter = code.Split('-')[1];
            return Chapter;
        }
    }

    /// <summary>
    /// 400章的截取工厂
    /// </summary>
    public class DisassembleTwoChapter : Idisassemble
    {
        public string GetChapter(string code)
        {
            string Chapter = code.Split('-')[0];
            return Chapter;
        }

        public string GetType(string code)
        {
            string [] codeList= code.Split('-');
            string Chapter = $"{codeList[2]}-{codeList[3]}";
            return Chapter;
        }
    }


    public static class BuildFactory 
    {

        public static Idisassemble Build(string code)
        {
            Idisassemble idisassemble = null;

            string Chapter = code.Split('-')[0];
            switch (Chapter)
            {
                case "100":
                    idisassemble = new DisassembleOneChapter();

                    break;

                case "200":
                    idisassemble = new DisassembleTwoChapter();

                    break;
                default:
                    break;
            }

            return idisassemble;
        }
    }

使用方式:

static void Main(string[] args)
        {
            List<string> codeList = new List<string>();
            codeList.Add("200-JG-SX-SJMS-GCMS");
            codeList.Add("100-JS-C#-Delegate");


           
            foreach (var code in codeList)
            {
                Idisassemble idisassemble = BuildFactory.Build(code);
                Console.WriteLine($"code:{code},章节:{idisassemble.GetChapter(code)},类型:{idisassemble.GetType(code)}");
            }
           

            

            Console.ReadLine();
        }

首先工厂模式的好处是:我可以用一个通用的接口,根据业务的不同,选择不同的实现方式,这样我们不会将所有的实现都在一个方法中实现,不会出现很长的代码段。

我们基于这样的一个思路去实现,首先我们需要设计一个接口,这个接口囊括了所有的处理抽象

 public interface Idisassemble
    {
        /**
         * 拆解的接口,包含拆解的基本方法,包含获取章节和类别
         */


        string GetChapter(string code);

        string GetType(string code);

    }

有了这个接口以后,我们需要根据他不同的业务类型创建不同的工厂实例,分析我们的业务中目前有一百章和两百章两种不同的实现分支。所以我们对应的有一百章和两百章两个不同的实现工厂。

/// <summary>
    /// 100章截取工厂
    /// </summary>
    public class DisassembleOneChapter : Idisassemble
    {
        public string GetChapter(string code)
        {
            string Chapter= code.Split('-')[0];
            return Chapter;
        }

        public string GetType(string code)
        {
            string Chapter = code.Split('-')[1];
            return Chapter;
        }
    }

    /// <summary>
    /// 400章的截取工厂
    /// </summary>
    public class DisassembleTwoChapter : Idisassemble
    {
        public string GetChapter(string code)
        {
            string Chapter = code.Split('-')[0];
            return Chapter;
        }

        public string GetType(string code)
        {
            string [] codeList= code.Split('-');
            string Chapter = $"{codeList[2]}-{codeList[3]}";
            return Chapter;
        }
    }

 

我们这两个实现工厂继承接口,并且实现自己的逻辑。到目前为止,我们的抽象和工厂实现都有了,有了这个工厂以后,我们就可以根据不同的业务用多态的方式去调用不同的工厂了。我们考虑一个问题,调用不同的工厂可以由使用者去自行判断,是不是也可以由我们的程序自己去判断出来?,由我们的程序自己判断出来的话,我们是不是可以使用策略模式的思想去实现?

到这里,我们引入一个新的概念,策略模式,策略模式是在程序运行时去判断我到底需要走哪个分支。

基于这个思想,我们是不是可以有一个创建具体工厂的策略管理类?

public static class BuildFactory 
    {

        public static Idisassemble Build(string code)
        {
            Idisassemble idisassemble = null;

            string Chapter = code.Split('-')[0];
            switch (Chapter)
            {
                case "100":
                    idisassemble = new DisassembleOneChapter();

                    break;

                case "200":
                    idisassemble = new DisassembleTwoChapter();

                    break;
                default:
                    break;
            }

            return idisassemble;
        }
    }

这个类我们需要知道用户输入什么,根据用户的不同输入,解析出来不同的分支,创建不同的实现工厂。但是我们在实际业务用的时候,最终使用的是工厂类中的某一个方法。所以,我们这个类只能是返回接口,而不是具体的实现工厂。我们在当前这个假定的业务中,可以根据code拆分出来具体使用哪个工厂。实际业务中可能会更复杂。

有了这个策略创建类。我们的具体使用就比较简单了。我们只需要调用策略构建类,传入code就可以了

static void Main(string[] args)
        {
            List<string> codeList = new List<string>();
            codeList.Add("200-JG-SX-SJMS-GCMS");
            codeList.Add("100-JS-C#-Delegate");


           
            foreach (var code in codeList)
            {
                Idisassemble idisassemble = BuildFactory.Build(code);
                Console.WriteLine($"code:{code},章节:{idisassemble.GetChapter(code)},类型:{idisassemble.GetType(code)}");
            }
           

            

            Console.ReadLine();
        }

到目前,我们的工厂创建已经完成了,但是,我们观察这两个工厂,它里面的获取章节的方法是重复的。业务简单抄一份倒也无所谓,但是如果业务复杂,抄一份的工作量还是很大的,而且从设计的角度来看,我们所有重复的,都可以抽出来。

 如果我们继承接口的不再直接是具体的工厂,而是一个可重写的虚实体,将通用的方法写在这个虚实体里边,不一样的方法再具体的工厂里边具体实现。

public interface Idisassemble
    {
        /**
         * 拆解的接口,包含拆解的基本方法,包含获取章节和类别
         */


        string GetChapter(string code);

        string GetType(string code);

    }


    public abstract class DisassembleAbtract : Idisassemble
    {
        public string GetChapter(string code)
        {
            string Chapter = code.Split('-')[0];
            return Chapter;
        }

        public abstract string GetType(string code);
    }

    /// <summary>
    /// 100章截取工厂
    /// </summary>
    public class DisassembleOneChapter : DisassembleAbtract
    {
        //public string GetChapter(string code)
        //{
        //    string Chapter= code.Split('-')[0];
        //    return Chapter;
        //}

        public override string GetType(string code)
        {
            string Chapter = code.Split('-')[1];
            return Chapter;
        }
    }

    /// <summary>
    /// 400章的截取工厂
    /// </summary>
    public class DisassembleTwoChapter : DisassembleAbtract
    {
        //public string GetChapter(string code)
        //{
        //    string Chapter = code.Split('-')[0];
        //    return Chapter;
        //}

        public override string GetType(string code)
        {
            string [] codeList= code.Split('-');
            string Chapter = $"{codeList[2]}-{codeList[3]}";
            return Chapter;
        }
    }

封装,继承,多态,虚方法。。。👍文章来源地址https://www.toymoban.com/news/detail-440881.html

到了这里,关于对工厂模式一次感悟的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java基础:简单工厂模式、工厂方法模式和抽象工厂模式综合概述

    简单工厂模式、工厂方法模式和抽象工厂模式是面向对象设计中用来实现对象创建灵活性的三种不同形式的工厂模式。它们各自有其特点、适用场景及优缺点。以下是它们之间的区别以及对应的适用场景,以及示例说明: 简单工厂模式 定义 : 简单工厂模式提供一个静态方法

    2024年04月25日
    浏览(35)
  • 设计模式(二)、工厂模式--简单工厂模式

    简单工厂模式:又叫做静态工厂方法模式,是由一个工厂对象决定创建出哪一种产品类的实例。 需要注意的是:简单工厂模式属于创建型模式,但不属于23种GOF设计模式之一  该模式主要有以下几个模块构成: 具体说明结合代码,如下: 代码中主要是有一个cake接父类,两个

    2024年02月13日
    浏览(50)
  • 设计模式(二)、工厂模式--工厂方法模式

    工厂方法模式是一种常用的创建型设计模式。它解决了简单工厂模式的问题:如违反了开闭原则,其次可以用于更复杂的结构 它的核心结构有四个角色  抽象工厂;具体工厂;抽象产品;具体产品 抽象工厂(抽象类或接口)不在负责具体的创建过程,即具体的代码实现。只制定

    2024年02月16日
    浏览(38)
  • 工厂模式之工厂方法模式

    大家好,欢迎来到程序视点! 在上一节的简单工厂模式中,我们知道简单工厂所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。 也就是说,类的创建依赖工厂类,如果想要拓展程序(添加新的类),必须对工厂类进行修改。这违背了开闭原则

    2024年02月08日
    浏览(38)
  • 【设计模式】单例模式、工厂方法模式、抽象工厂模式

    1. 单例模式 (Singleton Pattern): 场景: 在一个应用程序中,需要一个全局唯一的配置管理器,确保配置信息只有一个实例。 2. 工厂方法模式 (Factory Method Pattern): 场景: 创建一组具有相似功能但具体实现不同的日志记录器。 3. 抽象工厂模式 (Abstract Factory Pattern): 场景: 创建不同

    2024年01月15日
    浏览(61)
  • 工厂模式和抽象工厂模式的异同

    工厂模式(Factory Pattern)和抽象工厂模式(Abstract Factory Pattern)都是创建型设计模式,用于创建对象。它们有一些相似之处,但也有一些重要的区别。 相同之处: 创建对象:工厂模式和抽象工厂模式都用于创建对象,将对象的实例化过程从客户端代码中解耦。 抽象接口:两

    2024年02月13日
    浏览(42)
  • 设计模式-简单工厂模式(静态工厂模式)java实现

    简单工厂模式根据所 提供的参数 数据返回几个可能类中的一个类的实例。通常返回的类都有一个公共的父类和公共的方法。   意图 提供一个类,负责根据一定的条件创建某一具体类的实例。同时使用工厂模式也是为了隐藏创建对象的过程 角色及其职责 (1)工厂(Creator)角色

    2024年02月13日
    浏览(53)
  • JavaScript设计模式(二)——简单工厂模式、抽象工厂模式、建造者模式

    个人简介 👀 个人主页: 前端杂货铺 🙋‍♂️ 学习方向: 主攻前端方向,正逐渐往全干发展 📃 个人状态: 研发工程师,现效力于中国工业软件事业 🚀 人生格言: 积跬步至千里,积小流成江海 🥇 推荐学习:🍍前端面试宝典 🍉Vue2 🍋Vue3 🍓Vue2/3项目实战 🥝Node.js🍒

    2024年02月10日
    浏览(47)
  • 结构型设计模式-单例模式/工厂模式/抽象工厂

    创建型设计模式-单例模式/工厂模式/抽象工厂 行为型设计模式:模板设计模式/观察者设计模式/策略设计模式 C#反射机制实现开闭原则的简单工厂模式 设计模式可以分为三种类型: 创建型设计模式、结构型设计模式和行为型设计模式 。 创建型设计模式:这些模式涉及到 对

    2024年02月11日
    浏览(53)
  • 反射和工厂设计模式---工厂设计模式

    工厂模式(Factory Pattern)是开发中比较常用的设计模式之一。 它属于创建型模式(单例模式就是创建型模式的一种),这种模式让我们 在创建对象时不会直接暴露创建逻辑,而是通过使用一个共同的接口来完成对象的创建 。 工厂模式可以分为三种,分别是简单工厂模式、工厂方

    2024年02月13日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包