alibaba/jvm-sandbox

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.

Star history