工厂模式

Posted 2021-02-20 aqgy12138

工厂方法模式：定义一个用于创建对象的接口，但是让子类决定哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

工厂方法模式简称工厂模式，又可称为虚拟构造器模式或多态工厂模式。工厂模式是一种创建型模式。

在工厂模式中，工厂父类负责定义创建产品对象的的公共接口，而工厂子类负责生成具体的产品对象，

这样做的目的是将产品类的实例化操作延迟到工厂子类中完成。

其实，说到这我很想放个结构图的，书上的结构图描述的很清晰，但是我不知道有什么软件可以去画，我试着用word画了一下，给我丑死了。。。

那就直接上例子解析了。。

现在公司要我做个日志记录模块，现在的需求是需要我在查询和新增的时候记录下日志。

我准备用我们的工厂模式去实现它。

首先来个抽象产品类，抽象类有一个记录日志的公共方法。

   /// <summary>
    /// 抽象产品
    /// </summary>
    public interface ILogger
    {
        /// <summary>
        /// 记录日志
        /// </summary>
        void WriteLog();
    }

然后我的查询和新增实现这个公共方法。

    /// <summary>
    /// 查询记录日志，充当具体产品
    /// </summary>
    public class Select : ILogger
    {
        public void WriteLog()
        {
            Console.WriteLine("记录查询");
        }
    }
    /// <summary>
    /// 新增记录日志，充当具体产品
    /// </summary>
    public class Insert : ILogger
    {
        public void WriteLog()
        {
            Console.WriteLine("记录新增");
        }
    }

新增一个抽象工厂，里面有个实例化产品的公共方法。

     /// <summary>
    /// 抽象工厂
    /// </summary>
    public interface ILoggerFactory
    {
        /// <summary>
        /// 返回实例对象
        /// </summary>
        /// <returns></returns>
        ILogger CreateLogger();
    }

上面我们实现了两个产品（查询、新增），那具体的工厂也许与之对应。

   /// <summary>
    /// 查询
    /// </summary>
    public class SelectFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            return new Select();
        }
    }

    /// <summary>
    /// 新增
    /// </summary>
    public class InsertFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            return new Insert();
        }
    }

好了，代码写好了。现在来测试一下。。。。

   ILoggerFactory factory = new InsertFactory();
   ILogger logger = factory.CreateLogger();
    logger.WriteLog();

 

 

 有结果了，但是老板刚刚给我打了个电话说要我加个修改的日志记录。。。。

这很难受啊，但是该需求是习惯的事情了，这要换我没学工厂模式之前，俺肯定if else一条龙，但是现在俺们学了工厂模式，咋不能那么写了。

我先来个具体的修改（产品）实现抽象的产品

    /// <summary>
    /// 修改 日志记录
    /// </summary>
    public class Update : ILogger
    {
        public void WriteLog()
        {
            Console.WriteLine("修改日志");
        }
    }

再来个具体的工厂。

 public class UpdateFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            return new Update();
        }
    }

刚刚的代码我就把Insert换成Update

 

 

 ??完事，跟老板汇报下我弄好。

老板要我加多少我都不慌，反正又不改我其它查询，新增的代码，这么一说咋这开闭原则还是蛮好的。

有时候为了简化客户端的使用，还可以隐藏工厂方法。

先把接口类，改成抽象类

 public abstract class LoggerFactory
    {
        /// <summary>
        /// 实现记录日志
        /// </summary>
        public void WriteLog()
        {
            var logger = this.CreateLogger();
            logger.WriteLog();
        }
        public abstract ILogger CreateLogger();
    }

刚刚查询还没拉出来溜过，就改它吧。这次继承LoggerFactory,不是ILoggerFactory。

    /// <summary>
    /// 查询
    /// </summary>
    public class SelectFactory : LoggerFactory
    {
        
        public override ILogger CreateLogger()
        {
            return new Select();
        }
    }

改好了，再来测试下，这次测试的代码跟之前是不一样的嗷

 LoggerFactory factory = new SelectFactory();
  factory.WriteLog();//记录查询

比刚刚少了一句代码，但是其实是很有意义的，现在我们测试不需要创建具体产品的对象的实例，因为工厂已经帮我们把活干，我们只需要调用方法就好了。

------------------假装有分割线------------------------

下面讲一下工厂模式的优劣吧

好

1. 比如我想要查询的功能，我不需要知道查询这里面干啥了，你只给我完成就完事儿，我告诉查询工厂这事你给我干了。
2. 开闭性好，我老板跟我说要我加个修改，没关系你加呗，我查询和新增的不影响。
3. 多态性设计，工厂能够自己知道创建那种产品的对象，创建这个产品的对象全部都封装再对应的工厂里。

坏

 

1. 这个坏处以我的理解只能说一点，就是我每次新加个模块需要加两个类，搞得程序越来越复杂。