Implementing a Flow Engine and Plugin Extension for Business Isolation and Extensibility in Backend Systems

As a programmer, the author argues that simple solutions should be used for simple problems and warns against over‑design such as excessive use of if‑else branches, which leads to tangled code and difficult maintenance when supporting many business lines.

To solve code isolation and extensibility issues, the article proposes two approaches: using a process (flow) engine to configure separate execution chains for each business scenario, and employing a plugin‑extension engine to implement business‑specific differences.

The open‑source project MemberClub is presented as a real‑world example that applies both a flow engine and plugin extensions to handle paid‑membership transactions across various purchase scenarios.

Configuration of the flow chain is illustrated with the class DemoMemberPurchaseExtension , which defines three different execution chains. The flow nodes expose four methods: process , success , rollback , and callback .

During execution, the FlowChain.execute method runs each node's process method in order; if an exception occurs, the previously executed nodes' rollback methods are called in reverse order. If all process calls succeed, the success methods are invoked in reverse order, followed by a final callback for each node.

public
void execute(FlowChain
chain, T context) {
    Exception exception = null;
    int index = -1;
    for (FlowNode
node : chain.getNodes()) {
        try {
            node.process(context);
            index++;
        } catch (Exception e) {
            if (e instanceof SkipException) {
                CommonLog.warn("当前流程:{} 发出 Skip请求,后续流程不再执行", node.getClass().getSimpleName());
                break;
            }
            exception = e;
            break;
        }
    }
    // rollback or success handling omitted for brevity
    for (int i = index; i >= 0; i--) {
        FlowNode
node = chain.getNodes().get(i);
        try {
            node.callback(context, exception);
        } catch (Exception e) {
            CommonLog.error("callback执行异常,忽略 name:{}", node.getClass().getSimpleName(), e);
        }
    }
    if (exception != null) {
        throw exception;
    }
}

The article also provides links to the MemberClub repository on Gitee and GitHub, and lists the technologies used in the project, including MyBatis‑Plus, ShardingSphere, Redis/Redisson, Apollo, Spring Cloud, RabbitMQ, H2, Swagger, Lombok, MapStruct, and various custom components such as the flow engine, extension point engine, distributed retry component, logging component, inventory management, distributed lock, Redis Lua scripts, and Spring context utilities.

Overall, the piece serves as a tutorial on how to design a clean, extensible backend architecture using a flow engine and plugin mechanism, with concrete code snippets and an open‑source reference for deeper study.