对工厂模式一次感悟

标签：感悟 Chapter code string 模式工厂 codeList Split public

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

之前对工厂设计模式的认知一直是：这不就是简单的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;
        }
    }

封装，继承，多态，虚方法。。。

标签：感悟,Chapter,code,string,模式,工厂,codeList,Split,public
From： https://www.cnblogs.com/Xiaomoml/p/17392224.html

相关文章

赞助商

阅读排行