设计模式 2/23 工厂模式 – Lionel Andrés Messi

工厂模式是最常用的设计模式之一,用好了,代码优雅,可维护性高,对系统设计会上一个台阶

为什么这么说,因为工厂模式可以牵扯出抽象工厂模式,也有大家都会聊到的简单工厂模式

我们要了解一点,23中设计模式中,不包含简单工厂模式,之所以大家会去聊这个,四个字,渐进明细

通过对简单工厂模式的了解,我们引入工厂这个词,不然一个写代码的,天天给他讲工厂,工厂,工厂,西厂,东厂,会晕

同时,通过逐步的深入,从简单工厂,到工厂模式,再到抽象工厂,渐进明细的过程,逐步深入的理解,比较优劣,择优而为我们所用。

试想我们遇到以下情景,我们该怎么处理

在工作中,我们需要处理不同类型的文件,有音频的,视频的,图片的,文本的。通过程序的处理,我们可以分别提取到不同的信息。

这种情况你准备怎么处理

工作经验少的同学默默的心理噗嗤一声,看我5分钟搞定

 class Program
    {
        static void Main()
        {
            var fileType = "Video";
            switch (fileType)
            {
                case "Video":
                    HandleVideoFile(fileType);
                    break;
                case "Audio":
                    HandleAudioFile(fileType);
                    break;
                case "Image":
                    HandleImageFile(fileType);
                    break;
                case "Text":
                    HandleTextFile(fileType);
                    break;
            }
            Console.ReadKey();
        }

        public static void HandleTextFile(string fileType)
        {
            Console.WriteLine("我开始处理文本文件了");
        }

        public static void HandleImageFile(string fileType)
        {
            Console.WriteLine("我开始处理图片文件了");
        }

        public static void HandleAudioFile(string fileType)
        {
            Console.WriteLine("我开始处理音频文件了");
        }

        public static void HandleVideoFile(string fileType)
        {
            Console.WriteLine("我开始处理视频文件了");
        }
    }

View Code

各个方法封装,独立,可随处调用,面向对象三大特性,简简单单随随便便给你展现一脸

后来,系统变强壮了,业务增加了,要求同时也能处理邮件Email

是不是你这个时候开始修改代码,增加一个方法,添加一个case,break;

如果后续陆陆续续好几十种继续增加,怎么办。程序的可维护性,可扩展性在哪里?

开放-封闭原则在哪里?

开放-封闭原则是只软件实体(类,模块,函数等等),应该可以扩展,但是不可修改

抛开所有原则,再增加5个,你这个类的代码得有1000行了吧,那么多case,break, 那天稍微不小心的改错一个,是不是会引起巨震。

所以,我们开始进行修改,也就是我们接下来进入正题的 简单工厂模式。

所谓的简单工厂模式,是将一个具体类的实例化交给一个工厂方法来执行

1个点,敲黑板,重点来了

工厂方法来执行。首先需要一个工厂,还需要一个方法。一个方法来干嘛?来实例化具体的类,具体的什么类?具体的算法类!

我们首先来定义一个抽象类

    public abstract class Handle
    {
        public abstract void HandleFile();
    }

View Code

这个类告诉全世界,要实现我,就得实现我的方法,我们是强关系,我们是合成关系,我们是拥有关系,我们是鸟儿与翅膀的关系!

而且不准实现我,要实现,先继承,要继承,就得override我的所有方法

于是,不得已,要处理的类纷纷开始实现

文件处理类

    /// <summary>
    /// 文本处理类
    /// </summary>
    public class TextHandle : Handle
    {
        public override void HandleFile()
        {
            Console.WriteLine("我开始处理文本文件了");
        }
    }

View Code

图片处理类

   /// <summary>
    /// 图片处理类
   /// </summary>
    public class ImageHandle : Handle
    {
        public override void HandleFile()
        {
            Console.WriteLine("我开始处理图片文件了");
        }
    }

View Code

视频处理类

    /// <summary>
    /// 视频处理类
    /// </summary>
    public class VideoHandle : Handle
    {
        public override void HandleFile()
        {
            Console.WriteLine("我开始处理视频文件了");
        }
    }

View Code

音频处理类

    /// <summary>
    /// 音频处理类
    /// </summary>
    public class AudioHandle : Handle
    {
        public override void HandleFile()
        {
            Console.WriteLine("我开始处理音频文件了");
        }
    }

View Code

所有的处理类我们定义好了,如果后续,业务变更,需求增加,再添加什么邮件啊,电话啊,其他什么的,我们只需要继续添加我们的类,而不是通过去添加方法,这样每个类的单一职责原则是不是体现的很淋漓尽致了,如果单一职责觉得太书面,我们换个称呼,单一功能原则!没法再简单了

所有的处理类已经Ready了,我们的重点工厂可以开始修建了

    public class HandleFactory
    {
        public Handle CreateHandle(string fileType)
        {
            Handle handle = null;
            switch (fileType)
            {
                case "Video":
                    handle = new VideoHandle();
                    break;
                case "Audio":
                    handle = new AudioHandle();
                    break;
                case "Image":
                    handle = new ImageHandle();
                    break;
                case "Text":
                    handle = new TextHandle();
                    break;
            }
            return handle;
        }
    }

View Code

不要指指点点,不要指指点点,不要指指点点

我们就像项目过程一样,渐进明细

这次介绍的是简单工厂模式,简单工厂重点是 简单,工厂

后续增加业务的时候,我们只需要再加case,和对应的Handle类就好了

如何调用呢

 class Program
    {
        static void Main()
        {
            var handleFactory = new HandleFactory();
            var fileType = "Text";
            var handle = handleFactory.CreateHandle(fileType);
            handle.HandleFile();
        }

    }

View Code

是不是一下简单明了,你要是Web程序,可以,要是CS程序,可以,要是WebAPI,也可以

易扩展,可维护

 

总结下

优点

1、扩展性高,如果想增加一个处理方式,只要扩展一个处理类就可以。

2、屏蔽实现,只关心处理的结果

3、带你走进工厂模式

缺点

1、每次增加一个处理对象的时候,都需要增加一个处理类,还要同时告诉工厂,增加处理类型

2、增加了系统具体类的依赖

 

以上就是关于简单工厂模式的分享

一路前行,风雨无阻,不定时更新



You must enable javascript to see captcha here!

Copyright © All Rights Reserved · Green Hope Theme by Sivan & schiy · Proudly powered by WordPress

无觅相关文章插件,快速提升流量