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本质上也是消息模式，他们也内置了管道过滤器模式。