我要投稿

一文讲透程序编排的核心方式：从表达式语言到并行化实践

发布日期：2025-05-28 18:03:23 浏览次数： 1545 作者：阿里云开发者

引言

在构建复杂的数据处理系统或任务调度平台时，如何将业务逻辑高效、灵活地表达出来，并以可扩展的方式进行执行，是许多工程师和架构师面临的核心挑战之一。本文从“程序编排”的角度出发，探讨在实际项目中常见的几种核心编排方式——包括单语句表达式、类结构映射、流程化配置以及并行化调度，并结合一个真实系统的演进过程，分享我们在设计高灵活性任务处理引擎中的实践经验。

这些编排方式不仅适用于特定的数据处理场景，更是一种通用的系统设计思维。无论你是开发数据流水线、搭建自动化运营平台，还是构建低代码任务引擎，掌握这些模式，都能帮助你在面对复杂逻辑时更加游刃有余。

编排介绍

单语句编排(表达式语言)

表达式语句相对比较容易上手一些，其语法更接近 Java，而且有些表达式引擎还会将表达式编译成字节码，在执行速度和资源利用方面可能就更有优势。因此在业务没那么复杂，并且不想硬编码写的话，使用表达式语句性价比最高。犀牛系统中多处使用了表达式语句，通过数据库中配置表达式语句，提高系统灵活性。

MVEL(MVFLEX Expression Language)

MVEL是一个基于java语法的表达式，为JAVA语言提供便捷灵活的动态性，是部分规则引擎的底层调用。

使用示例如下:

        String expression = "score > 60";        HashMap<String, Integer> vars = new HashMap<>(1);        vars.put("score", 100);        if ((Boolean)MVEL.eval(expression, vars)) {            System.out.println("分数及格");        }

OGNL(Object-Graph Navigation Language)

OGNL主要用于获取和设置Java对象的属性，主要通过反射的方式实现。

使用方式：

        Map<String, Object> map = new HashMap<>();        map.put("key", "value");        String expression = "#{key}";        OgnlContext context = buildContext();        Object result = Ognl.getValue(expression,context, map);        System.out.println(result);

Aviator

Aviator是一门高性能、轻量级的Java语言实现的表达式动态求值引擎，可将表达式编译成字节码。其有两种执行方式: 编译执行和不编译执行。

使用方式:

        String expression = "a * (b - c)";        Map<String, Object> env = new HashMap<>();        env.put("a", 3.3);        env.put("b", 2.2);        env.put("c", 1.1);        int num = 10000;        // 编译        long l = System.nanoTime();        Expression compliedExp = AviatorEvaluator.compile(expression);        for (int i = 0; i < num; i++) {            compliedExp.execute(env);        }        System.out.println((System.nanoTime() - l) / 1000000);        l = System.nanoTime();        //不编译        for (int i = 0; i < num; i++) {            AviatorEvaluator.execute(expression, env);        }        System.out.println((System.nanoTime() - l) / 1000000);

编译和不编译耗时相差7倍，但由于编译之后占用内存，首次编译加载耗时较长，因此需要根据调用次数以及编译成本，判断是否有必要进行编译。

总结：

如果追求性能，并且主要是简单的动态计算的话，不需要对对象进行操作，可以使用Aviator。如果方法调用和对象属性的访问等，倾向于使用OGNL，其基于反射，操作比较灵活。而MCEL介于两者之间。较为适合快速开发。当然以上限制也不是绝对的，如果追求性能可以对其进行优化，如在OGML或者MVEL加一层缓存，命中缓存可以加快响应速度。

类编排

在项目开发当中，经常会出现某个类的属性或几个属性是另外一个类的查询条件，无论是数据库查询还是rpc调用，需要显式手动拼接，并且由于使用范围不同，只会取某些类，随着项目的迭代，这往往会导致代码中混乱调用，以及业务中有众多相似代码，但如果统一在一起加载，例如使用聚合根的思想，又会造成某些不需要的类加载，造成读放发大。本节介绍model-view-builder框架，来解决上述问题。

model-view-builder

github地址: https://github.com/PhantomThief/model-view-builder，这是一个能力非常强大的框架，其使用函数式编程定义加载动作，树状结构关联加载类，懒加载延时构建。

函数式编排

SimpleModelBuilder builder = new SimpleModelBuilder<SimpleBuildContext>()                .self(TaskInfo.class, TaskInfo::getTaskId)                .on(TaskInfo.class).id(TaskInfo::getTaskId).to(Decision.class)                .on(TaskInfo.class).id(TaskInfo::getTaskId).to(Disposal.class)                .on(TaskInfo.class).id(TaskInfo::getTaskId).to(RiskControl.class)                .on(TaskInfo.class).id(TaskInfo::getPoiId).to(DeepInfo.class)                .on(TaskInfo.class).id(TaskInfo::getPoiId).to(PoiInfo.class)                .build(Decision.class, decisionDao::getDecisionMap)                .build(Disposal.class, disposalDao::getDisposalMap)                .build(RiskControl.class, riskControlDao::getRiskControlMap)                .build(DeepInfo.class, deepInfoDao::getDeepInfoMap)                .build(PoiInfo.class, poiInfoDao::getPoiInfoMap);

树状结构关联

懒加载构建

builder = new SimpleModelBuilder<UgcBuildContext>()        .self(A.class, A::getId)        .lazyBuild(A.class,                        (BuildContext context, Collection<String> ids)                                -> BService.get(ids),                        B.class)//只有在调用获取的B的时候，才会执行BService.get取值逻辑buildContext.get(B.class)

其中lazyBuild是懒加载，只有在读取的时候会调用；重复获取数据的时候也不会重复调用，可以避免读放大。

该框架使用多层Map维护类与函数，以及类与类之间的映射关系，使其具有编排、聚合的能力，这些能力天然就适合领域划分，通过领域划分确定边界作为上下文信息，在方法中传递使用，提高代码可读性的同时，也为研发人员提供高效获取数据的体验。

业务示例描述：有这么一个需求，先查询帖子，再查询评论，最后查询是否是粉丝。

构建modelBuilder

构建与读取结果

框架缺点同样也很明显：

学习成本高，需要熟悉函数式编程，才能熟练驾驭；
接口限制，接口返回限定Map，需要接口改造和兼容(也可以改造框架适应)；
隐式调用，可读性不好；

在考虑引入该框架的时候，需要考虑以上缺点在团队中是否成问题，如果没问题，可放心使用，你大概率会成为它的重度用户。

流程编排

有限状态机编排

如果项目中有很多实体，每个实体都有很多状态，各状态会经过不同事件触发后转换到另一个状态，当实体状态或者状态转换变多时，处理这些状态的业务代码会分散在各处，往往会对开发和维护造成不小的挑战，有限状态机可以缓解这一情况。

使用状态机来表达状态的流转，语义会更加清晰，会增强代码的可读性和可维护性。

Stateless4j

stateless4j是一个轻量级的状态机库，其核心概念是基于枚举的事件和状态。

例子：超级玛丽闯关

    publicfinalstatic StateMachineConfig<CurrentState,Trigger> config = new StateMachineConfig<>();
    static {        //最初为小状态        config.configure(CurrentState.SMALL)            .permit(Trigger.MUSHROOM,CurrentState.BIG) //遇到蘑菇触发-->big状态            .permit(Trigger.MONSTER,CurrentState.DEAD); //妖怪触发,死亡状态        //最初为大状态        config.configure(CurrentState.BIG)            .ignore(Trigger.MUSHROOM)            .permit(Trigger.FLOWER,CurrentState.ATTACH) //遇到花花,状态变为可攻击状态            .permit(Trigger.MONSTER,CurrentState.SMALL); //遇到妖怪,状态变为small        //最初为攻击状态        config.configure(CurrentState.ATTACH)            .ignore(Trigger.MUSHROOM)            .ignore(Trigger.FLOWER)            .permit(Trigger.MONSTER,CurrentState.SMALL); //遇到妖怪,状态变为small        //最初为死亡状态        config.configure(CurrentState.DEAD)            .ignore(Trigger.MUSHROOM)            .ignore(Trigger.FLOWER)            .ignore(Trigger.MONSTER);
    }

代码逻辑如下：

    privatestatic StateMachine<CurrentState,Trigger> stateMachine =       new StateMachine<CurrentState, Trigger>(CurrentState.BIG,StateConver.config);    publicstaticvoidmain(String[] args){        stateMachine.fire(Trigger.FLOWER);        System.out.println("currentState-->"+stateMachine.getState());    }

当前状态为大马里奥，当遇到花之后，状态就变为可攻击了。

Cola-StateMachine

是一个功能丰富的状态机框架，支持XML和Java API定义状态机，提供图形化建模工具。

使用起来比较复杂，这里就贴一个github地址：https://github.com/spring-projects/spring-statemachine.git

总结：Cola-StateMachine比stateless4j功能更丰富，更完备，有更多高级的玩法。

语法树编排

Antlr4

Antlr4具有强大的语法分析能力，可以生成解析指定语言的Java代码；可用于解析和处理各种数据格式，帮助我们快速构建数据解析器，同时也有静态代码分析的能力。

使用示例：解析某文件格式

定义g4文件：

grammar load;    //定义规则文件grammar//parserssta:(load ender)*;  //定义sta规则，里面包含了*（0个以上）个 load ender组合规则ender:';';  //定义ender规则，是一个分号load   //定义load    :  LOAD format '.' path  as tableName //load语法规则,大致就是 load json.'path' as table1，load语法里面含有format，path， as，tableName四种规则    ;    //load规则结束符as: AS;   //定义as规则，其内容指向AS这个lexertableName: identifier;  //tableName 规则，指向identifier规则format: identifier;   //format规则，也指向identifier规则path: quotedIdentifier; //path,指向quotedIdentifieridentifier: IDENTIFIER | quotedIdentifier;  //identifier，指向lexer IDENTIFIER  或者parser quotedIdentifierquotedIdentifier: BACKQUOTED_IDENTIFIER;  //quotedIdentifier,指向lexer BACKQUOTED_IDENTIFIER//lexers antlr将某个句子进行分词的时候，分词单元就是如下的lexer//keywords  定义一些关键字的lexer，忽略大小写AS: [Aa][Ss];LOAD: [Ll][Oo][Aa][Dd];//base  定义一些基础的lexer,fragment DIGIT:[0-9];   //匹配数字fragment LETTER:[a-zA-Z];  //匹配字母STRING        //匹配带引号的文本    : '\'' ( ~('\''|'\\') | ('\\' .) )* '\''    | '"' ( ~('"'|'\\') | ('\\' .) )* '"'    ;IDENTIFIER    //匹配只含有数字字母和下划线的文本    : (LETTER | DIGIT | '_')+    ;BACKQUOTED_IDENTIFIER   //匹配被``包裹的文本    : '`' ( ~'`' | '``' )* '`'    ;//--hiden  定义需要隐藏的文本，指向channel(HIDDEN)就会隐藏。这里的channel可以自定义，到时在后台获取不同的channel的数据进行不同的处理SIMPLE_COMMENT: '--' ~[\r\n]* '\r'? '\n'? -> channel(HIDDEN);   //忽略行注释BRACKETED_EMPTY_COMMENT: '/**/' -> channel(HIDDEN);  //忽略多行注释BRACKETED_COMMENT : '/*' ~[+] .*? '*/' -> channel(HIDDEN) ;  //忽略多行注释WS: [ \r\n\t]+ -> channel(HIDDEN);  //忽略空白符
// 匹配其他的不能使用上面的lexer进行分词的文本UNRECOGNIZED: .;

文件自动生成：

覆盖BaseListen的enterLoad方法：

测试代码：

    publicstaticvoidmain(String[] args){        String oriStr = "load json.`F:\\tmp\\temp.json` as temp;";        ANTLRInputStream input = new ANTLRInputStream(oriStr);        loadLexer lexer = new loadLexer(input);        CommonTokenStream tokens = new CommonTokenStream(lexer);        loadParser parser = new loadParser(tokens);        loadParser.LoadContext tree = parser.load();        MyLoadListener listener = new MyLoadListener();        ParseTreeWalker.DEFAULT.walk(listener,tree);    }

结果：

可以看到这个框架非常强大，但是理解成本和实现成本比较高，如果你发现市面上没有框架实现你想要的编排能力，可以考虑使用该框架进行挑战。

引擎编排

Drools(规则引擎)

规则引擎的主要思想是将应用程序中的业务决策部分分离出来，使用指定的语句编写业务规则，由用户或开发者在需要时进行配置、管理。

drools是基于Java语言开发的开源规则引擎，将复杂的业务规则从硬编码中解放出来，以规则脚本的形式存储起来，当业务规则改变的时候不用修改代码。

示例如下：

规则配置：

//图书优惠规则package book.discountimport drools.Order
//规则一：所购图书总价在100元以下的没有优惠rule "book_discount_1"    when        $order:Order(originalPrice < 100)    then        $order.setRealPrice($order.getOriginalPrice());        System.out.println("成功匹配到规则一：所购图书总价在100元以下的没有优惠");end
//规则二：所购图书总价在100到200元的优惠20元rule "book_discount_2"    when        $order:Order(originalPrice < 200 && originalPrice >= 100)    then        $order.setRealPrice($order.getOriginalPrice() - 20);        System.out.println("成功匹配到规则二：所购图书总价在100到200元的优惠20元");end
//规则三：所购图书总价在200到300元的优惠50元rule "book_discount_3"    when        $order:Order(originalPrice <= 300 && originalPrice >= 200)    then        $order.setRealPrice($order.getOriginalPrice() - 50);        System.out.println("成功匹配到规则三：所购图书总价在200到300元的优惠50元");end
//规则四：所购图书总价在300元以上的优惠100元rule "book_discount_4"    when        $order:Order(originalPrice >= 300)    then        $order.setRealPrice($order.getOriginalPrice() - 100);        System.out.println("成功匹配到规则四：所购图书总价在300元以上的优惠100元");end

测试代码：

        KieServices kieServices = KieServices.Factory.get();        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();        //创建会话，用于和规则引擎交互        KieSession kieSession = kieClasspathContainer.newKieSession();        //构造订单对象，设置原始价格        Order order = new Order();        order.setOriginalPrice(210.0);        //将数据提供给规则引擎，规则引擎会根据提供的数据进行规则匹配        kieSession.insert(order);        //激活规则引擎，如果规则匹配成功则执行规则        kieSession.fireAllRules();        //关闭会话        kieSession.dispose();
        System.out.println("优惠前原始价格：" + order.getOriginalPrice() +            "，优惠后价格：" + order.getRealPrice());

结果：

配置文件和代码逻辑分开来，如果活动变动，只需要修改配置文件就行了。

BPMN(流程引擎)

流程引擎的关注的是业务流程，编排业务流程，使用文件或者指定语言规则进行配置。

示例代码：犀牛系统中任务的调度流程：

其中streamMainProcess为xml文件的key。

调用逻辑：

其中STREAM_PROCESS_DEF_KEY=streamMainProcess。

流程的配置和代码逻辑分开，如果变动流程只需要变动xml文件就可以了。

虽然规则引擎和流程引擎都可以将相应配置分开，但当业务较为复杂时，会有不易维护的特点，因此需要更方便的可视化来帮助理解，代表引擎有ice(https://waitmoon.com/)，通过二叉树组织，一个节点表示条件，另一个节点表示结果/动作。除此之外，规则引擎还有一定的性能问题，高并发业务下容易成为性能瓶颈。

并行化编排

如果有a，b，c，d四个线程，b，c运行的前提是a运行结束，d运行的前提是b，c运行结束。业务简单的话硬编码是没有问题的，但当并行线程达到十几个，你要如何进行进行编排呢，本节就此问题抛砖引玉，聊聊并行化编排。

CompleteFuture

CompletableFuture 是一种高级的并发工具，它允许你组合多个异步操作，创建复杂的异步流程。

使用示例如下：

        CompletableFuture<String> taskA = CompletableFuture.supplyAsync(() -> executeA());        CompletableFuture<String> taskC = taskA.thenApplyAsync(result -> executeC());        CompletableFuture<String> taskB = taskA.thenApplyAsync(result -> executeB());        CompletableFuture<Void> voidCompletableFuture =           CompletableFuture.allOf(taskC, taskB).whenComplete((result1, result2) -> executeD());        voidCompletableFuture.join();

可以看到CompletableFuture为我们提供了并发编排的能力，但如果线程数量较多，其维护性就比较差了。