3-3设计模式之命令模式（Command）

作者

3.3.1 模式意图:

在开发中会遇到多个技能排序释放；事件到达一定阈值时触发；对操作进行"记录、撤销、重做"等行为。在以上情况下，需要将"行为请求者"与"行为实现者"解耦。将一组行为抽象为对象，可以实现二者之间的松耦合。为了满足这种需求，可以考虑使用命令模式。

3.3.2 模式概念:

它属于行为型模式，以对象的形式将请求封装，从而让你使用不同的请求把客户端参数化。对排队的请求或记录请求相关日志，可以提供命令的恢复、撤销功能。

3.3.3 模式元素:

  • 命令类抽象（Command）
  • 命令类细节（CommandOne、CommandTwo）
  • 调用者（Invoker）:
  • 接收者（Receiver）

3.3.4 代码示例:

接受者

public interface IReceiver
{
    void Release();
}
public class SkillOne : IReceiver
{
    public void Release()
    {
        Debug.Log("释放技能一");
    }
}
public class SkillTwo : IReceiver
{
    public void Release()
    {
        Debug.Log("释放技能二");
    }
}

命令相关

public abstract class Command
{
    protected IReceiver receiver = null;

    public Command(IReceiver receiver)
    {
        this.receiver = receiver;
    }
    public abstract void Execute();
}

public class CommandOne : Command
{
    public CommandOne(IReceiver receiver) : base(receiver) { }

    public override void Execute()
    {
        Debug.Log("命令一");
        receiver.Release();
    }
}

public class CommandTwo : Command
{
    public CommandTwo(IReceiver receiver) : base(receiver) { }

    public override void Execute()
    {
        Debug.Log("命令二");
        receiver.Release();
    }
}

调用者

public class Invoker
{
    public List commadGroup = new List();

    public void Execute()
    {
        foreach (var commad in commadGroup)
        {
            commad.Execute();
        }
    }

    public void Add(Command command)
    {
        commadGroup.Add(command);
    }
}

调用示例

    void Start()
    {
        Invoker invoker = new Invoker();
        invoker.Add(new CommandOne(new SkillOne()));
        invoker.Add(new CommandTwo(new SkillTwo()));

        invoker.Execute();
    }

3.3.5 写法对比:

略

3.3.6 模式分析:

  • IReceiver的细节，包含行为的具体如何实施与执行。
  • Command可以理解为一个容器，用这个容器把Receiver细节包裹在里面。在执行Execute时调用具体的实现方式。
  • Invoker负责批量拆开Command包裹，来执行所含的IReceiver细节。

在PureMVC中，这种类似命令模式的实现，将一个要执行的函数包裹起来，在需要的时候拆开包裹进行调用其中的内容。

        // 关键代码片段
        public virtual void NotifyObserver(INotification notification)
        {
            object context;
            string method;

            lock (m_syncRoot)
            {
                context = NotifyContext;
                method = NotifyMethod;
            }

            Type t = context.GetType();
            BindingFlags f = BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase;
            MethodInfo mi = t.GetMethod(method, f);
            mi.Invoke(context, new object[] { notification });
        }

Observer相当于一个Command，其中NotifyObserver就是一个Command中的Execute，通过对context进行反射找到真正的类，然后根据method找到这类中的具体方法，接下来传入参数执行即可。

Controller中的ExecuteCommand方法，他直接根据类的名称反射一个全新的类，然后执行其中的Execute方法，简单明了。

        public virtual void ExecuteCommand(INotification note)
        {
            Type commandType = null;

            lock (m_syncRoot)
            {
                if (!m_commandMap.ContainsKey(note.Name)) return;
                commandType = m_commandMap[note.Name];
            }

            object commandInstance = Activator.CreateInstance(commandType);

            if (commandInstance is ICommand)
            {
                ((ICommand) commandInstance).Execute(note);
            }
        }

使用命令模式来应对这种需要排序执行的操作是首选，可以显著降低系统的耦合度，对于后期的需求变动也符合开闭原则，但命令过多容易造成命令类数量爆炸的情况。

3.3.7 应用场景:

需要排队执行或者撤销/重做等处理的需求。

3.3.8 小结:

命令模式利用对象方便排序、增减的特点进一步对函数的执行进行封装，降低系统中函数间交互的耦合度。

更多设计模式详见：设计模式全家桶

阅读量： 1,890

发表评论