The article demonstrates how to let users upload a JAR that implements a given interface, then hot‑replace the implementation at runtime using either reflection or Spring annotation‑based loading, covering class loading, bean registration, and cleanup with concrete code examples.
The article demonstrates how to replace manual JAR deployment with a dynamic hot‑deployment mechanism that loads user‑provided JARs at runtime, supporting both Spring‑managed and pure‑reflection implementations, and explains bean registration, removal, and testing procedures.
The article explains why rebuilding and redeploying a whole JAR for small rule or script changes is inefficient, distinguishes development‑time hot reload from production hot deployment, and shows how a plugin architecture using URLClassLoader and ServiceLoader provides granular, rollback‑friendly, and extensible updates while warning of classloader leaks and dependency conflicts.
This article walks through defining a simple Calculator interface, provides two implementation styles, and demonstrates both reflection‑based and annotation‑based hot‑deployment of uploaded JARs in a Spring application, including bean registration, removal, and a test loop.
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.
The article demonstrates how to let a system expose an interface, accept user‑written JARs that implement it, and hot‑replace the implementation at runtime using either Spring‑managed beans or pure reflection, including bean registration and cleanup.
This article shows how to let users upload a JAR that implements a predefined interface, then hot‑deploy the new implementation at runtime using either Spring annotation‑based registration or plain reflection, including bean registration, removal, and a test harness.
This guide shows how to let users upload a JAR that contains a custom implementation of a predefined Java interface, then hot‑replace the implementation at runtime using either Spring‑managed bean injection or pure reflection, with full code examples and a test harness.
This article walks through building a simple Calculator interface, creating a dual‑mode implementation, and then dynamically loading, registering, and unloading user‑supplied JAR files at runtime using reflection or Spring annotation processing, complete with utility methods and a test harness.
This guide explains how to let users upload a JAR that implements a predefined interface, then hot‑deploy the new implementation at runtime using either Spring annotation‑based bean registration or pure Java reflection, complete with utility methods for loading, registering, and cleaning up beans.
This article explains how to let users upload a JAR containing a custom implementation of a predefined Java interface, then hot‑deploy the new implementation using either Spring annotation‑based injection or pure reflection, covering interface definition, bean registration, and cleanup.
This tutorial demonstrates how to let users upload a JAR that implements a predefined Java interface, then hot‑replace the implementation at runtime via reflection or Spring bean registration, covering interface definition, concrete classes, dynamic class loading, bean management, and testing.
This article walks through building a Java interface, providing two implementation styles (Spring‑managed and pure‑reflection), loading user‑uploaded JARs at runtime, dynamically registering or removing beans in the Spring container, and testing the whole hot‑deployment cycle with concrete code examples.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (annotation‑managed and reflection‑based), and achieve hot deployment of user‑supplied JARs in a Spring Boot application, including loading, registering, and removing beans dynamically.
This guide demonstrates how to enable hot deployment of user‑provided Java interface implementations in a Spring Boot application, covering both annotation‑based and reflection‑based approaches, jar uploading, dynamic bean registration, class loading, and cleanup, with complete code examples.
This article explains three hot‑deployment methods for Spring Boot—IDEA's configuration options, the spring‑boot‑devtools library, and the JRebel plugin—detailing how to set them up, their underlying mechanisms, and best‑practice recommendations to avoid costly full restarts during development.
This article demonstrates how to let users upload a JAR containing a custom implementation of a predefined Java interface, then hot‑deploy the new implementation at runtime using either reflection or Spring bean registration, with complete code examples and utility methods.
This article explains how to let users upload a JAR containing a custom implementation of a predefined Java interface, then hot‑deploy the JAR by loading it with a URLClassLoader and dynamically registering or deregistering Spring beans using reflection or annotation modes.
HotSeconds is a Java remote hot‑deployment plugin that lets developers instantly apply code, resource, and class changes—including Spring MVC fields and methods—directly on a running server, dramatically reducing build‑restart cycles and improving development efficiency.
This article demonstrates how to define a simple Calculator interface, provide both annotation‑based and reflection‑based implementations, and dynamically hot‑deploy user‑supplied JAR files by loading them with URLClassLoader, registering Spring beans, and handling bean removal on JAR deletion.
This article examines the Matrix middle‑platform framework used at JD.com, detailing its hot‑deployment mechanism, the push‑and‑pull integration chains, class‑loader isolation based on the parent‑delegation model, and the design of business‑identity recognition, while offering best‑practice recommendations and code examples.
This article demonstrates how to design a simple Calculator interface in Java, implement it using both Spring‑managed and reflection‑based approaches, and achieve hot deployment by loading user‑provided JAR files at runtime, including code for class loading, bean registration, and cleanup.
This article examines JD's practical implementation of middle‑platform (中台) evolution, detailing the design rationale, the Matrix support framework, hot‑deployment mechanisms, class‑loader isolation, and business‑identity principles to illustrate how the architecture improves delivery speed and modularity.
This article introduces the design and implementation of a remote hot‑deployment component (Mark42/Jarvis) built on Java Agent and an IDEA plugin, analyzes the challenges of dynamic compilation in Spring‑Boot fat‑jar environments, presents solution choices, and shares practical experiences and future directions.
This article presents Xiaohongshu's evolving recommendation engineering architecture, detailing its modular backend design, graph-based Ark framework, hot deployment mechanisms, and the challenges and solutions for scaling personalized content delivery in a fast‑growing mobile platform.
This guide explains how to install, activate, and configure JRebel and XRebel in IntelliJ IDEA to enable hot deployment for Java Spring Boot projects, covering offline mode, auto‑make settings, and usage of the performance analysis features.
This article explains how to let users upload a JAR that implements a predefined Java interface, then dynamically load, register, and switch the implementation at runtime using both reflection‑based and Spring‑annotation‑based hot‑deployment techniques, complete with code examples and utility methods.
This article demonstrates how to define a simple Java interface, provide two implementation styles (Spring‑annotation and pure‑reflection), package the implementation as a JAR, and dynamically load, register, replace, or remove the implementation at runtime using URLClassLoader and Spring's bean factory.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (annotation‑based Spring beans and reflection‑based classes), and dynamically load, register, and unload user‑supplied JAR files at runtime through hot‑deployment mechanisms in a Java backend system.
This article demonstrates how to define a simple Calculator interface, implement it via both Spring-managed and reflection-based approaches, and achieve hot deployment by uploading JAR files, dynamically loading classes, registering or deregistering beans in the Spring container, and testing the process.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (Spring annotation and reflection), and achieve hot deployment by uploading JAR files, dynamically loading classes, registering or removing beans in the Spring container, and testing the runtime behavior.
This article demonstrates how to design a simple Calculator interface, provide both annotation‑based and reflection‑based implementations, and achieve hot deployment by loading user‑supplied JAR files at runtime, including dynamic bean registration and removal in a Spring container.
This article details Meituan's internal Sonic IDEA plugin, explaining hot‑deployment concepts, why they matter, the technical challenges, and Sonic's architecture—including agents, instrumentation, class reloading, Spring Bean/XML/MyBatis reloads, and real‑world deployment experience—showing how code changes can become effective in seconds instead of minutes.
This article explains how to add SpringBoot DevTools for hot deployment, integrate Lombok to simplify JavaBean code, and configure the Spring Configuration Processor for property metadata, providing step‑by‑step instructions, IDE settings, and Maven dependency snippets for a smoother development experience.
The article details Meituan's internal Sonic IDEA plugin for remote and local hot deployment, explaining why hot deployment is needed, its architecture, instrumentation techniques, DCEVM integration, file‑watching, class reloading, and support for Spring Bean, Spring XML and MyBatis, along with adoption statistics and performance benefits.
This article explains the Java class loading lifecycle, the different built‑in and custom ClassLoaders, the parent‑delegation model, reasons for breaking it (e.g., JDBC and Tomcat), how to implement custom loaders, hot‑deployment techniques, and includes typical interview code questions.
This article explains how to achieve hot deployment in Spring Boot by disabling template engine caches for Thymeleaf, FreeMarker, Groovy, and Velocity, using Debug mode, adding spring-boot-devtools, and optionally employing Spring Loaded or JRebel for more comprehensive live reloading.
This guide explains how to install JRebel, a hot‑deployment tool for Java web applications, using either Tomcat startup parameters or the IntelliJ IDEA plugin, and details the necessary VM options, deployment settings, and Maven/Gradle integration to achieve instant code updates without restarting the server.
This article explains how to install and configure JRebel for both local and remote hot deployment in Spring Boot projects, compares it with Spring DevTools, and provides step‑by‑step instructions, code snippets, and troubleshooting tips for multi‑module applications.
This article explains how to disable template engine caching and use various hot‑deployment methods—including property settings, Debug mode, spring‑boot‑devtools, Spring Loaded, and JRebel—to achieve real‑time updates of Spring Boot web pages.
This guide explains how to set up JRebel—either by adding JVM arguments to Tomcat or by installing the IntelliJ IDEA plugin—to achieve instant class and resource updates during Java web development, including platform‑specific VM options and Maven/Gradle integration.
This comprehensive guide walks you through IntelliJ IDEA's debugging features, covering the interface, basic shortcuts, variable inspection, expression evaluation, smart step‑into, conditional breakpoints, multithreaded debugging, frame rollback, request interruption, and JRebel activation for hot‑deployment.
Learn how to dramatically speed up Java web development by installing JRebel, covering both Tomcat startup parameter configuration and the IntelliJ IDEA plugin method, with detailed screenshots, VM options for Windows, Linux, and macOS, and tips for proper deployment settings.
This guide explains what JRebel is, why it speeds up Java web development, and provides step‑by‑step instructions for installing it via Tomcat startup parameters or the IntelliJ IDEA plugin, including configuration of deployment settings and VM options for Windows, Linux, and macOS.
This article explains how to install and configure JRebel for both local and remote hot deployment in Spring Boot projects, compares it with Spring DevTools, provides step‑by‑step setup instructions, and addresses multi‑module deployment pitfalls.
This guide explains why relying on third‑party reverse proxies for JRebel activation can fail, and provides step‑by‑step instructions to build your own local or server‑side reverse proxy, generate the required GUID, and configure IDEA or command‑line activation for seamless hot‑deployment.
This article explains how to disable template caching in Spring Boot for Thymeleaf, FreeMarker, Groovy, and Velocity, and compares several hot‑deployment methods including Debug mode, spring-boot-devtools, Spring Loaded, and JRebel, providing configuration snippets and practical guidance.
This article introduces Spring Boot, explains its key features, walks through creating a Maven project with a complete pom.xml, adds essential dependencies and plugins, shows how to write a basic @RestController application, and demonstrates various ways to run and hot‑reload the service.
The article details the evolution of the Tmall client homepage from a static slot system to a personalized platform, analyzes the inefficiencies of the 2016 architecture, and introduces the 2017 TAC (Tangram App Container) solution that uses Java dynamic compilation, loading, and hot‑deployment to streamline backend development and improve stability.
This article explains the differences between the WAR and WAR exploded deployment modes in Java web projects, compares their packaging and hot‑deployment capabilities, shows experimental results on path resolution, and provides practical tips for configuring Tomcat for effective development.
