AOP：使用命令模式實現AOP

背景

某位大牛說過，采用命名模式的好處是，你可以將命令按照不同的方式執行，如：排隊、異步、遠程和攔截等等。今天我介紹一下如何攔截命令的執行，這有些AOP的味道。

思路

就是一個管道過濾器而已

實現

先不考慮處理器的實例化和過濾器列表的實例化，如果給你一個命令、一些過濾器和一個處理器，讓你組裝為一個管道應該不是啥大問題。

這部分概念雖然簡單，可是也不見得好理解，因此我基本把全部代碼都貼上了，建議不太明白的同學，自己重寫一遍，加深對管道過濾器的理解。

核心代碼

命令接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Command
{
    /// <summary>
    /// 命令接口。
    /// </summary>
    public interface ICommand
    {
    }
}

命令處理器接口，一個命令只能有一個命令處理器。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Command
{
    /// <summary>
    /// 命令處理器接口，一個命令只能有一個命令處理器。
    /// </summary>
    public interface ICommandHandler<TCommand>
        where TCommand : ICommand
    {
        /// <summary>
        /// 處理命令。
        /// </summary>
        void Handle(TCommand command);
    }
}

命令攔截器，攔截正在被執行的命令。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Command
{
    /// <summary>
    /// 命令攔截器，攔截正在被執行的命令。
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    public abstract class CommandInterceptorAttribute : Attribute
    {
        /// <summary>
        /// 構造方法。
        /// </summary>
        /// <param name="order">指示攔截器在管道中的位置</param>
        protected CommandInterceptorAttribute(int order)
        {
            this.Order = order;
        }

        /// <summary>
        /// 攔截正在被執行的命令。
        /// </summary>
        /// <param name="context">命令執行上下文</param>
        public abstract void Intercept(ICommandExecuteContext context);

        /// <summary>
        /// 攔截器在管道中的位置。
        /// </summary>
        public int Order { get; protected set; }
    }
}

命令執行上下文接口，代表了一次命令的執行過程。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Command
{
    /// <summary>
    /// 命令執行上下文接口，代表了一次命令的執行過程。
    /// </summary>
    public interface ICommandExecuteContext
    {
        /// <summary>
        /// 命令執行服務。
        /// </summary>
        ICommandService CommandService { get; }

        /// <summary>
        /// 正在執行的命令。
        /// </summary>
        ICommand Command { get; }

        /// <summary>
        /// 執行下一個<see cref="CommandInterceptorAttribute"/>，如果已經是最后一個，就會執行<see cref="ICommandHandler{TCommand}"/>。
        /// </summary>
        void ExecuteNext();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Happy.ExtensionMethod.Reflection;

namespace Happy.Command.Internal
{
    internal sealed class CommandExecuteContext : ICommandExecuteContext
    {
        private CommandInterceptorChain _commandInterceptorChain;

        internal CommandExecuteContext(ICommandService commandService, ICommand command, Action commandExecutor)
        {
            this.CommandService = commandService;
            this.Command = command;
            _commandInterceptorChain = new CommandInterceptorChain(
                this,
                command.GetType().GetAttributes<CommandInterceptorAttribute>(),
                commandExecutor);
        }


        public ICommandService CommandService
        {
            get;
            private set;
        }

        public ICommand Command { get; private set; }

        public void ExecuteNext()
        {
            _commandInterceptorChain.ExecuteNext();
        }
    }
}

管道過濾器的內部實現

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Command.Internal
{
    internal sealed class CommandInterceptorChain
    {
        private ICommandExecuteContext _commandExecuteContext;
        private CommandInterceptorAttribute[] _commandInterceptors;
        private Action _commandExecutor;
        private int _currentCommandInterceptorIndex = -1;

        internal CommandInterceptorChain(
            ICommandExecuteContext commandExecuteContext,
            CommandInterceptorAttribute[] commandInterceptors,
            Action commandExecutor)
        {
            _commandExecuteContext = commandExecuteContext;
            _commandInterceptors = commandInterceptors.OrderBy(x => x.Order).ToArray();
            _commandExecutor = commandExecutor;
        }

        private CommandInterceptorAttribute CurrentCommandInterceptor
        {
            get
            {
                return _commandInterceptors[_currentCommandInterceptorIndex];
            }
        }

        internal void ExecuteNext()
        {
            _currentCommandInterceptorIndex++;

            if (_currentCommandInterceptorIndex < _commandInterceptors.Length)
            {
                this.CurrentCommandInterceptor.Intercept(_commandExecuteContext );
            }
            else
            {
                _commandExecutor();
            }
        }
    }
}

命令服務，負責執行命令

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

using Common.Logging;
using Microsoft.Practices.ServiceLocation;

using Happy.DesignByContract;

namespace Happy.Command.Internal
{
    internal sealed class DefaultCommandService : ICommandService
    {
        private readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();

        public void Execute<TCommand>(TCommand command)
            where TCommand : ICommand
        {
            command.MustNotNull("command");

            var context = this.CreateCommandExecuteContext(command);

            context.ExecuteNext();
        }

        public ICommandService AddService<T>(T service)
        {
            _services[typeof(T)] = service;

            return this;
        }

        public T GetService<T>()
        {
            return (T)_services[typeof(T)];
        }

        private CommandExecuteContext CreateCommandExecuteContext<TCommand>(TCommand command)
            where TCommand : ICommand
        {

            return new CommandExecuteContext(this, command, () =>
            {
                this.ExecuteCommandHandler(command);
            });
        }

        private void ExecuteCommandHandler<TCommand>(TCommand command)
            where TCommand : ICommand
        {
            ServiceLocator.Current.MustNotNull("ServiceLocator.Current");

            var commandHandler = ServiceLocator
                .Current
                .GetInstance<ICommandHandler<TCommand>>();

            commandHandler.Handle(command);
        }
    }
}

事務攔截器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;

namespace Happy.Command
{
    /// <summary>
    /// 事務攔截器。
    /// </summary>
    public sealed class TransactionAttribute : CommandInterceptorAttribute
    {
        /// <inheritdoc />
        public TransactionAttribute(int order) : base(order) { }

        /// <inheritdoc />
        public override void Intercept(ICommandExecuteContext context)
        {
            using (var ts = new TransactionScope())
            {
                context.ExecuteNext();

                ts.Complete();
            }
        }
    }
}

應用事務攔截器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Happy.Domain;
using Happy.Command;
using Happy.DesignByContract;

namespace Happy.Application
{
    /// <summary>
    /// 簡單的創建命令。
    /// </summary>
    [Transaction(1)]
    public abstract class SimpleCreateCommand<TAggregateRoot> : SimpleCommand<TAggregateRoot>
        where TAggregateRoot : AggregateRoot
    {
    }
}

執行命令

        /// <summary>
        /// 創建。
        /// </summary>
        public ActionResult Create(TAggregateRoot item)
        {
            this.CurrentCommandService.Execute(new TCreateCommand
            {
                Aggregate = item
            });

            return this.NewtonsoftJson(new
            {
                success = true,
                items = this.GetById(item.Id)
            });
        }

備注

這里的命令模式本質上是一種消息模式，因為命令里沒有任何行為，將行為獨立了出來。像WCF、ASP.NET和ASP.NET MVC本質上也是消息模式，他們也內置了管道過濾器模式。