1 views collected around this technical thread.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.