.NET责任链模式(混合单例模式，模板方法模式)-----制做与扩展能力验证

.NET责任链模式、单例模式、模板方法模式混用

 

前言

　　哇，看到题目挺长的，这个组合型的东西，到底能干啥呢？本篇文章来一块儿琢磨琢磨，这两天为了团队的软件赶工，我负责的那一块叫：插件管理器。咱们团队的成员用的语言仍是挺分散的，本人C#，队长VB.NET，还有其余成员写易语言等，系统的功能插件是咱们分开写的，各自用各自的喜欢的语言写各个功能模块的插件，最后用我开发的插件管理器把全部的插件整合到一块儿。这让我很头疼啊，一个C#版的插件，一个VB.NET版的插件，一个易语言的插件，若是有新成员加入，又来个Python版的插件，叫我如何是好。最普通、最烂的处理方法就是：写不少版本的读取器，而后使用if来根据插件语言使用对应该版本的读取器读取信息，哇，这若是来十几种语言，岂不是坑爹。可能有人会说：引入Kernel32能解决非.NET语言的插件读取吧。确实目前使用了这种方案，能兼容易语言，.NET语言就使用.NET的插件Dll读取方式，可是还不肯定Kernel32能不能解决任何语言的插件。因此为了让本身有个后路，我结合题目所说的三种设计模式，写了一个模板，下面看这个模板能干吗，为何要这样用。若是有地方使用得不恰当的，但愿各位朋友们强拍，我会努力学习改正，若是以为能够的，点个推荐，谢谢~

 

框架展现与说明

　　　                                   　

　　你们看下类图，下面分别介绍各个类的职责。Plugin类是插件的数据结构类，PluginType是一个枚举，它的内容是定义了全部插件的类型，例如DotNet,Python等，扩展的时候须要修改该枚举。而后剩下的就是本章的重点了，用户代码Client使用IPluginAnalyzerable接口来读取插件信息，该接口有两个实现类，一个是PluginAnalyzer（抽象类，定义各个语言的读取器的公共部分），该类实现模板方法模式和责任链模式，让处理命令能在其子类之间互相推卸责任，其子类目前有两个，分别是DotNet,Python的具体读取器。最后一个类ComponentAnalyzer担任封装职责，将责任链初始化好，本身实现单例模式，提供给用户代码调用。因此，最后的效果是：获取ComponentAnalyzer的实例，调用其中一个方法，该方法调用具体读取器链，最后哪一个读取器处理了请求，用户是不须要知道的，大概思路就是这样。

 

实现过程

　　本实现过程只是模板的实现，具体应用到项目中还须要作出相应的改变。

　　事不宜迟，咱们先实现Plugin类和PlugType枚举：

　　　　Plugin：

class Plugin
    {
        public Plugin(PluginType type,String pluginPath)
        {
            this.BelongType = type;
            this.PluginPath = pluginPath;
        }
        public PluginType BelongType { set; get; }
        public String PluginPath { set; get; }
    }

　　　　PlugType：

enum PluginType
    {
        DotNet=0,
        Python=1,
    }

　　实现完两个基本的类型之后，而后就来看下本篇的重头戏，我会边贴代码边附加上帮助理解的说明。首先从最底层的IPluginAnalyzerable开始：

interface IPluginAnalyzerable
    {
         void Analyze(Plugin plugin);
    }

 

　　用户代码就是使用该接口的Analyze方法来处理传入的插件的，再下一层有两个类，一个是抽象类PluginAnalyzer，一个是ComponentAnalyzer。

 

abstract class PluginAnalyzer:IPluginAnalyzerable
    {
        public PluginAnalyzer(PluginType type)
        {
            this.analyzerType = type;
        }
        protected PluginType analyzerType;

        public void Analyze(Plugin plugin)
        {
            if (plugin.BelongType == this.analyzerType)
            {
                String author = GetAuthor(plugin);
                String version = GetVersion(plugin);
                Console.WriteLine(String.Format("\r\n分析者：{0},插件类型:{1} \r\n{2}\r\n{3}", 
                    this.GetType().Name,plugin.BelongType,author, version));
            }
            else
            {
                if (nextAnalyzer != null)
                {
                    nextAnalyzer.Analyze(plugin);
                }
            }
        }

        private PluginAnalyzer nextAnalyzer;
        public PluginAnalyzer NextAnalyzer
        {
            set
            {
                this.nextAnalyzer = value;
            }
            get 
            {
                return this.nextAnalyzer;
            }
        }

        protected abstract String GetAuthor(Plugin plugin);
        protected abstract String GetVersion(Plugin plugin);
    }

 

　　解读：

　　每个继承本类的具体类都有两个字段

　　　　1：所属类型(PluginType枚举)，变量名为analyzerType。  

　　　　2：下一个分析者(PluginAnalyzer)，也就是兄弟类(一样继承PluginAnalyzer)。

　　每个继承本类的具体类都须要重写两个方法GetAuthor和GetVersion，这两个方法将会在模板方法Analyzer内部被使用。

　　模板方法Analyzer首先判断传进来的插件类型是否和自身能够处理的类型相同，若是相同则调用自身的方法处理，若是不一样则把处理权推给本身的下一位分析者。这样就完成了具体架构的搭建了。

　　

　　而后就是具体读取器类了，各自有各自的处理相同任务的方式。都继承PluginAnalyzer

　　　　DotNetPluginAnalyzer(该类是处理.NET插件的读取器)

class DotNetPluginAnalyzer:PluginAnalyzer
    {
        public DotNetPluginAnalyzer(PluginType type) 
            : base(type) 
        { }
        public DotNetPluginAnalyzer()
            : base(PluginType.DotNet)
        { }
        protected override string GetAuthor(Plugin plugin)
        {
            return "DotNet的插件，做者名为：Jarvin";
        }

        protected override string GetVersion(Plugin plugin)
        {
            return "DotNet的插件，版本号为：!!!V2014!!";
        }
    }

 

　　　　PythonPluginAnalyzer(该类是处理Python插件的读取器)

class PythonPluginAnalyzer:PluginAnalyzer
    {
        public PythonPluginAnalyzer(PluginType type) 
            : base(type) 
        { }
        public PythonPluginAnalyzer()
            : base(PluginType.Python)
        { }
        protected override string GetAuthor(Plugin plugin)
        {
            return "Python的插件，做者名为：Joker";
        }

        protected override string GetVersion(Plugin plugin)
        {
            return "Python的插件，版本号为：V---很奇怪----";
        }
    }

 

 

　　好了，如何使用？我将新建一个类，把这些读取器包装起来，而且造成一条链，提供一个统一的接口给用户代码调用，下面看我如何包装的。

　　　　ComponentAnalyzeclass ComponentAnalyzer:IPluginAnalyzerable    {

private ComponentAnalyzer() { rootAnalyzer = new DotNetPluginAnalyzer(); PythonPluginAnalyzer pythonAnalyzer = new PythonPluginAnalyzer(); rootAnalyzer.NextAnalyzer = pythonAnalyzer; } #region 单例模式实现
　　　　 private ComponentAnalyzer()
　　　　 {

　　　　 } public static ComponentAnalyzer GetInstance() { return SingleHelper.GetInstance(); } private class SingleHelper { private static ComponentAnalyzer me = new ComponentAnalyzer(); public static ComponentAnalyzer GetInstance() { return me; } } #endregion PluginAnalyzer rootAnalyzer; public void Analyze(Plugin plugin) { rootAnalyzer.Analyze(plugin); } }

　　很简单的一个类，咱们先看构造函数：把全部语言的读取器链接起来，而后链头是rootAnalyzer，咱们每次调用Analyze方法都会调用rootAnalyzer对应的方法，让其在内部传递。弄到这里，差很少完成了,你们能够在最下面直接下载源码运行看结果，下面给出客户端测试类。

class Programe
    {
        public static void Main(string[] args)
        {
            IPluginAnalyzerable dotnetAnalyzer=ComponentAnalyzer.GetInstance();
            Console.WriteLine("输入Q退出");
            while(true)
            {
                Plugin plugin = RandomPlugin();
                dotnetAnalyzer.Analyze(plugin);
                if (Console.ReadLine().ToUpper() == "Q")
                {
                    break;
                }
            }
        }
        private static Plugin RandomPlugin()
        {
            Random random = new Random();
            PluginType type = (PluginType)random.Next(0, 2);
            String plaginPath = Path.GetRandomFileName();
            Plugin result = new Plugin(type, plaginPath);
            return result;
        }
    }

View Code

 　　 测试结果：看，以一致的方式执行，可是会获得不同的效果，责任被推到合适的地方作出相应的处理。

　　到这里有人会说，那如何证实该模型的扩展性？？ 好，下面我扩展一种语言读取器，看我改了多少，对系统影响了多少？

 

扩展性测试

　　　我以Ruby为例。

　　　　1.在PluginType中添加一个枚举内容Ruby：。

　　　　2.添加一个Ruby读取器：

　　　　3.在ComponentAnalyzer(前面说的包装器)中，把该读取器添加到链条上！

　　　　

　　　　为了测试，在客户端代码中修改Random随机生成数，使其能生成3，大功告成！（这是测试相关，咱们没有修改实际客户端任何代码）

　　　　 顺利扩展！！！咱们修改的只是上层的代码，对于底层，也提供了扩展点，符合对修改封闭，对扩展开放。

 

总结

　　完成了，你们也累了，但愿有不对的地方你们大力拍，面向组合编程，面向接口编程，不要面向具体实现类编程，这是我学习设计模式感觉最深的一句话。谢谢你们观看。下面提供完整源码。

                                   完整Demo下载