alibaba/jvm-sandbox
Jvm Sandbox
jvm-sandbox is a bytecode instrumentation framework and plugin container for the Java Virtual Machine. It acts as a runtime application modifier that enables the injection and modification of bytecode in a running process without requiring an application restart or changes to the original source code.
The system provides a non-invasive aspect-oriented programming framework to intercept method execution and alter behavior in live processes. It functions as an isolated environment for functional modules, employing a custom class loader hierarchy to prevent dependency conflicts between plugins and the host application.
Its capabilities include real-time execution flow control, allowing for the modification of method input parameters, return values, and the handling of exceptions. The framework supports live application hot-patching and multi-tenant instance management to control multiple independent instances within a single target application.
Features
- Runtime Instrumentation Agents - Uses the Java Instrumentation API to modify class bytecode at runtime without requiring a process restart.
- Hot-Patching Tools - Fixes bugs or changes behavior in a production environment by injecting new logic into the running JVM process.
- Runtime Application Modifiers - Alters the behavior of running Java applications by dynamically transforming method inputs, outputs, and execution flow.
- Runtime Bytecode Instrumentation - Injects custom logic into existing methods of a running process to change behavior without requiring an application restart.
- Runtime Execution Interception - Intercepts method calls to modify input parameters, return values, or bypass original logic during runtime.
- Runtime Logic Bypassing - Provides the ability to bypass original application logic by returning custom results or transforming exceptions at runtime.
- Bytecode Modification Frameworks - Provides a framework for injecting and modifying bytecode in a running Java Virtual Machine without restarting the application.
- JVM Plugin Containers - Provides a runtime environment that isolates dependencies and manages the lifecycle of functional modules within a target Java process.
- Aspect-Oriented Programming Frameworks - Implements cross-cutting concerns like logging or monitoring into a live application without modifying its existing codebase.
- Non-Invasive Bytecode Weaving - Implements aspect-oriented programming by weaving logic into existing bytecode rather than requiring source code modifications.
- Method Argument & Return Manipulation - Enables modification of method input parameters, return values, and thrown exceptions during the start, end, or error phases.
- Method Logic Injection - Injects custom hook logic into method bodies to capture and modify inputs, outputs, and exception flows without source alteration.
- Non-Invasive AOP Frameworks - Provides an aspect-oriented programming system that intercepts method execution and modifies logic in live processes without source code changes.
- Classloader Isolation - Loads modules using a custom class loader to prevent version conflicts between plugins and the target application.
- Class Loader Hierarchies - Employs a custom class loader hierarchy to prevent dependency conflicts between external plugins and the host application.
- JVM Instance Isolation - Maintains independent state and control structures to allow multiple versions of the framework within one JVM.
- Module Lifecycle Managers - Adds or removes functional modules from a running process dynamically without leaving permanent traces in the target application.
- Functional Module Management - Adds or removes functional plugins from a running application while isolating dependencies to avoid version conflicts.
