Tagged articles
Expression Engine
18 articles · Page 1 of 1
This article introduces four of Spring Boot’s expression engines—Groovy, MVEL, JEXL, and JSP EL—showing how to add their Maven dependencies, run concrete code examples, and provides practical guidance on selecting the right engine based on performance, feature richness, and integration ease.
Expression EngineGroovyJEXL
0 likes · 13 min read

This article introduces dynamic expression parsing for enterprise Java applications, compares seven Spring Boot‑compatible expression engines (SpEL, MVEL, Aviator, JEP, OGNL, JEXL, QLExpress) across performance, security and syntax, and provides complete code samples, execution results and pros‑cons for each engine.
AviatorExpression EngineJEP
0 likes · 19 min read

This article presents an in‑depth analysis of the ZhiZhi checkout payment routing system, covering its historical evolution from basic configuration to rule‑engine and modular construction modes, detailing architecture, expression engine implementation, automatic anomaly detection, and future outlook for scalability and AI integration.
Exception HandlingExpression EnginePayment Routing
0 likes · 28 min read

This article introduces Aviator, a lightweight JVM‑based expression engine, explains its features and limitations, and demonstrates how to integrate it with Spring Boot and AOP to replace traditional if‑else validation logic using custom annotations and script files.
AOPAviatorException Handling
0 likes · 20 min read

This article introduces AviatorScript, a lightweight high‑performance JVM‑based scripting language, outlines its core features and limitations, demonstrates how to add it to a Maven project, shows expression evaluation, variable handling, custom functions, script files, and provides a practical Spring Boot AOP validation example with full code snippets.
AOPExpression EngineJava
0 likes · 18 min read

The article surveys popular Java expression engines—including Spring Expression Language, OGNL, Aviator, and MVEL2—detailing their key features and providing lightweight utility wrappers, and highlights Hutool’s unified façade that can encapsulate these engines to simplify dynamic rule evaluation in backend applications.
AviatorExpression EngineHutool
0 likes · 12 min read

This article introduces AviatorScript, a lightweight high‑performance expression engine and scripting language for the JVM (including Android), outlines its core features, demonstrates basic expression evaluation, variable handling, built‑in and custom functions, and shows how to run full scripts with code examples.
AviatorBackendExpression Engine
0 likes · 8 min read

This article introduces Aviator, a high‑performance, lightweight JVM‑based expression engine that has evolved into AviatorScript, covering its core features, typical use cases, basic syntax, variable handling, built‑in and custom functions, and how to run scripts with code examples.
BackendExpression EngineJava
0 likes · 9 min read

This article examines the challenges of scaling store settlement calculations, evaluates several Java expression engines, selects MVEL for its performance and community support, and details the architectural redesign, database schema, caching strategy, and step‑by‑step migration process for integrating the engine into a backend system.
CacheDatabase DesignExpression Engine
0 likes · 14 min read

This article provides a comprehensive overview and comparative analysis of popular Java expression engines—including AviatorScript, MVEL, OGNL, SpEL, QLExpress, JEXL, JUEL, and Janino—covering their features, community support, size, performance benchmarks, security settings, usage cases, and syntax differences to guide developers in selecting the most suitable engine for their projects.
Expression EngineJavaSecurity
0 likes · 23 min read

AviatorScript is a lightweight, high‑performance JVM expression engine and full‑featured scripting language that supports Java‑like operators, first‑class functions, closures, high‑precision arithmetic, script syntax, modularity, sandboxing, and can compile to bytecode for fast rule‑engine, formula, and ELT use cases.
AviatorExpression EngineJVM
0 likes · 8 min read

This article introduces Aviator, a lightweight high‑performance JVM‑based expression engine that evolved into AviatorScript, detailing its core features, typical use cases, basic syntax, variable handling, built‑in and custom functions, and how to run scripts and compile expressions.
AviatorExpression EngineJVM
0 likes · 8 min read

This article introduces Aviator, a high‑performance lightweight JVM‑based expression engine and script language, detailing its features, usage scenarios, code examples for evaluating expressions, variables, custom functions, and script execution, making it suitable for rule engines and dynamic calculations.
AviatorExpression Enginescripting
0 likes · 9 min read

This article explains GaiaX’s cross‑platform expression engine, covering its design, LR(1) grammar‑based parsing, syntax‑tree construction, C++ core implementation, Android JNI and iOS bridge integration, unified data types, performance benchmarks, and how it ensures consistent, high‑performance UI rendering on mobile devices.
AndroidC++Expression Engine
0 likes · 16 min read

The article presents a Swift‑based functional expression engine built with parser combinators and a monadic parser abstraction, detailing its layered architecture, grammar, expression‑tree representation, and performance benchmarks that replace NSPredicate limitations with a fast, composable solution for evaluating nested, configurable string expressions.
Expression EngineMonadParser Combinators
0 likes · 21 min read

This article explains the concept and execution methods of rule engines, describes the forward‑link inference approach used by ZhiZhuan’s risk‑control engine, and details the evolution from hard‑coded rules to feature‑engineered expressions using the Aviator expression engine, highlighting configuration, data sources, and practical examples.
Expression Enginebackend developmentfeature engineering
0 likes · 13 min read

The article describes how the Zhaunzhuan app backend team replaced a hard‑coded Map‑based routing configuration with a rule‑driven Aviator expression engine, detailing the problem analysis, engine selection, architectural redesign, code changes, a deployment incident, and the resulting improvements in flexibility, maintainability, and performance.
AviatorBackendConfiguration
0 likes · 10 min read

Aviator is a lightweight, high‑performance Java expression evaluation engine that compiles expressions to JVM bytecode, offering rich operator support, custom functions, variable handling, and compilation for reuse, while detailing its features, limitations, dependency setup, and multiple code examples for practical backend integration.
AviatorCode SamplesCustom Functions
0 likes · 9 min read
