企业应用：一个够用的、通用的状态机（管理实体的业务状态）

背景

企业应用下，需要关注三个状态机：

• 业务相关的状态机。
• 审批流程相关的状态机。
• 持久化相关的状态机。

某些企业应用开发人员终其一生就是希望能开发出通用的一个框架以简化这些状态机的开发。本文重点关注：“业务相关的状态机”。

常见的状态机需求

产品的状态机

单据的状态机

业务相关的状态机的一般性需求如下：

• 当处于某个状态时，可以执行哪些合法的迁移？迁移的前置条件是什么？
• 当处于某个状态时，可以执行哪些合法的操作？如：已提交和已审核状态的单据不能被修改。

实现状态机

我目前使用过两种思路实现这种状态机：

1. 使用状态模式。这种要求为每种单据的状态管理定义一套状态体系，有点麻烦了。
2. 使用状态表格。这种就是本文介绍的。

下面先看两个示例。

一个简单的示例

注意下面的链式配置代码，这些代码表达的意思是：

In(Status.UnSaved).When(Operation.Save).If(CanSave).TransferTo(Status.Saved)

处于 UnSaved 状态下，当 Save 操作发生时，如果 CanSave，就迁移到 Saved 状态。

------------------------------------------------------------------------------------

.In(Status.UnSaved).When(Operation.Edit).Aways().Ok()

处于 UnSaved 状态下，当 Edit 操作发生时，总是，允许的。

代码

    class Order
    {
        private readonly StateMachine<Status, Operation> _stateMachine;

        public Status Status { get; internal set; }

        public Order()
        {
            _stateMachine = StateMachine<Status, Operation>
                    .Config(() => this.Status, status => this.Status = status)
                    .In(Status.UnSaved).When(Operation.Save).Aways().TransferTo(Status.Saved)
                    .In(Status.Saved).When(Operation.Submit).Aways().TransferTo(Status.Submitted)
                    .Done();
        }

        public void Save()
        {
            _stateMachine.Schedule(Operation.Save);
        }

        public void Submit()
        {
            _stateMachine.Schedule(Operation.Submit);
        }

        public void Edit()
        {
            _stateMachine.Schedule(Operation.Edit);
        }
    }

测试

    [TestClass]
    public class StateMachineTest
    {
        [TestMethod]
        public void ValidSave()
        {
            var order = new Order { Status = Status.UnSaved };
            order.Save();

            Assert.AreEqual(Status.Saved, order.Status);
        }

        [TestMethod]
        [ExpectedException(typeof(StateScheduleException))]
        public void InvalidSubmit()
        {
            var order = new Order { Status = Status.UnSaved };
            order.Submit();
        }
    }

一个相对完善的例子

代码

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

using Happy.Domain;
using Happy.StateManager;

namespace Happy.Examples.ManufactureManagement.Domain.Bases
{
    public abstract class MIAggregateRoot<TItem> : AggregateRoot<Guid>
    {
        protected MIAggregateRoot()
        {
            this.StateMache =
                StateMachine<Status, Operation>
                .Config(() => this.Status, status => this.Status = status)
                .In(Status.UnSaved).When(Operation.Save).If(CanSave).TransferTo(Status.Saved)
                .In(Status.UnSaved).When(Operation.Edit).Aways().Ok()
                .In(Status.Saved).When(Operation.Submit).If(this.CanSubmit).TransferTo(Status.Submitted)
                .In(Status.Saved).When(Operation.Edit).Aways().Ok()
                .In(Status.Submitted).When(Operation.Verify).If(this.CanVerify).TransferTo(Status.Verified)
                .Done();

            // ReSharper disable DoNotCallOverridableMethodsInConstructor
            this.Items = new Collection<TItem>();
            // ReSharper restore DoNotCallOverridableMethodsInConstructor
        }

        protected StateMachine<Status, Operation> StateMache { get; private set; }

        protected internal virtual ICollection<TItem> Items { get; protected set; }

        internal Status Status { get; set; }

        protected virtual bool CanSave()
        {
            return true;
        }

        protected virtual bool CanSubmit()
        {
            return true;
        }

        protected virtual bool CanVerify()
        {
            return true;
        }

        internal void Save()
        {
            this.StateMache.Schedule(Operation.Save);
        }

        internal void Submit()
        {
            this.StateMache.Schedule(Operation.Submit);
        }

        internal void Verify()
        {
            this.StateMache.Schedule(Operation.Verify);
        }

        internal void AddItem(TItem item)
        {
            this.AddItems(new List<TItem> { item });
        }

        internal void AddItems(IEnumerable<TItem> items)
        {
            this.StateMache.Schedule(Operation.Edit);

            foreach (var item in items)
            {
                this.Items.Add(item);
            }
        }

        internal void DeleteItem(TItem item)
        {
            this.DeleteItems(new List<TItem> { item });
        }

        internal void DeleteItems(IEnumerable<TItem> items)
        {
            this.StateMache.Schedule(Operation.Edit);

            foreach (var item in items)
            {
                this.Items.Remove(item);
            }
        }
    }
}

测试

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

using Happy.StateManager;
using Happy.Examples.ManufactureManagement.Domain.Bases;
using Happy.Examples.ManufactureManagement.Domain.QualityTests;

namespace Happy.Examples.ManufactureManagement.Domain.Test.QualityTests
{
    [TestClass]
    public class QualityTestTest
    {
        [TestMethod]
        public void TestUnSavedQualityTest()
        {
            var entity = this.MockUnQualityTest(Status.UnSaved);
            entity.AddItem(new QualityTestItem(Guid.NewGuid(), entity.Id));
            entity.Save();

            Assert.AreEqual(Status.Saved, entity.Status);
        }

        [TestMethod]
        public void TestSavedQualityTest()
        {
            var entity = this.MockUnQualityTest(Status.Saved);
            entity.AddItem(new QualityTestItem(Guid.NewGuid(), entity.Id));
            entity.Submit();

            Assert.AreEqual(Status.Submitted, entity.Status);
        }

        [TestMethod]
        [ExpectedException(typeof(StateScheduleException))]
        public void TestSubmittedQualityTest()
        {
            var entity = this.MockUnQualityTest(Status.Submitted);
            entity.AddItem(new QualityTestItem(Guid.NewGuid(), entity.Id));
        }

        private QualityTest MockUnQualityTest(Status status)
        {
            return new QualityTest
                {
                    Id = Guid.NewGuid(),
                    Status = status
                };
        }
    }
}

实现代码

代码

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

using Happy.ExtentionMethods;
using Happy.StateManager.Configuration;

namespace Happy.StateManager
{
    /// <summary>
    /// 状态机。
    /// </summary>
    public sealed class StateMachine<TState, TOperation>
    {
        private readonly List<Transition<TState, TOperation>> _transitions = new List<Transition<TState, TOperation>>();
        private readonly Func<TState> _stateGetter;
        private readonly Action<TState> _stateSetter;

        /// <summary>
        /// 构造方法。
        /// </summary>
        public StateMachine(Func<TState> stateGetter, Action<TState> stateSetter)
        {
            stateGetter.MustNotNull("stateGetter");
            stateSetter.MustNotNull("stateSetter");

            _stateGetter = stateGetter;
            _stateSetter = stateSetter;
        }

        /// <summary>
        /// 配置状态机。
        /// </summary>
        public static IConfig<TState, TOperation> Config(Func<TState> stateGetter, Action<TState> stateSetter)
        {
            stateGetter.MustNotNull("stateGetter");
            stateSetter.MustNotNull("stateSetter");

            return new Config<TState, TOperation>(stateGetter, stateSetter);
        }

        /// <summary>
        /// 配置状态迁移。
        /// </summary>
        public StateMachine<TState, TOperation> ConfigTransition(
            TState sourceState,
            TOperation operation,
            ICondition condition,
            TState targetState)
        {
            sourceState.MustNotNull("sourceState");
            operation.MustNotNull("operation");
            condition.MustNotNull("condition");
            targetState.MustNotNull("targetState");

            var transition = new Transition<TState, TOperation>(
                    sourceState,
                    operation,
                    condition,
                    targetState);

            _transitions.Add(transition);

            return this;
        }

        /// <summary>
        /// 使用<paramref name="operation"/>调度状态机。
        /// </summary>
        public void Schedule(TOperation operation)
        {
            operation.MustNotNull("operation");

            var currentState = _stateGetter();
            var transition = _transitions
                .FirstOrDefault(x =>
                    x.SourceState.Equals(currentState)
                    &&
                    x.Operation.Equals(operation)
                    &&
                    x.Condition.IsSatisfied());

            if (transition == null)
            {
                throw new StateScheduleException(currentState, operation);
            }

            _stateSetter(transition.TargetState);
        }
    }
}

说明

内部就是一个状态表格，没啥交代的，有兴趣的朋友可以去 http://happy.codeplex.com/SourceControl/latest，找到 Happyframework/Src/Happy.StateManager 下载最新代码看看。

进一步交代的问题

如果需要在真实的项目中使用这个模式，有两个问题还需要解决：

第一个问题：迁移的前置条件判断和后置操作的执行如果需要更多的信息，而这些信息不在实体内，怎么办？处理这个问题有很多种方式，这里介绍一下我目前最偏好的一种，引入领域服务：

领域服务代码

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

using Happy.Examples.ManufactureManagement.Domain.QualityTests;
using Happy.Examples.ManufactureManagement.Domain.SmallCuts;

namespace Happy.Examples.ManufactureManagement.Domain.Services
{
    public sealed class QualityTestManager
    {
        private readonly ISmallCutRepository _smallCutRepository;

        public QualityTestManager(ISmallCutRepository smallCutRepository)
        {
            _smallCutRepository = smallCutRepository;
        }

        public void Save(
            QualityTest qualityTest,
            IEnumerable<QualityTestItem> addedItems,
            IEnumerable<QualityTestItem> deletedItems)
        {
            qualityTest.AddItems(addedItems);
            qualityTest.DeleteItems(deletedItems);

            qualityTest.Save();

            this.AcquireLocks(qualityTest, addedItems);
            this.ReleaseLocks(qualityTest, deletedItems);
        }

        public void Submit(
            QualityTest qualityTest,
            IEnumerable<QualityTestItem> addedItems,
            IEnumerable<QualityTestItem> deletedItems)
        {
            qualityTest.AddItems(addedItems);
            qualityTest.DeleteItems(deletedItems);

            qualityTest.Submit();

            this.AcquireLocks(qualityTest, addedItems);
            this.ReleaseLocks(qualityTest, deletedItems);
        }

        public void Verify(QualityTest qualityTest)
        {
            qualityTest.Verify();

            foreach (var item in qualityTest.Items)
            {
                var smallCut = _smallCutRepository.Load(item.SmallCutId);
                smallCut.ReleaseLock(CreateLockInfo(qualityTest));
            }
        }

        private void AcquireLocks(QualityTest qualityTest, IEnumerable<QualityTestItem> addedItems)
        {
            foreach (var item in addedItems)
            {
                var smallCut = _smallCutRepository.Load(item.SmallCutId);
                smallCut.AcquireLock(CreateLockInfo(qualityTest));
            }
        }

        private void ReleaseLocks(QualityTest qualityTest, IEnumerable<QualityTestItem> deletedItems)
        {
            foreach (var item in deletedItems)
            {
                var smallCut = _smallCutRepository.Load(item.SmallCutId);
                smallCut.ReleaseLock(CreateLockInfo(qualityTest));
            }
        }

        private static LockInfo CreateLockInfo(QualityTest qualityTest)
        {
            return new LockInfo(LockType.LockByQualityTest, qualityTest.Id);
        }
    }
}

第二个问题：之前我只需要在 UI 中控制好这种状态机就行了，如果移动到了领域层，UI 也要重复一遍了，如何消除这种重复，答案是：引入元编程，让 UI 能自动识别这些元数据，最小化重复，这里就不给出实现（还没做）。

备注

上面状态机的配置过程也很有意思，In后只能是When，When后可以是If或Always，有点类似语法树了，找个机会可以写篇文章（实现是很简单的）。