自定義工作流 之 模型設計與實現

背景

在上篇文章（Workflow：自定義工作流 之 模型選擇）介紹了模型的選擇，這篇文章就介紹一下模型的設計與實現。

有些朋友會希望在這里看到：數據庫、持久化或審批人角色處理等代碼，我是領域驅動設計（DDD）的愛好者，因此很長一段時間內您是看不到這些代碼的，我覺得這些不是模型的核心。

模型設計

概念模型

模型規則如下

1、系統有活動（方塊或圓形）和路由（線條）組成，每種類型的活動支持不同的路由規則。

2、方塊代表人工活動，人工活動只能路由到一個目標節點，可以定義多個路由，但是只有一個路由會執行，這讓模型支持：順序和判定。

順序執行

判定執行

3、圓形代表並行活動，Split（分流）和Join（合流）必須成對出現，Split會導致多個活動並行執行，Join會合並這些並行執行的活動，這讓模式支持：並行。

並行執行

設計模型

工作流中涉及兩塊設計模型，一、定義模型（流程本身）；二、實例模型（流程的運行實例）。

定義模型

實例模型

我想類圖就沒有啥解釋的，這些類圖非常直觀的反映了概念模型，讓我們直接去看實現。

實現

活動基類

這里定義活動可以Enter（進入）和Exit（離開），當然前提是他們CanEnter（能進入）和CanExit（能離開），如果他們Enter或Exit了，會觸發OnEnter或OnExit。

Enter方法

        internal void Enter(WorkflowContext context, ActivityInstance activityInstance)
        {
            activityInstance.SetStateToEntering(context);

            if (!this.CanEnter(context, activityInstance))
            {
                return;
            }

            activityInstance.SetStateToEntered(context);

            this.OnEnter(context, activityInstance);
        }

Exit方法

        internal void Exit(WorkflowContext context, ActivityInstance activityInstance)
        {
            activityInstance.SetStateToExiting(context);

            if (!this.CanExit(context, activityInstance))
            {
                return;
            }

            activityInstance.SetStateToExited(context);

            this.OnExit(context, activityInstance);

            if (this.IsFinal)
            {
                context.WorkflowInstance.SetStateToCompleted(context);
            }
        }

人工活動

    /// <summary>
    /// 代表了流程中的一個人工節點。
    /// </summary>
    public class ManualActivity : Activity
    {
        /// <inheritdoc />
        protected override bool CanEnter(WorkflowContext context, ActivityInstance activityInstance)
        {
            return true;
        }

        /// <inheritdoc />
        protected override void OnEnter(WorkflowContext context, ActivityInstance activityInstance)
        {

        }

        /// <inheritdoc />
        protected override bool CanExit(WorkflowContext context, ActivityInstance activityInstance)
        {
            return true;
        }

        /// <inheritdoc />
        protected override void OnExit(WorkflowContext context, ActivityInstance activityInstance)
        {
            var routers = context
                .WorkflowInstance
                .Workflow
                .GetRoutersByFromId(this.Id);

            foreach (var router in routers)
            {
                //遇到第一個能執行的路由，進執行路由。
                if (router.GetCondition().CanRoute(context, activityInstance, router))
                {
                    router.Route(context, activityInstance);

                    break;
                }
            }
        }
    }

這里可以看到，人工活動實現了：順序和判定模式，您沒能看到：會簽、審批人規則等，這些會在后面增加進去，目前不是重點。

路由方法的代碼

 

這里除了分流令牌的創建，其它邏輯還是比較好理解的：創建目標活動實例，創建路由實例，執行目標活動（toActivity.Enter）。

腳本路由條件

    /// <summary>
    /// 腳本路由條件。
    /// </summary>
    public sealed class ScriptRouterCondition : IRouterCondition
    {
        private readonly string _serializedConditionContent;

        /// <summary>
        /// 構造方法。
        /// </summary>
        public ScriptRouterCondition(string serializedConditionContent)
        {
            _serializedConditionContent = serializedConditionContent;
        }

        /// <inheritdoc />
        public bool CanRoute(WorkflowContext context, ActivityInstance fromActivityInstance, Router router)
        {
            var engine = new ScriptEngine();

            foreach (var item in context.Agrs)
            {
                engine.SetGlobalValue(item.Key, item.Value);
            }

            return (bool)engine.Evaluate(_serializedConditionContent);
        }

        /// <inheritdoc />
        public string SerializedToString()
        {
            return _serializedConditionContent;
        }
    }

測試

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Linq;

using Happy.BasicModule.Activities.Domain.Workflows;
using Happy.BasicModule.Activities.Domain.WorkflowInstances;

namespace Happy.BasicModule.Activities.Test
{
    [TestClass]
    public class ConditionWorkflowTest
    {
        [TestMethod]
        public void Condition_Test()
        {
            var workflow = new Workflow
            {
                Id = Guid.NewGuid()
            };

            workflow.AddActivity(new ManualActivity
            {
                Id = Guid.NewGuid(),
                DisplayName = "A",
                IsFinal = false,
                Name = "A"
            }, true);
            workflow.AddActivity(new ManualActivity
            {
                Id = Guid.NewGuid(),
                DisplayName = "B1",
                IsFinal = true,
                Name = "B1"
            });
            workflow.AddActivity(new ManualActivity
            {
                Id = Guid.NewGuid(),
                DisplayName = "B2",
                IsFinal = true,
                Name = "B2"
            });

            var routerA_B1 = new Router
            {
                Id = Guid.NewGuid(),
                DisplayName = "A->B1",
                FromId = workflow["A"].Id,
                ToId = workflow["B1"].Id
            };
            routerA_B1.SetCondition(new ScriptRouterCondition("性別==\"男\""));
            workflow.AddRouter(routerA_B1);

            var routerA_B2 = new Router
            {
                Id = Guid.NewGuid(),
                DisplayName = "A->B2",
                FromId = workflow["A"].Id,
                ToId = workflow["B2"].Id
            };
            routerA_B2.SetCondition(new ScriptRouterCondition("性別==\"女\""));
            workflow.AddRouter(routerA_B2);


            var instance = new WorkflowInstance(workflow);
            var args = new Dictionary<string, object>
            {
                { "性別", "女" }
            };


            instance.Run(args);
            var activityInstances = instance.GetActivityInstances();
            var routerInstances = instance.GetRouterInstances();

            Assert.AreEqual(1, activityInstances.Length);
            Assert.AreEqual(ActivityState.Entered, activityInstances[0].State);
            Assert.AreEqual(WorkflowState.Running, instance.State);
            Assert.AreEqual(0, routerInstances.Length);


            instance.Resume(activityInstances[0].Id, args);
            activityInstances = instance.GetActivityInstances();
            routerInstances = instance.GetRouterInstances();

            Assert.AreEqual(2, activityInstances.Length);
            Assert.AreEqual(ActivityState.Exited, activityInstances[0].State);
            Assert.AreEqual(ActivityState.Entered, activityInstances[1].State);
            Assert.AreEqual(WorkflowState.Running, instance.State);
            Assert.AreEqual(1, routerInstances.Length);


            instance.Resume(activityInstances[1].Id, args);
            activityInstances = instance.GetActivityInstances();
            routerInstances = instance.GetRouterInstances();

            Assert.AreEqual(2, activityInstances.Length);
            Assert.AreEqual(ActivityState.Exited, activityInstances[0].State);
            Assert.AreEqual(ActivityState.Exited, activityInstances[1].State);
            Assert.AreEqual(WorkflowState.Completed, instance.State);
            Assert.AreEqual(1, routerInstances.Length);
            Assert.AreEqual("B2", workflow[activityInstances[1].ActivityId].Name);
        }
    }
}

備注

如果去掉分流和合流，流程還是比較容易處理的，分流和合流的思想會在下一篇文章重點介紹。