Escape the if‑else Nightmare with Powerful Workflow Orchestration

Problem

When a middle‑platform serves dozens of business lines, developers often accumulate large if‑else blocks. Adding a new business requires editing the same tangled code, increasing the risk of regressions and online failures.

Solution

Introduce a dedicated flow engine that isolates business logic into independent flow nodes and configures a separate execution chain for each business scenario. A plugin‑extension engine provides the differentiated implementation for each business.

Example Project – MemberClub

The open‑source MemberClub project (hosted on Gitee) demonstrates both techniques. It implements a paid‑membership transaction solution and contains the flow‑engine implementation.

https://gitee.com/juejinwuyang/memberclub

https://gitee.com/-/ide/project/juejinwuyang/memberclub/edit/master/-/memberclub.common/src/main/java/com/memberclub/common/flow/FlowChainService.java

Configuring a Flow Execution Chain

Different membership products require different transaction flows. The class DemoMemberPurchaseExtension implements a purchase extension point and registers three execution‑chain configurations.

Defining Flow Nodes

Each node implements four lifecycle methods:

process

success

rollback

callback

The engine invokes these methods during execution, separating business logic, success handling, compensation, and final callbacks.

Flow Execution Process

Execution starts by creating a context object and calling FlowChain.execute. The engine iterates over the nodes, invoking process. If an exception occurs, the loop breaks and rollback is executed for all already‑processed nodes in reverse order. If no exception occurs, success is executed for each node in reverse order, followed by callback for every node.

public <T> void execute(FlowChain<T> chain, T context) {
    Exception exception = null;
    int index = -1;
    for (FlowNode<T> node : chain.getNodes()) {
        try {
            node.process(context);
            index++;
        } catch (Exception e) {
            if (e instanceof SkipException) {
                CommonLog.warn("Current flow:{} sent Skip request, stop further execution", node.getClass().getSimpleName());
                break;
            }
            exception = e;
            break;
        }
    }
    if (exception != null) {
        for (int i = index; i >= 0; i--) {
            FlowNode<T> node = chain.getNodes().get(i);
            try {
                node.rollback(context, exception);
            } catch (Exception e) {
                CommonLog.error("rollback error, ignore name:{}", node.getClass().getSimpleName(), e);
            }
        }
    } else {
        for (int i = index; i >= 0; i--) {
            FlowNode<T> node = chain.getNodes().get(i);
            try {
                node.success(context);
            } catch (Exception e) {
                CommonLog.error("success error, ignore name:{}", node.getClass().getSimpleName(), e);
            }
        }
    }
    for (int i = index; i >= 0; i--) {
        FlowNode<T> node = chain.getNodes().get(i);
        try {
            node.callback(context, exception);
        } catch (Exception e) {
            CommonLog.error("callback error, ignore name:{}", node.getClass().getSimpleName(), e);
        }
    }
    if (exception != null) {
        throw exception;
    }
}

Effect

By isolating business logic into independent flow nodes and configuring execution chains per business, the approach eliminates sprawling if‑else structures, simplifies testing, and reduces the chance of accidental regressions when adding new business scenarios.