java实现业务编排_手写实现一套流程编排&规则引擎

流程编排&规则引擎

什么是流程编排，什么是规则引擎呢？我们为什么需要使用它？

随着业务的不断发展，业务流程迭代慢慢变得复杂了起来，全景不清晰，这不仅仅会使开发人员编写代码弄的' 不敢改 '心理，以及出现问题不好寻找出错位置，历史包袱太重，影响面需要评估，等等。小橘也是感同身受～ 。一个本来很简单的需求，但是由于很多历史背景和包袱导致侵入代码需要评估改动影响面很大，这时候就需要一套流程编排&规则引擎来使得流程清晰，能全局感受到业务的能力地图。减少开发、测试等的维护迭代成本。

流程编排特点

流程配置化

通过配置化的方式形成业务规则，通过插拔某些组件形成新的规则，每条规则对应一个业务身份(比如，“餐饮商品下单”就是一个业务身份)，当我们需要新增业务身份，其实就是在对能力进行聚合编排，最终配置成我们需要的业务规则。

能力复用

在更多的业务身份产生的同时，更多的业务能力也被我们沉淀下来，能力会被编排进更多的业务规则中，在各个规则中复用。

业务细节聚合

在传统模式中，随着需求的不断迭代以及开发人员不同的编码习惯，越来越多的业务逻辑被分散在各个代码模块，给后续业务的理解和迭代造成很大的困难，而通过流程编排，不同的能力被分组聚合，各个能力职责单一，校验只做校验，装配只做装配。

通过执行引擎，实现技术细节和业务逻辑的分离

开发人员只需要定规则，具体的执行完全由执行引擎调度，强大的执行引擎通过其本身复杂的实现而让开发者获得更好的编码体验，如跨组件事务，依赖注入，监控等。

流程编排组件

参数校验 -- 业务校验 -- 事务前置扩展点 -- 业务参数装配 -- 事务执行 -- 事务结果装配 -- 事务后置扩展点

备注：节点不固定，根本具体业务评估需要哪些组件。

流程编排实现

下面我们就简单实现一个demo级的流程编排例子。

能力流程编排的各个组件我们通过上下文使它们环环相扣，定义如下：

package com.orangecsong.st.template;

import java.io.Serializable;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

/*** @Description: 上下文* @author: orangeCs* @create: 2020-08-22*/

public class Context implements Serializable {
private final Map,Object> CONTEXT = new ConcurrentHashMap<>();

public T get(Class clazz) {
return (T) CONTEXT.get(clazz);

}

public void put(Object obj) {
if(null == obj) {
return;

}

CONTEXT.put(obj.getClass(),obj);

}

}

事务执行模板,定义组件之间api，为了通用，我们这里将上下文注射到回调模板的泛型参数中

package com.orangecsong.st.template;

import com.orangecsong.bizclass.BaseResult;

/*** @Description: 流程引擎-执行事件接口* @author: orangeCs* @create: 2020-08-22*/

public interface ActionCallBack {
void paramValidate(C context);

void bizValidate(C context);

void beforeProcess(C context);

void process(C context);

void afterProcess(C context);

T assemble(C context);

}

考虑到某些业务无需扩展点交互，为此我们抽象出来。

package com.orangecsong.st.template;

import com.orangecsong.bizclass.BaseResult;

/*** @Description: 流程引擎-抽象执行事件接口* @author: orangeCs* @create: 2020-08-22*/

public abstract class AbstractActionCallBack implements ActionCallBack{
@Override

public void beforeProcess(C context) {
}

@Override

public void afterProcess(C context) {
}

}

接下来我们定义流程引擎具体实现类

package com.orangecsong.st.template;

import com.orangecsong.bizclass.BaseResult;

/*** @Description: 通用的执行器* @author: orangeCs* @create: 2020-08-22*/

public class GeneralActionCallBack extends AbstractActionCallBack {
@Override

public void paramValidate(Context context) {
}

@Override

public void bizValidate(Context context) {
}

@Override

public void process(Context context) {
}

@Override

public BaseResult assemble(Context context) {
return null;

}

}

为了业务流程中调用，我们封装对外调用API ,传入对应上下文、回调函数即可。

package com.orangecsong.st.template;

import com.orangecsong.bizclass.BaseResult;

/*** @Description:* @author: orangeCs* @create: 2020-08-22*/

public interface ServiceTemplate {
/*** @param context* @param action* @return*/

T invoke(C context, AbstractActionCallBack action);

}

对业务无感知的流程引擎实现

package com.orangecsong.st.template;

import com.orangecsong.bizclass.BaseResult;

/*** @Description: 服务模板* @author: orangeCs* @create: 2020-08-22*/

public class ServiceTemplateImpl implements ServiceTemplate{
@Override

public BaseResult invoke(Context context, AbstractActionCallBack action) {
//参数校验 paramValidate(context, action);

//业务校验 bizValidate(context, action);

//事务执行前置扩展点 beforeProcessCallBack(context, action);

//事务执行 processCallBack(context, action);

//事务执行后置扩展点 afterProcessCallBack(context, action);

//数据装配 return assemble(context, action);

}

private BaseResult assemble (Context context, AbstractActionCallBack action){
System.out.println("assemble");

return action.assemble(context);

}

private void afterProcessCallBack (Context context, AbstractActionCallBack action){
System.out.println("afterProcessCallBack");

action.afterProcess(context);

}

private void processCallBack (Context context, AbstractActionCallBack action){
System.out.println("processCallBack");

action.process(context);

}

private void beforeProcessCallBack (Context context, AbstractActionCallBack action){
System.out.println("beforeProcessCallBack");

action.beforeProcess(context);

}

private void bizValidate (Context context, AbstractActionCallBack action){
System.out.println("bizValidate");

action.bizValidate(context);

}

private void paramValidate (Context context, AbstractActionCallBack action){
System.out.println("paramValidate");

action.paramValidate(context);

}

}

最后我们写个测试程序测试一下

package com.orangecsong.st.client;

import com.orangecsong.bizclass.BaseResult;

import com.orangecsong.st.template.Context;

import com.orangecsong.st.template.ServiceTemplate;

import com.orangecsong.st.template.ServiceTemplateImpl;

/*** @Description: 测试服务模板流程引擎调用* @author: orangeCs* @create: 2020-08-22*

*     查询学生为某某某的人*     paramValidate 学生id不能为空 且大于0*     bizValidate 学生姓名不能带“cute”*     process 查询db 得到结果* 
*/
public class ServiceTemplateInvoke {
public static void main(String[] args) {
//构造上下文 Context context = new Context();

context.put(10);

StudentAction studentAction = new StudentAction();

ServiceTemplate serviceTemplate = new ServiceTemplateImpl();

final BaseResult invoke = serviceTemplate.invoke(context, studentAction);

System.out.println(invoke.getData());

}

}

最后强调一下，任务技术的引入都是一把双刃剑，我们还是需要根据具体的场景和业务评估采取哪种方式，如果业务简单，流程不复杂，我们引入了流程引擎，一是增加了对流程引擎使用了解的成本，二是杀鸡用牛刀，工具的使用宗旨是让我们处理高效。
————————————————
版权声明：本文为CSDN博主「化学小辣鸡toto」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_36164538/article/details/114542848