alibaba/QLExpress
QLExpress
QLExpress is a dynamic scripting engine and expression language for the Java platform. It functions as a runtime expression evaluator and business rule engine, allowing applications to execute scripts and evaluate business logic without requiring system recompilation.
The engine distinguishes itself through a secure scripting sandbox that enforces security policies via class whitelisting and execution timeouts. It supports high-precision mathematics to prevent rounding errors and provides language alias support to create domain-specific languages that resemble natural language. Additional capabilities include a macro-based fragment replay mechanism and the ability to extend existing Java classes by injecting new member methods accessible only within the script environment.
The system covers a broad range of capabilities, including bytecode-based compilation with script caching, abstract syntax tree evaluation, and dynamic string interpolation. It also provides observability through node-level execution tracing for root cause analysis, as well as script syntax validation and complex data structure support using JSON syntax.
Features
- Business Rule Engines - Functions as a business rule engine allowing complex operational logic to be changed at runtime without recompilation.
- Expression Evaluators - Functions as a general-purpose engine for processing mathematical and logical expressions during runtime.
- Embeddable Scripting Engines - Provides an embeddable scripting engine for Java applications to support flexible logic updates and DSLs.
- Expression Parsing - Uses a formal grammar to decompose text into mathematical and logical operators for deterministic evaluation.
- Bytecode Compilation - Translates scripts into an internal binary format to improve execution speed and avoid repeated parsing.
- Dynamic Expression Languages - Serves as a dynamic expression language for the Java platform to evaluate business rules at runtime.
- Dynamic Script Execution - Evaluates expressions and runs scripts within an application to change business logic without requiring a full recompile.
- External Variable Mapping - Extracts required external variables and functions from scripts to prepare the necessary execution context.
- Expression Tree Evaluators - Implements a recursive visitor pattern to evaluate logical operations within a generated expression tree.
- Sandbox Permissions - Enforces security policies via class whitelisting and execution timeouts within a controlled scripting sandbox.
- Scripting Sandboxes - Restricts access to class fields and methods using configurable security policies like whitelists or isolation.
- Secure Sandboxing - Provides an execution environment that enforces security policies through class whitelisting and execution timeouts.
- Runtime Variable Mappings - Provides a mechanism to map script variables to external Java objects during the runtime execution phase.
- Scripted Function Definitions - Allows defining and invoking reusable named or anonymous functions within the scripting environment.
- Runtime Expression Evaluation - Calculates dynamic values and executes scripts on the fly using external variables and custom functions.
- Script Validators - Validates script syntax and security constraints before execution to prevent runtime errors and unauthorized access.
- Syntax Validation - Checks for syntax errors and enforces operator restrictions without executing the script to ensure correctness.
- Compiled Caches - Stores compiled expressions in memory or as serializable objects to eliminate redundant parsing overhead.
- Script Execution Timeouts - The project interrupts script execution after a specified duration to prevent infinite loops from consuming system resources.
- Runtime Method Injection - Adds new member methods to existing Java classes that remain accessible exclusively within the script environment.
- Complex Data Structure Support - Provides JSON-based syntax for defining maps, lists, and complex objects within scripts.
- Domain Specific Languages - Supports the creation of simplified, natural language syntax to allow non-technical users to write business logic.
- Dynamic Variable Injection - Supports nested dependencies by defining variables as expressions that depend on other variables.
- Language Alias Support - Allows assigning custom names to keywords and functions to make scripts read more like natural language.
- Macro-Based Fragment Replay - Encapsulates script fragments for reuse through a replay mechanism that shares the caller's scope.
- Macro Replay Mechanisms - Implements a macro-based fragment replay mechanism to encapsulate and reuse script segments.
- String Interpolation - Embeds expression results directly into strings using template syntax for flexible text generation.
- High Precision Mathematics - Uses high-precision decimal types for numbers that cannot be represented exactly by doubles to prevent rounding errors.
- Dynamic Class Extensions - Enables the extension of existing Java classes by injecting new member methods accessible only within the script environment.
- Method Logic Injection - Allows attaching new behaviors to existing Java classes at runtime via proxies accessible within scripts.
- Execution Tracing - Records intermediate values of every node during evaluation to provide a detailed tree for root cause analysis.
- Step-Level Tracing - Records the result of every single operation in the syntax tree to enable detailed debugging and root cause analysis.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
