设计模式 2/23 工厂模式(一)

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

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

我们要了解一点，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("我开始处理视频文件了");
        }
    }

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

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

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

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

开放-封闭原则在哪里？

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

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

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

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

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

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

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

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

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

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

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

文件处理类

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

图片处理类

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

视频处理类

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

音频处理类

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

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

所有的处理类已经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;
        }
    }

不要指指点点，不要指指点点，不要指指点点

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

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

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

如何调用呢

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

    }

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

易扩展，可维护

总结下

优点

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

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

3、带你走进工厂模式

缺点

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

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

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

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