Tagged articles
LiteFlow
47 articles · Page 1 of 1
This tutorial demonstrates how LiteFlow v2.16+ integrates AI agents as native components, enabling developers to orchestrate LLMs like DeepSeek, Qwen, and OpenAI models using familiar LiteFlow operators (THEN, WHEN, IF) within Spring Boot applications.
AI AgentAgent orchestrationJava framework
0 likes · 14 min read

This article introduces the Liteflow rule‑engine framework, explains its core concepts, syntax, and configuration options, and walks through a complete Spring Boot 3.2 / Java 17 project that demonstrates building, deploying, and testing a multi‑step workflow with practical code examples.
EL SyntaxJava 17LiteFlow
0 likes · 14 min read

The article explains why scattered, frequently changing business rules cause maintenance headaches, and introduces a rule visualization configuration platform that provides visual authoring, validation, approval, gray release, and local execution to make complex rule iteration safer and more efficient.
Gray ReleaseLiteFlowSDK
0 likes · 28 min read

This article details replacing hardcoded business routing with LiteFlow in a Spring Boot production system, covering component design, EL-based flow orchestration, Nacos-powered hot rule updates, thread-pool tuning, exception isolation, observability, and rule versioning — with concrete code, config, and lessons learned.
Dynamic OrchestrationHot ReloadLiteFlow
0 likes · 19 min read

The article introduces the liteflow rule‑engine framework, explains its architecture, component types, EL rule files, data‑context handling, configuration options, and demonstrates a real‑world e‑commerce workflow that replaces verbose if‑else code with concise rule definitions.
ConfigurationJavaLiteFlow
0 likes · 9 min read

LiteFlow is a lightweight, open‑source Chinese rule engine that transforms tangled if‑else code into modular, hot‑deployable components using a simple EL DSL, offering high performance, multi‑language scripting, and visual orchestration for backend systems.
Component OrchestrationEL DSLHot Deployment
0 likes · 12 min read

This article introduces Liteflow, a lightweight yet powerful Java rule engine that enables developers to orchestrate complex serial and parallel business flows using concise XML/JSON/YAML definitions, supports hot‑deployment, multiple scripting languages, and provides detailed usage examples, component types, configuration, and a real‑world e‑commerce scenario.
JavaLiteFlowrule engine
0 likes · 13 min read

This article introduces Liteflow, a lightweight yet powerful rule engine for Spring Boot, covering its architecture, supported rule formats, component types, EL rule file syntax, data context handling, configuration options, and a real‑world e‑commerce workflow example that demonstrates parallel and sequential processing.
LiteFlowrule engineworkflow
0 likes · 12 min read

This article introduces LiteFlow, a lightweight yet powerful rule engine for Java Spring Boot, explains its architecture, supported rule formats, core components, EL rule syntax, data context handling, configuration options, and demonstrates a real e‑commerce workflow with code snippets and diagrams.
LiteFlowrule enginespring-boot
0 likes · 13 min read

This article introduces the Liteflow rule engine, explains its architecture, component types, EL rule syntax, data context handling, Spring Boot configuration, and demonstrates a real‑world e‑commerce order processing scenario with code examples and diagrams.
JavaLiteFlowspring-boot
0 likes · 13 min read

This article introduces LiteFlow, a lightweight Java flow engine, demonstrating how to replace verbose if‑else logic with concise rule files, covering its main features, IDEA plugin support, rule expression syntax, integration steps, component implementation, and a complete order‑price calculation example.
LiteFlowSpringBootbackend development
0 likes · 12 min read

This guide explores the core pain point of frequent business rule changes versus system stability, introduces five rule engines (Drools, Easy Rules, QLExpress, Aviator, LiteFlow), compares their performance, advantages, disadvantages, and provides practical selection tips and pitfalls to avoid.
AviatorDroolsEasy Rules
0 likes · 11 min read

This article introduces LiteFlow, a lightweight Java workflow engine, explains its key features, rule syntax, IDE plugin, integration steps with SpringBoot, component development, context handling, and provides practical code examples for building a complex order‑price calculation flow.
JavaLiteFlowSpringBoot
0 likes · 10 min read

This article examines the conflict between rapidly changing business rules and system stability, introduces rule engines as a solution, compares five widely used Java rule engines—including Drools, Easy Rules, QLExpress, Aviator, and LiteFlow—by their scenarios, advantages, disadvantages, performance, and provides practical guidance for selecting and avoiding common pitfalls.
AviatorDroolsEasy Rules
0 likes · 12 min read

This article introduces Liteflow, a lightweight yet powerful Java rule engine, explains its architecture, shows how to integrate it with Spring Boot, details its component types and EL rule syntax, and demonstrates a real‑world e‑commerce workflow using XML rule files.
JavaLiteFlowbackend development
0 likes · 13 min read

This article introduces the LiteFlow lightweight rule engine, explains its architecture, component types, EL rule files, data context handling, configuration options, and demonstrates a real‑world e‑commerce workflow with code examples, while also noting related promotional offers at the end.
JavaLiteFlowrule engine
0 likes · 12 min read

This article explains how to split a multi‑function OpenAPI endpoint into independent steps using the responsibility‑chain pattern in Spring, detailing the abstract component, context sharing, bean retrieval via ApplicationContext, and a controller that dynamically orders execution through a query parameter, with full code examples.
AOPChain of ResponsibilityDesign Pattern
0 likes · 9 min read

This article introduces LiteFlow, a lightweight yet powerful Java rule engine, explains its architecture, component types, EL rule file syntax, configuration options, and demonstrates a real‑world e‑commerce workflow example, providing code snippets and deployment tips for backend developers.
JavaLiteFlowbackend development
0 likes · 11 min read

This article introduces LiteFlow, a lightweight yet powerful rule engine for Spring Boot, explains its architecture, supported rule formats, core components, EL rule files, data context handling, configuration options, and demonstrates a real‑world e‑commerce order processing workflow with code examples.
JavaLiteFlow
0 likes · 10 min read

This article introduces the LiteFlow rule engine, explaining its architecture, supported rule file formats, component types, EL rule definitions, data context handling, configuration options, and demonstrates its application in an e‑commerce order processing scenario, highlighting hot‑deployment and performance benefits for Java backend development.
JavaLiteFlowbackend development
0 likes · 12 min read

This article introduces LiteFlow, a lightweight Java component‑based rule engine that decouples complex business logic, explains its workbench design, demonstrates usage in both non‑Spring and SpringBoot environments with Maven setup and XML configuration, and details its core components, parsing, chain execution, and node processing.
Component ArchitectureJavaLiteFlow
0 likes · 19 min read

LiteFlow is a lightweight Java rule engine that lets developers orchestrate serial and parallel business workflows using XML, JSON or YAML rule files stored in back‑ends like SQL or Zookeeper, offering NodeComponent, NodeSwitchComponent and NodeIfComponent types, EL syntax, Spring Boot integration, and high‑performance execution monitoring.
ELJavaLiteFlow
0 likes · 8 min read

By adopting LiteFlow’s lightweight low‑code workflow engine with a workbench‑component‑rule architecture, the team replaced repetitive custom code with configurable pipelines, achieving high decoupling, flexible orchestration, reduced development cost, and improved extensibility for complex business processes, while planning a visual backend platform.
Component ArchitectureLiteFlowbackend development
0 likes · 7 min read

LiteFlow is a lightweight Java flow‑orchestration framework that lets developers break complex business processes into independent Spring‑Boot node components, configure them via XML, and execute them with FlowExecutor, supporting conditional switches and loops while focusing on simple workflow modeling rather than role‑task management.
JavaLiteFlowSpringBoot
0 likes · 8 min read

This article examines the challenges of sprawling order‑processing code in logistics systems and presents a strategic component‑based approach using the open‑source LiteFlow framework, detailing its architecture, execution rules, example XML flow, Java implementations, and key advantages for scalable backend development.
Component ArchitectureJavaLiteFlow
0 likes · 10 min read

This article examines the challenges of scaling order‑processing logic in logistics systems and presents a component‑oriented solution using the open‑source LiteFlow framework, detailing its strategic “workbench” pattern, tactical component design, execution rules, and practical Java code examples for building flexible, decoupled workflows.
Component ArchitectureJavaLiteFlow
0 likes · 11 min read

This article introduces Liteflow, a lightweight yet powerful Java rule engine built on Spring Boot, explains its architecture, usage patterns, component types, EL rule files, data context handling, configuration options, and demonstrates a real‑world e‑commerce workflow, while also containing promotional material for related services.
BackendLiteFlowrule engine
0 likes · 12 min read

This article explains how the LiteFlow rule engine enables Java developers to define, configure, and execute complex serial and parallel business workflows using XML/JSON/YAML rule files, various node components, data contexts, and runtime parameters, with hot‑deployment and integration examples for Spring Boot projects.
JavaLiteFlowbackend development
0 likes · 9 min read

This article explains how to use the LiteFlow rule‑engine framework to define reusable Java components, express execution flows with EL expressions, design a visual canvas that converts JSON into an abstract syntax tree, generate valid EL code via DFS, and manage workflow updates through push‑pull refresh mechanisms, while also outlining benefits and future plans.
ASTEL expressionJava
0 likes · 18 min read

This article outlines the background, objectives, and system design of a strategy center for a recycling business, detailing how the LiteFlow rule engine enables modular, hot‑plugable workflow configuration, visual canvas support, node editing, and future plans for data dictionaries, security, and visual configuration back‑ends.
LiteFlowstrategy center
0 likes · 8 min read

This guide shows how to integrate the lightweight LiteFlow rule engine into a Spring Boot application, split complex business logic into reusable components, configure rule files, and use various component types—including switch, condition, and parameterized components—to achieve dynamic orchestration, hot‑reloading, and high scalability.
Component OrchestrationJavaLiteFlow
0 likes · 13 min read

This article presents Liteflow, a lightweight yet powerful Java rule engine that supports XML/JSON/YAML rule files, multiple storage backends, and hot‑deployment, and demonstrates its components, configuration, and a real‑world e‑commerce workflow example with code snippets.
BackendELJava
0 likes · 8 min read

This article introduces the lightweight yet powerful LiteFlow rule engine, explains its architecture, component types, EL rule files, data context handling, configuration, and demonstrates a practical e‑commerce workflow with hot‑deployment capabilities.
JavaLiteFlowrule engine
0 likes · 9 min read

This article introduces LiteFlow, a powerful rule‑engine framework for Spring Boot, explains its advantages, shows how to define rules in XML/JSON/YML, and provides a complete end‑to‑end example with code snippets and hot‑swap components for flexible business logic.
JavaLiteFlowbackend development
0 likes · 9 min read

This article introduces LiteFlow, a lightweight yet powerful rule engine that enables rapid development of complex workflow orchestration through XML/JSON/YAML rule files, supports various component types, data context handling, and hot‑deployment, and provides a complete Spring Boot integration example.
LiteFlowrule enginespring-boot
0 likes · 8 min read

This article introduces LiteFlow, a lightweight Java workflow engine, explains its core features, demonstrates rule syntax for serial, parallel, switch, and conditional orchestration, and provides step‑by‑step integration examples—including Maven dependencies, configuration, component implementation, and controller usage—to simplify complex business processes.
JavaLiteFlowbackend development
0 likes · 13 min read

This article presents Liteflow, a lightweight yet powerful rule engine that enables developers to define and execute complex serial, parallel, switch, and conditional workflows using XML/JSON/YAML rule files, supports hot‑deployment, and integrates seamlessly with Spring Boot for high‑performance backend services.
LiteFlowbackend developmentrule engine
0 likes · 11 min read

This article explains how the LiteFlow rule engine can be used to design and execute serial, parallel, switch, and conditional business flows by defining components, EL rule files, data contexts, and configuration settings, and demonstrates its application with an e‑commerce order‑processing example.
BackendJavaLiteFlow
0 likes · 9 min read

This article explains the concepts, architecture, and practical usage of Liteflow, a lightweight Java rule engine that integrates with Spring Boot, supports various rule file formats, multiple component types, data contexts, and configuration options for building complex workflow processes in backend applications.
JavaLiteFlowrule engine
0 likes · 9 min read

This article introduces LiteFlow, a lightweight and fast component‑based rule engine that decouples complex business logic, explains its design principles, demonstrates usage in both non‑Spring and SpringBoot environments with Maven dependencies and XML configurations, and delves into its core components and execution flow through detailed source code analysis.
BackendJavaLiteFlow
0 likes · 18 min read

This article introduces LiteFlow, a lightweight yet powerful Java flow engine that enables developers to define complex business logic through concise rule files, demonstrates its key features, IDE plugin support, various orchestration expressions, and provides step‑by‑step integration examples with SpringBoot, code snippets, and a real‑world order‑price calculation use case.
Business LogicJavaLiteFlow
0 likes · 10 min read

This article explains how the LiteFlow component-based rule engine is used to design, configure, and execute flexible lightweight inspection reports, highlighting its modular architecture, real‑time component management, data context handling, and integration with configuration centers to reduce development overhead.
Component ArchitectureJavaLiteFlow
0 likes · 11 min read

This article introduces LiteFlow, a lightweight Java workflow engine that decouples complex business logic by modeling each step as a reusable component, explains its workbench design, demonstrates usage in both non‑Spring and Spring Boot environments, and walks through its core architecture and execution flow.
Business LogicJavaLiteFlow
0 likes · 18 min read

This article provides an in‑depth technical comparison between the mature Drools rule engine and the newer LiteFlow framework, covering definitions, expression syntax, Java integration, API usage, coupling, learning curve, tooling, storage, hot‑reloading, UI support, performance benchmarks, and overall suitability for complex business logic.
DroolsJavaLiteFlow
0 likes · 15 min read

Facing a tangled SMS routing system with many third‑party providers, I replaced cumbersome if‑else and serial queries with LiteFlow’s lightweight rule engine, using parallel checks, EL expressions, sub‑variables, and context‑based data flow to create a flexible, maintainable, and hot‑reloadable workflow, even for multithreaded tasks.
EL ExpressionsHot ReloadJava
0 likes · 16 min read

This article introduces LiteFlow, a lightweight, fast, and stable component‑based rule engine, explains its design principles, shows step‑by‑step usage in both non‑Spring and Spring Boot environments, and dives into the core source code that drives parsing, chain execution, and node processing.
BackendLiteFlowcomponent-based
0 likes · 19 min read

This article introduces four powerful Java open‑source projects from the Dromara community—Sa‑Token for lightweight permission authentication, Forest as an elegant HTTP client, LiteFlow for component‑based workflow orchestration, and JPom for lightweight DevOps—detailing their core features, usage examples, and how they boost developer productivity.
BackendForestJava
0 likes · 18 min read
