系统架构技能之设计模式-工厂模式

一、开篇

        一个多月没有写文章了，一方面是由于家庭的原因，还有一方面是因为工作上的原因，所以在这里给大家说抱歉了，这段时间也是有很多热心的朋友，一直询问我，什么时候能把相关的

系列文章写完，其实我也特别的想赶快的把相关的文章书写完毕，不过现在真的是有时候力不从心，家庭和工作上的事情需要都处理好，所以属于个人思考的时间可能就会相对的少一些了，不

过我会继续努力，出时间来把下面的这几个系列写完：

        1、系统架构技能之设计模式-系列索引

        2、系统架构师-基础到企业应用架构-系列索引

        3、Step by Step-构建自己的ORM系列

        当然可能在我写的过程中又会产生新的想法或者思路，我会提出来，并且给出相应的实现方案的。希望大家能够集思广益，能够创造出适合大家的通用的解决某类 问题的通用解决方案，

那么就真的是大功告成了，呵呵，闲话不多说了，我们还是来实质性的东西吧，本文主要是讲述设计模式中最经典的创建型模式-工厂模式，本文将会从以下几点对工厂模式进行阐述。

       

        本文将会从上面的四个方面进行详细的讲解和说明，当然会的朋友可以之处我的不足之处，不会的朋友也请我们能够相互学习讨论。

二、摘要

        本文将会主要是结合项目中的一些实例作为实例来分析工程模式的使用方式和何时使用工程模式，并且分析工程模式的有点和它解决的问题，在我们实际的项目中何时能使用到它，或者

说我们在什么情况下，应该考虑使用工厂模式来解决项目中的问题，一般情况下我们可以这样理解设计模式，设计模式是一种方案，为我们遇到与设计模式提出的应用场景想象或者相仿的场景

中，这类问题通常是经常发生或者是经常遇到的问题的通用解决方案。

        本文依然是采用图文讲解的形式来分析工程模式在项目中出现的位置，并且给出几个灵活的实现方案。主要针对的实现方式有：通过配置文件,通过类型,通过委托,通过特性等来实现工厂。

三、本文大纲

       a、开篇。

       b、摘要。

       c、本文大纲。

       d、工厂模式的特点及使用场景。

       e、工厂模式的实现方案。

       f、工厂模式使用总结。

       g、系列进度。

       h、下篇预告。

四、工厂模式的特点及使用场景

4.1、工厂模式简介

        工厂模式是创建型模式中最典型的模式，主要是用来创建对象，减少我们在使用某个对象时的new() 操作，我相信大家都有这样的困惑，目前我所在的项目都在程序开发的过程中，还是

有很多的new()操作出现在表现层中，并没有通过工厂来创建对象，一方面可能是因为我们自身比较懒，不规范项目的编码形式，另外一方面也是由于项目的进度比较紧，没有那么多的时间去

完成工厂的统一创建，当然对于这样的动态创建对象的工厂，推荐的做法还是我们后面会讲到的创建型模式--《抽象工厂模式》来解决吧。

        如果您并不知道工厂模式是用来干什么的，我们可以通过如下举例来说明，例如我们现在有个矿泉水加工厂，加工矿泉水，我们现在知道有矿泉水这个对象，那么当我批量生产矿泉水的

时候，我们就通过工厂来批量的生产，等于我们程序中的批量创建对象。这时候我有很多个对象，也就是很多游客，他们每人都要一瓶矿泉水，这时候如果说把游客比作不同的应用程序模块，

都要使用矿泉水这个对象，那么我是不是应该每个应用程序都在使用这个对象的时候，我使用new()操作呢？，无疑这不是一个好的方案。我们来看看图形化的描述吧？

这种情况下，不同的游客需要矿泉水的时候，我就new()一个矿泉水和我找个加工厂生产矿泉水明显是有差别的，这个时候，游客不应该和矿泉水有

关联关系了，而且游客不知道，矿泉水是怎么生产出来的，也不需要关心这些东西。

        那么我们应该如何去解决这样的问题呢？基于面向对象的变成设计时，原则就是低耦合，对象和对象之间。那么对象之间的引用关系，可以通过抽象出接口，通过借口的依赖来解耦，降低系统的耦合性。

        假如这个时候我修改对象服务的名称,那么我是不是必须把所有的调用这个对象服务应用程序代码都进行

修改？这个是必须的，否则程序无法编译通过的。但是如果我们使用工厂模式的时候呢？有什么不同呢？我们来看看：

        上面是添加了工厂模式之后的情况，上面就算是你修改了类名之后，只

需要修改工厂中的New出来的类即可，当然如果你要是通过返回接口的形式的话，再不修改接口命名的前提下，如何修改类方法都是可行的，并且通过工厂模式，无疑降低了应用程序与对象之

间的耦合性，通过工厂来解耦，提供程序的应对变化的适应能力。

4.2、工厂模式的使用场景

           工厂模式一般用于创建一类对象，而不用每次在使用时通过new()对象才能使用对象，而是通过工厂来完成对象的创建，这样不但提供了统一创建对象的入口，而且对于程序的可维护

和可测试性都有很大的提高。总体来说如下场景使用工厂模式非常合适：

          1、工厂负责创建某一类对象的时候，或者说工厂的职责比较单一时，如果说多个类型的对象时候，用工厂模式就不如使用抽象工厂了

          2、一般比较少的积累对象，可以通过类型的判定创建不同的对象时，也是可以通过工厂模式来完成，例如多数据库的支持，我们在设计数据访问层时，利用简单对象工厂，通过枚举或

者配置文件的形式，来动态的创建数据访问层实例。

          3、一般来说类型单一的对象，或者类型比较少的时候，使用工厂模式来创建对象可以解决一类问题。还可以通过一个总的工厂，来创建多个工厂，然后多个工厂负责创建相应的实例，

有点类似我们平时说的目录结构似的。

          类似如下的形式，大家一看就明白了：

         

         等于是不同层级的工厂，具有不同的职责和任务。

五、工厂模式的实现方案

         5.1、工厂模式的配置文件实现。

            我们先看配置文件的配置内容

           <DatabaseInfo>
           <ConnKey>default</ConnKey>
          <DataBaseType>MSSQLServer</DataBaseType>
          </DatabaseInfo>

    定义要创建的对象实例统一接口

    /// <summary>
    /// 所有的数据访问接口
    /// </summary>
    public interface IDbAccess
    {
    }

    实现这个接口的具体类

public class SQLServer : IDbAccess
   {
       //相关的方法
       public System.Data.SqlClient.SqlConnection Connection
       {
           get
           {
               return new System.Data.SqlClient.SqlConnection();
           }
       }
   }

     负责创建返回类型为IDbAccess的数据访问层对象实例

public class DBFactory
    {
        public IDbAccess Create()
        {
            IDbAccess instance = null;

            System.Xml.XmlDocument doc=new System.Xml.XmlDocument();
            doc.LoadXml("");

            XmlElement root = doc.DocumentElement;//XML文档的根节点
            XmlNode node = root.SelectSingleNode("DataBaseType");

            switch (node.InnerText)
            {
                case "SQLServer":
                    instance = new SQLServer();
                    break;
                case "Oracle":
                    instance = new Oracle();
                    break;
                default:
                    break;
            }

            return instance;
        }
    }

具体的控制台输出测试代码如下：

class Program
{
    static void Main(string[] args)
    {
        DBFactory factory = new DBFactory();
        IDbAccess dbaccess = factory.Create();

        //使用相应的数据访问对象即可。
    }
}

5.2、通过枚举来实现。

通过枚举来实现后，工厂类的创建代码如下：

public class DBFactory
    {
         public IDbAccess CreateByEnum(DbType dbType)
        {
            IDbAccess dbAccess = null;

            switch ((int)dbType)
            {
                case (int)DbType.SQLServer:
                    dbAccess= new SQLServer();
                    break;
                case (int)DbType.Oracle:
                    dbAccess = new Oracle();
                    break;
                case (int)DbType.Access:
                    dbAccess = new Access();
                    break;
                default:
                    break;
            }

            return dbAccess;
        }
    }

相应的枚举代码如下：

public enum DbType
{
    SQLServer=0,
    Oracle=1,
    Access=2
}

 

相应的控制台测试代码：

static void Main(string[] args)
        {
            DBFactory factory = new DBFactory();
            IDbAccess dbaccess = factory.CreateByEnum(DbType.SQLServer);

            //使用相应的数据访问对象即可。
        }

5.3、工厂模式的复杂进阶

我们上面只是定义了一种工厂，该工厂负责所有的子类对象的创建，如果说我们的工厂要求能够满足增加新的对象时，我们必须修改工厂代码，那么我们如何来做呢？我们可以这

样来做。

每个类型的对象都有与这个类型对应的工厂去创建，那么就算以后增加或者修

改，只需要修改相应的工厂涉及的文件即可。但是这样也有很大的弊端就是工厂类太多，难以维护。优点是支持动态的增加新的对象类型，对之前的创建工作不会造成影响，我们

来看看相应的代码，基于图中的几个类型。先定义对象的统一接口和工厂的接口。

先看对象接口的统一定义：

public  interface IComObject
    {
        /// <summary>
        /// 重要级别
        /// </summary>
        /// <returns></returns>
        int ImportLevel();
    }

工厂接口的统一定义：

public interface IComFactory
    {
        IComObject Create();
    }

我们来看看具体的对象实现和工厂实现吧，我们这里以上图中的书为例说明创建过程

public class BookFactory : IComFactory
{
    public IComObject Create()
    {
        return new Book();
    }
}

具体的对象实现代码-实现IComObject对象接口

public class Book : IComObject
    {
        public int ImportLevel()
        {
            return 0;
        }
    }

我们来看看具体的程序调用代码：

static void Main(string[] args)
        {
            IComFactory factory = new BookFactory();
            IComObject book = factory.Create();

            //使用相应的数据访问对象即可。
        }

通过上面的形式，我们可以看到，后期如果新增比如说我现在要对个产品这个对象新增到系统中，那么我们只需要增加相应的对象实现类和工厂实现类即可，对其他地方不会有影

响，相比上面讲述的，一个工厂创建所有的对象实例的方式无疑提供了新增对象类型创建的能力。

六、工厂模式使用总结

         通过上面的简单实例讲解，估计高手理解起来很容易也很简单，其实本来也是很简单的，大伙不了解工厂模式的朋友，应该也能理解讲述的内容，本文前面讲述的2中方式主要是针对简

单工厂模式，简单工厂模式，不符合高内聚的原则，因为所有的对象的创建工作都放在一个类的内部去完成，逻辑太复杂了，通过后面的工厂模式，将每个工厂的职责进行了更细化，每个工厂

只负责具体对象类型实例的创建。这也为后期增加新的对象类型提供了不错的扩展，本文并没有给出特性+委托的工厂的实现方案，我放在下篇的抽象工厂中去讲解，也会针对配置文件,特性,委

托的几种方式来给出抽象工厂模式的实现方案，当然我给出的都是很简单的例子，希望大家一看就懂，就能用在实际的项目中，可能高手会认为我讲的太浅了，一方面是因为自己没有整理好思

路，时间紧迫，另一方面是因为自身能力有限，还请大家多提宝贵意见，我们总结下本文讲述的内容吧；

         前面讲述了2中简单工厂模式的实现方案。通过配置文件、通过枚举来完成对象的创建，其实就是根据对象的类型来完成，也可以通过反射来完成。这里给出简单的实现：

public IDbAccess Create(string TypeName)
        {
            Type type = Type.GetType(TypeName);
            IDbAccess obj = (IDbAccess)Activator.CreateInstance(type);
            return obj;
        }

其实就是这样的简短代码，给出关键代码实现吧，可能实际运行中还要进行相应的调整。

总体来说简单工厂适合项目中类型不多的情况时使用简单工厂很方便。

当项目中频繁的增加不同类型的对象时，考虑使用工厂模式，来满足这样的动态变化需求。

七、系列进度

       创建型

        1、系统架构技能之设计模式-单件模式

        2、系统架构技能之设计模式-工厂模式

        3、系统架构技能之设计模式-抽象工厂模式

        4、系统架构技能之设计模式-创建者模式

        5、系统架构技能之设计模式-原型模式

        结构型

        1、系统架构技能之设计模式-组合模式

        2、系统架构技能之设计模式-外观模式

        3、系统架构技能之设计模式-适配器模式

        4、系统架构技能之设计模式-桥模式

        5、系统架构技能之设计模式-装饰模式

        6、系统架构技能之设计模式-享元模式

        7、系统架构技能之设计模式-代理模式

        行为型

        1、系统架构技能之设计模式-命令模式

        2、系统架构技能之设计模式-观察者模式

        3、系统架构技能之设计模式-策略模式

        4、系统架构技能之设计模式-职责模式

        5、系统架构技能之设计模式-模板模式

        6、系统架构技能之设计模式-中介者模式

        7、系统架构技能之设计模式-解释器模式

八、下篇预告。

            下篇将会针对抽象工厂模式进行讲述，该模式也是目前项目中使用最多的一个设计模式，目前我所在的项目中，就使用到了这个模式，我会对于前面讲述的工厂模式与抽象工厂模式进行对比，并且把今天文章中提到的特性+委托的方案放出实现，希望大家多提宝贵已经，错误之处还请指出，请大家继续支持。

九、本文源码

            下载源码