一次运用设计模式对现有系统进行重构的尝试（二）

      关于这次尝试的实践在上次发文后（http://www.cnblogs.com/Ivan-Yan/archive/2008/10/29/1322119.html），得到了几位朋友（木野狐(Neil Chen) 、T2噬菌体等）的指点，在这里再次感谢你们的热心帮助。

     思考
     上次对于不同的产品入库用简单工厂模式重构后，就象朋友们所说，这个设计确实很不灵活：如果有新的产品（如原材料）入库作业，那么需要修改的地方太多了：工厂类，具体类...实际上违背了面向对象的设计原则：开放封闭原则。
     经过学习思考后，认识到：这里的设计实际上还违背了依赖倒置原则：依赖于抽象，而不要依赖于具体实现。而简单工厂模式就存在这个弊端。
     为了解决这个问题，我对此设计进行了再次重构：工厂方法模式

     运用工厂方法模式再次重构
     
    
 为每个产品作业的工厂建立抽象接口

Code
 interface IRecFactory
    {
        IGoodReceive recFac();
    }

     半成品工厂类：

Code
 class CellFactory:IRecFactory
    {
         IGoodReceive IRecFactory.recFac()
        {
            return new CELLReceive();
        }
    }

     成品工厂类：

Code
class MODFactory:IRecFactory
    {
         IGoodReceive IRecFactory.recFac()
        {
            return new MODReceive();
        }
    }

     对入库作业进行抽象：

Code
    interface IGoodReceive
    {
        string ExecReceive();
    }

     半成品入库作业具体类：

Code
   class CELLReceive:IGoodReceive
    {
        string IGoodReceive.ExecReceive()
        {
            return "在这里执行【半成品入库】作业";
        }
    }

     成品入库作业具体类：

Code
 class MODReceive:IGoodReceive 
    {
        string IGoodReceive.ExecReceive()
        {
            return "在这里执行【成品入库】作业";
        }
    }

     Client端的作业：

Code
 private void btnCellRec_Click(object sender, EventArgs e)
        {
            //半成品入库
            IRecFactory fac = new CellFactory();
            IGoodReceive rec = fac.recFac();
            string returnInfo= rec.ExecReceive();
            MessageBox.Show(returnInfo);
        }

        private void btnModRec_Click(object sender, EventArgs e)
        {
            //成品入库作业
            IRecFactory fac = new MODFactory();
            IGoodReceive rec = fac.recFac();
            string returnInfo = rec.ExecReceive();
            MessageBox.Show(returnInfo);
        }

     
     可以看到Client端的作业均依赖于抽象，这就使得系统面对需求变更趋于稳定。
     假如用户此时要假如原材料入库作业，那么此时的设计可以从容应对。
     应对需求变化

     
加入原材料入库作业类：

Code
class RawReceive:IGoodReceive
    {
        string IGoodReceive.ExecReceive()
        {
            return "在这里执行【原材料入库】作业";
        }
    }

     为原材料作业建立工厂：

Code
class RawFactory:IRecFactory
    {
        IGoodReceive IRecFactory.recFac()
        {
            return new RawReceive();
        }
    }

     
     可以看到，面对变化，系统可以轻松扩展，而对原来产品的实现不用做任何更改，这个正是面向对象设计原则的关键所在。

 

      看到几个朋友的建议，实际上在客户端是可以利用反射来完成的：

Code
 private void btnCellRec_Click(object sender, EventArgs e)
        {
            //半成品入库
            //IRecFactory fac = new CellFactory();

            string factoryname = System.Configuration.ConfigurationManager.AppSettings["CellFactory"].ToString();
            IRecFactory fac = (IRecFactory)Assembly.Load("FactoryMethodDemo").CreateInstance("FactoryMethodDemo."+factoryname);
             IGoodReceive rec = fac.recFac();
            string returnInfo= rec.ExecReceive();
            MessageBox.Show(returnInfo);
        }

        private void btnModRec_Click(object sender, EventArgs e)
        {
            //成品入库作业
           // IRecFactory fac = new MODFactory();

            string factoryname = System.Configuration.ConfigurationManager.AppSettings["ModFactory"].ToString();
            IRecFactory fac = (IRecFactory)Assembly.Load("FactoryMethodDemo").CreateInstance("FactoryMethodDemo." + factoryname);
            IGoodReceive rec = fac.recFac();
            string returnInfo = rec.ExecReceive();
            MessageBox.Show(returnInfo);
        }

     App.Config

Code
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key ="CellFactory" value ="CellFactory"/>
    <add key ="ModFactory" value ="MODFactory"/>
  </appSettings>
</configuration>

     我想利用反射来完成的话，客户端对具体的工厂操作也被抽到Config文档中配置完成，这样在以后的维护中会更加灵活。比如，如果具体工厂名称有变化，只要改动Config文档即可，Client端无需更改。