Tagged articles
Hot Deployment
51 articles · Page 1 of 1
The article explains the background of long Java restart times, defines hot swap and hot deployment, details their implementation mechanisms, compares their granularity, speed, limitations, and impact, lists common tools, and highlights frequent misconceptions and pitfalls for developers.
Hot DeploymentHot SwapJRebel
0 likes · 9 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 10 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 8 min read

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.
Hot DeploymentJavaPlugin Architecture
0 likes · 8 min read

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.
Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 8 min read

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.
Component OrchestrationEL DSLHot Deployment
0 likes · 12 min read

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.
Bean RegistrationDynamic JAR LoadingHot Deployment
0 likes · 8 min read


java1234Jan 9, 2026 · Backend Development
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.
Bean RegistrationDynamic JAR LoadingHot Deployment
0 likes · 8 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 8 min read

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.
Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 9 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 9 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 8 min read

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.
Dynamic LoadingHot DeploymentReflection
0 likes · 9 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 9 min read

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.
Hot DeploymentJavaReflection
0 likes · 9 min read

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.
Dynamic Bean RegistrationHot DeploymentReflection
0 likes · 8 min read

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.
DevToolsHot DeploymentIDEA
0 likes · 4 min read

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.
BackendHot DeploymentJAR Loading
0 likes · 9 min read

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.
BackendHot DeploymentJAR Loading
0 likes · 8 min read

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.
Hot DeploymentRemote Debuggingbackend-development
0 likes · 5 min read

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.
Hot DeploymentJAR LoadingJava
0 likes · 8 min read


JD TechMay 14, 2024 · Backend Development
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.
ClassLoaderHot DeploymentJava
0 likes · 33 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 12 min read

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.
ClassLoaderHot DeploymentJava
0 likes · 32 min read

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.
Dynamic CompilationHot DeploymentJava
0 likes · 16 min read

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.
Hot DeploymentRecommendation SystemXiaohongshu
0 likes · 13 min read

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.
Hot DeploymentIntelliJ IDEAJRebel
0 likes · 8 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 8 min read

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.
Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 8 min read

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.
BackendDynamic Bean RegistrationHot Deployment
0 likes · 8 min read

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.
Dynamic LoadingHot DeploymentJava
0 likes · 8 min read

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.
Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 10 min read

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.
Dynamic LoadingHot DeploymentReflection
0 likes · 8 min read


21CTOMay 13, 2022 · Backend Development
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.
Hot DeploymentIDEA PluginJVM
0 likes · 21 min read

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.
Configuration ProcessorDevToolsHot Deployment
0 likes · 5 min read

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.
DCEVMHot DeploymentIDEA Plugin
0 likes · 19 min read

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.
ClassLoaderHot DeploymentJVM
0 likes · 13 min read

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.
DevToolsHot DeploymentJava
0 likes · 4 min read

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.
Hot DeploymentIntelliJ IDEAJRebel
0 likes · 5 min read

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.
Hot DeploymentIDEAJRebel
0 likes · 11 min read

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.
DevToolsHot DeploymentTemplate Engine
0 likes · 4 min read

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.
Hot DeploymentIntelliJ IDEAJRebel
0 likes · 5 min read

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.
Development ToolsHot DeploymentIDE
0 likes · 16 min read

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.
Hot DeploymentIntelliJ IDEAJRebel
0 likes · 6 min read

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.
Hot DeploymentIntelliJ IDEAJRebel
0 likes · 5 min read

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.
Hot DeploymentIntelliJ IDEAJRebel
0 likes · 8 min read

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.
Hot DeploymentIDEAJRebel
0 likes · 7 min read

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.
DevToolsFreeMarkerHot Deployment
0 likes · 3 min read

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.
Hot DeploymentJavaMaven
0 likes · 14 min read

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.
Dynamic CompilationHot DeploymentJava
0 likes · 9 min read

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.
BackendHot DeploymentJava
0 likes · 4 min read
