Tagged articles
Dynamic Loading
65 articles · Page 1 of 1
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 argues that loading prompts, skills, and configuration only when they are needed—just-in-time context—dramatically reduces token consumption, improves precision, and turns AI agents from wasteful code generators into lean, production‑grade assistants.
AI ArchitectureAI agentsDynamic Loading
0 likes · 12 min read

This article explains the Linux kernel module mechanism, covering core concepts such as dynamic loading, unloading, dependency management, and symbol export, and provides implementation details, practical usage scenarios, best‑practice guidelines, and complete code examples.
Dynamic LoadingKernel ModulesLinux
0 likes · 9 min read

The article presents a step‑by‑step design and implementation of a Claude‑style Skills mechanism for LangChain agents, using a double‑layer tool architecture, state‑driven dynamic filtering, and middleware interception to load only relevant tools, dramatically reducing token consumption and improving decision quality and response speed.
Dynamic LoadingLangChainPython
0 likes · 15 min read

This article explains Java's reflection mechanism, covering its main uses such as dynamic class loading, handling unknown types, accessing private members, and framework development, then walks through basic steps, a complete code example, and discusses its advantages and drawbacks.
Dynamic LoadingFrameworksJava
0 likes · 6 min read

This guide explains Java's Service Provider Interface (SPI) mechanism, compares it with APIs, and walks through creating a multi‑module Maven project that defines SPI interfaces, implements plugins, loads external JARs with a custom class loader, and integrates the plugins into a Spring Boot application for dynamic authentication.
Custom ClassLoaderDynamic LoadingJava SPI
0 likes · 15 min read

This article explains the purpose, behavior, return values, and exception handling of Java's Class.forName and ClassLoader APIs, compares their initialization and flexibility characteristics, and provides practical code examples and typical use cases for each approach.
Class.forNameClassLoaderDynamic Loading
0 likes · 4 min read

This guide explains how to use a custom dynamic loader library on STM32 (Cortex‑M7) microcontrollers, covering project structure, installation steps, and runtime usage to load relocatable AXF files into RAM similarly to DLLs or shared objects.
C++Dynamic LoadingEmbedded
0 likes · 7 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 explains how to build a Spring Boot hot‑patch loader that uses Java agents and dynamic class loading to apply runtime patches—such as Spring Bean, plain class, or static method replacements—allowing urgent bug fixes in production within minutes without restarting the service.
Dynamic LoadingJava Agenthot-patch
0 likes · 34 min read

This article explains a step‑by‑step approach to load external JAR files into the JVM, configure Spring Boot to recognize the new classes, and choose among classpath expansion, Spring Boot's loader.path, or a custom ClassLoader, complete with Maven settings and code examples.
ClassLoaderDynamic LoadingJVM
0 likes · 8 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 explains Java's ClassLoader architecture, the parent delegation model, the three phases of class loading, dynamic loading and binding mechanisms, and demonstrates how to inspect object layout using the JOL tool, providing code examples and practical insights for JVM internals.
ClassLoaderDynamic LoadingJOL
0 likes · 11 min read

This article explains how to build a decentralized micro‑frontend system for Vue 3 using the Vite‑based @originjs/vite-plugin-federation, covering architecture concepts, configuration, dynamic module loading, shared routing, state management with Pinia, and deployment strategies, complete with code examples.
Dynamic LoadingViteVue3
0 likes · 15 min read

This article explains how to build a hot‑reload wrapper for API automation testing in Pytest, covering requirement analysis, technology selection, step‑by‑step implementation—including YAML test case definition, dynamic loader, reflection utility, and Pytest plugin—and demonstrates its practical usage to improve development efficiency.
API testingDynamic LoadingHot Reload
0 likes · 4 min read

This article explains Java's ClassLoader mechanism, its loading, linking, and initialization phases, the parent‑delegation hierarchy, common problems such as ClassNotFoundException and OOM, and provides practical troubleshooting steps and best practices for managing dynamic class loading.
ClassLoaderDynamic LoadingJVM
0 likes · 6 min read

This article explains Java's reflection mechanisms, comparing Class.forName and ClassLoader as two primary ways to load classes, detailing their behavior, static initialization effects, code examples, and practical scenarios such as loading JDBC drivers versus custom dynamic loading.
Class.forNameClassLoaderDynamic Loading
0 likes · 6 min read

Ke Jie explains why reducing the Game Center APK—by eliminating alpha‑PNG images, unused code and resources, limiting language and density assets, disabling v1 signing, compressing images, loading native libraries on demand, shipping only 64‑bit binaries, enabling code/resource shrinking and R‑file inlining—cut size by about 31% (≈20 MB), boosting download conversion and launch performance.
APK OptimizationAndroidApp Size Reduction
0 likes · 14 min read

By implementing a plug‑in architecture that uses a custom URLClassLoader to load and unload JAR‑packaged governance tasks at runtime, the Spring Boot application can dynamically register Spring beans and XXL‑Job handlers, remove them cleanly, update configuration via YAML or Nacos, and package the solution with Maven Shade without restarting services.
ClassLoaderDynamic LoadingJava
0 likes · 21 min read

This article explains how to dynamically load JAR files in a Spring Boot application, covering core concepts, benefits, usage of SpringBootClassLoader, creation of JARs, and alternative third‑party OSGi‑resource‑locator approaches with full code examples.
Dynamic LoadingJavaOSGi
0 likes · 8 min read

This article explains the concepts and step-by-step implementation of dynamically loading JAR packages in Spring Boot applications, covering built‑in classloader usage, creating JARs, and leveraging third‑party libraries to enhance flexibility and extensibility.
BackendClassLoaderDynamic Loading
0 likes · 9 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 explains how to design a plug‑in architecture for a data‑governance service that can start, stop, add, or upgrade individual tasks at runtime without restarting the whole service, using a custom URLClassLoader, Spring bean registration, XXL‑Job integration, dynamic configuration updates, and a clean unload process.
ClassLoaderDynamic LoadingJava
0 likes · 26 min read

This guide explains Android pluginization, showing how a host app can dynamically load separate APK modules—including native libraries, classes via a custom DexClassLoader, and mixed resources—while supporting hot updates, modular isolation, and reduced initial size, and details each loading step and manager implementation.
AndroidClassLoaderDynamic Loading
0 likes · 31 min read

The article presents a Java Spring solution that uses a custom URLClassLoader to dynamically load, register, and unload governance task JARs as Spring beans and XXL‑Job handlers at runtime, with configuration persistence via YAML or Nacos and Maven Shade packaging for seamless updates without service restarts.
Custom ClassLoaderDynamic LoadingJava
0 likes · 21 min read

The solution introduces a plug‑in architecture that uses a custom URLClassLoader to load governance task JARs at runtime, registers their Spring beans and @XxlJob handlers with XXL‑Job, and provides unload logic to deregister jobs, destroy beans, and update configuration via YAML or Nacos without restarting the service.
ClassLoaderDynamic LoadingJava
0 likes · 21 min read

This article walks through nine practical JavaScript patterns—including dynamic script loading, a lightweight template engine, data transformation with reduce, default parameters, one‑time execution, currying, singleton implementation, a simple CommonJS loader, and recursive property access—providing clear code examples for each.
Dynamic LoadingFrontend DevelopmentJavaScript
0 likes · 11 min read

This article explains the design and implementation of a dynamic resource management system for Android apps, covering the motivation for reducing APK size, the architecture of the dynamicresbase, dynamicrescore, and dynamicresplugin modules, resource loading and application processes, Gradle plugin tasks, code transformation, and practical tips for handling .so libraries.
APK OptimizationAndroidDynamic Loading
0 likes · 31 min read

This article explains the four common compilation and linking problems C/C++ developers encounter on 64‑bit Linux, covering preprocessing, ELF object formats, static library ordering, dynamic linking mechanics, symbol interposition, and runtime loading pitfalls, and provides concrete solutions for each.
C++Dynamic LoadingELF
0 likes · 15 min read

The article explains how dynamically loaded dex files are optimized on Android 5.0 through 12—detailing AOT compilation via dex2oat, profile‑guided filters, runtime‑filter flags, class‑loader contexts, SELinux limits, and the use of PathClassLoader or the PMS performDexOptSecondary command to achieve performance comparable to installed APKs.
AOTAndroidClassLoader
0 likes · 17 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 explains Java's class loading mechanism in depth, covering the class lifecycle stages, the three primary class loaders, the parent‑delegation model, caching behavior, and practical code examples for custom loaders and dynamic loading methods.
Class LoadingCustom ClassLoaderDynamic Loading
0 likes · 8 min read


58 TechNov 3, 2022 · Mobile Development
This article explains the fundamentals of Android pluginization, covering class loading, resource handling, Dex and OAT formats, security considerations, and presents a lightweight plugin framework used by 58.com to reduce app size and enable dynamic updates.
AndroidClassLoaderDEX
0 likes · 30 min read

The Thor Container Framework, created by Baidu for its App to meet Hook technology needs, offers standardized Java and Native Hook interfaces through an abstract layer, enabling lightweight, dynamically delivered plugins with hot‑swap capability, cloud‑controlled activation, and robust disaster‑recovery features, supporting use cases such as low‑end optimization, privacy compliance, OOM handling, and pipeline integration.
AndroidDynamic LoadingJava Hook
0 likes · 22 min read

The article explains how a Business Monitoring Platform isolates user‑defined Groovy scripts by assigning each script its own custom Java ClassLoader that loads uploaded JARs, breaking parent‑delegation, preventing class conflicts, reducing Metaspace growth, and dynamically creating Feign and Dubbo beans for safe, independent execution.
ClassLoaderDubboDynamic Loading
0 likes · 12 min read

The Shadow framework, developed by Tencent, is an open‑source Android plugin solution that reuses independent app source code, employs zero‑reflection dynamic loading, minimizes host footprint, and provides detailed module architecture, component support, Flutter integration, and isolation mechanisms for stable, dynamic plugin development.
AndroidClassLoaderDynamic Loading
0 likes · 9 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 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


政采云技术Apr 8, 2022 · Mobile Development
This guide explains how to implement a Flutter solution that dynamically loads and updates iconfont TTF files at runtime, covering the FontLoader API, remote font fetching, name‑to‑Unicode mapping, and a FutureBuilder‑based extension that refreshes icons without requiring a new app release.
DartDynamic LoadingFlutter
0 likes · 11 min read

The article shows how to overcome extensibility limits in a Java list‑management system by creating a custom DynamicClassLoader that loads encrypted .class files at runtime, explains Java’s class‑loading stages, fixes a Tomcat deployment issue via proper parent delegation, and demonstrates dynamic invocation of new encryption modules without code changes.
Code ExtensibilityDynamic LoadingJVM
0 likes · 14 min read

This article explains the problem of resource ID mismatches when Android plugins use host resources, reviews existing resource‑fixation solutions, and presents a novel “no‑resource‑fixation” method that dynamically maps host IDs at compile‑time and runtime to keep plugins stable across host updates.
AAPT2AndroidDynamic Loading
0 likes · 26 min read

This article details the motivation, design, implementation, and results of a dynamic Flutter package splitting solution that extracts data and resource segments on iOS and separates native libraries and assets on Android, enabling on‑demand download and reducing overall app size.
Dynamic Loadingpackage splitting
0 likes · 14 min read

This tutorial demonstrates how to integrate Layui with ThinkPHP 5.1 to dynamically load hierarchical city category data, covering HTML setup, JavaScript tree rendering, PHP backend data retrieval, and a recursive method for obtaining parent IDs, enabling interactive navigation of multi‑level locations.
Dynamic LoadingJavaScriptLayui
0 likes · 5 min read

The QQ Music/Karaoke team migrated their Android app from 32‑bit to Arm64‑v8a by reconfiguring Gradle builds, recompiling or replacing over 120 native libraries, extending the dynamic‑resource loader for ABI selection, implementing ABI‑aware update channels, and fixing issues such as library path limits, I/O reliability, camera latency, and WebView cache corruption, completing the transition in early 2021.
AndroidBuild ConfigurationDynamic Loading
0 likes · 27 min read

This article explores the concept, use‑cases, and step‑by‑step implementation of a high‑performance dual‑column waterfall (masonry) layout for mobile H5, covering Flexbox structure, dynamic data distribution, error‑correction techniques, and a DP‑based optimal arrangement algorithm.
DP algorithmDynamic LoadingFlexbox
0 likes · 13 min read

This article describes how the JAYE 2.0 project at Beike leverages abstract syntax tree (AST) generation, a custom runtime interpreter, and Dart VM execution to achieve high‑performance, hot‑fixable dynamic updates for Flutter applications, addressing packaging, hot‑reload, and scalability challenges.
ASTDynamic LoadingFlutter
0 likes · 13 min read

The team built a low‑intrusion Gradle plugin that detects changed source and resource files, performs precise dependency analysis, leverages aapt2 for incremental resource compilation, and injects updated Dex and assets into the running app, cutting full Android builds from 418 seconds to 13 seconds and boosting daily developer productivity on large projects such as QQ Music.
AndroidBuild OptimizationDynamic Loading
0 likes · 23 min read

This article explains how to dynamically replace the Dart libapp.so library and asset resources in a Flutter Android app by modifying the AOT_SHARED_LIBRARY_NAME argument and using AssetManager reflection, enabling hot updates without publishing a new APK.
AndroidDynamic LoadingFlutter
0 likes · 12 min read

Qigsaw, iQIYI’s open‑source framework released in 2019, enables low‑risk dynamic loading of Android App Bundle split APKs across all components and processes, offering Play‑Core‑compatible APIs, single‑hook stability, resource merging, and Tinker‑based hot updates, thereby simplifying plugin integration and reducing app size.
AndroidApp BundleDynamic Loading
0 likes · 18 min read

This article explains how to use Spring to hot‑load Groovy scripts stored in a database as beans, enabling on‑the‑fly data source access, RPC calls, and dependency injection without restarting the Java application.
BackendBean RegistrationDynamic Loading
0 likes · 6 min read

This article analyzes iQIYI’s Neptune plugin framework, explaining why pluginization is needed, the core technical principles of class and resource loading, lifecycle management, and how Neptune implements multi‑ClassLoader isolation, resource handling, context wrapping, and incremental updates for large‑scale Android apps.
AndroidClassLoaderDynamic Loading
0 likes · 18 min read

This article provides an in‑depth exploration of the Objective‑C runtime, covering the underlying object model, class and metaclass structures, the isa_t layout, how classes are loaded and initialized, dynamic loading mechanisms, and practical applications such as ORM and automatic NSCoding implementation.
Class LoadingDynamic LoadingORM
0 likes · 22 min read


21CTOJun 10, 2018 · Fundamentals
This article explains how the Hyperlambda‑based Phosphorus Five operating system achieves dynamic module loading and initialization with only a handful of declarative commands, demonstrating a minimalist approach to building extensible, modular software that can be extended by simply adding folders and startup files.
Dynamic LoadingHyperlambdaminimal code
0 likes · 6 min read

The article explains why Android developers split large NDK‑generated .so files from the APK to reduce package size, outlines how to design comprehensive test points for dynamic loading, and provides practical suggestions for handling download, installation, compatibility, and upgrade scenarios.
AndroidDynamic LoadingNDK
0 likes · 6 min read

JarsLink is an Alibaba open‑source Java modular framework that allows runtime dynamic loading, unloading, and inter‑module communication of JAR packages, offering plug‑and‑play isolation, versioning, and resource management to simplify large‑scale backend development, reduce deployment time, and support use cases such as data integration, micro‑service testing, and backend systems.
Dynamic LoadingJavaModular Development
0 likes · 13 min read

The article outlines a systematic method for structuring native‑layer code and using dlopen, dlsym, and dlclose to dynamically load and unload .so libraries on Android, enabling selective loading, reduced memory usage, hot‑fix updates, and solutions to STL version, permission, and C++ name‑mangling challenges.
AndroidC++Dynamic Loading
0 likes · 14 min read

The article chronicles Ctrip's mobile app architecture evolution—from a simple MVC design in 2011, through a tightly coupled early server model, to a modular API‑Gateway‑based backend, intelligent downgrade mechanisms, multi‑Dex loading, and finally a bundle‑oriented dynamic plugin framework—highlighting the technical challenges, solutions, and lessons learned for large‑scale mobile development.
API GatewayApp ArchitectureCtrip
0 likes · 27 min read

The article presents an in‑depth technical overview of Qunar's Spider framework for Android modular development, describing its component model, architecture, development workflow, performance benefits, comparison with other dynamic‑loading solutions, and step‑by‑step guidance for building and releasing Spider‑based apps.
AndroidComponent ArchitectureDynamic Loading
0 likes · 6 min read

This article introduces the Spider framework used at Qunar for Android modular development, explaining its architecture, component model, development and release workflow, performance benefits, dynamic loading features, and provides a quick‑start guide with examples and resources.
AndroidDynamic LoadingModular Development
0 likes · 6 min read


21CTOFeb 20, 2016 · Mobile Development
This article explains how Ctrip’s Android app adopted a plugin‑based, dynamic‑loading framework to overcome method‑limit, improve build speed, enable hot‑deployment, and support modular A/B testing, detailing the underlying principles, compilation changes, runtime resource and class loading, and the trade‑offs involved.
AndroidBuild OptimizationDynamic Loading
0 likes · 16 min read

This article explains the motivations, design principles, compilation and runtime techniques of Ctrip's Android plugin‑based architecture and dynamic loading framework, detailing how it solves method‑count limits, improves build speed, enables hot‑deployment, and outlines the associated trade‑offs.
AAPTAndroidCtrip
0 likes · 19 min read
