自定义工作流 之 模型设计与实现

背景

在上篇文章（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);
}
}
}

备注

如果去掉分流和合流，流程还是比较容易处理的，分流和合流的思想会在下一篇文章重点介绍。