Tagged articles
Class Loading
69 articles · Page 1 of 1
This article explains why a custom java.lang.String class cannot replace the JDK's String, detailing the parent delegation class loading model, Bootstrap ClassLoader's role, core class protection mechanisms, Java 9+ module system restrictions, and why attempts to bypass these (custom class loaders, -Xbootclasspath, --patch-module, Java Agents) fail or are unsafe.
Bootstrap ClassLoaderClass LoadingCore Class Protection
0 likes · 23 min read

This article traces a Java method call through five stages: compilation to bytecode, class loading with vtable resolution, interpretation via stack frames, JIT compilation with optimizations like inlining and escape analysis, and final execution as machine code on CPU pipelines.
CPU pipelineClass LoadingHotSpot
0 likes · 30 min read

The article explains that Java static blocks are not always the first code to run during class loading because static field initializers and static blocks are executed in the order they appear in the source, and a static field can trigger instance initialization.
Class LoadingJavaJava fundamentals
0 likes · 6 min read

This article walks through the full lifecycle of a Java class—from loading, verification, preparation, and resolution to initialization, usage, and unloading—explains active versus passive references, the parent‑delegation model, JDK 8‑to‑17 module‑system changes, and shows how to write a custom ClassLoader for class isolation.
Class LoadingClassLoaderCustom ClassLoader
0 likes · 26 min read

This article presents ten essential JVM interview questions, covering the Java 8 memory model, object allocation flow, common GC algorithms and collectors, class‑loading mechanics, OOM and CPU‑spike troubleshooting, tuning parameters, and the differences among strong, soft, weak and phantom references.
Class LoadingJVMJava Interview
0 likes · 12 min read

This article explains how Java source files are compiled into bytecode, details the JVM's class loading lifecycle, describes the hierarchical class loader delegation model, and breaks down the runtime data areas—including stack, heap, and metaspace—while offering practical tuning tips to avoid common OOM issues.
Class LoadingJava Memory ModelOOM
0 likes · 13 min read


java1234Jan 27, 2026 · Backend Development
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
Auto-configurationClass LoadingDatabase Connection
0 likes · 9 min read

This article provides a comprehensive technical guide covering Java bytecode structure, the seven-stage class lifecycle, JIT compilation, memory layout, garbage‑collection algorithms, execution engine details, and both static and dynamic bytecode enhancement techniques such as ASM, Javassist, and Java agents.
ASMClass LoadingJIT
0 likes · 74 min read

This guide explains how to load external JAR files into the JVM, configure SpringBoot to recognize them, and choose among several class‑loading strategies—including expanding the classpath, using the loader.path parameter, or implementing a custom classloader—while providing Maven configuration examples and code snippets.
Class LoadingCustom ClassLoaderDynamic Configuration
0 likes · 9 min read

This comprehensive guide explores Tomcat’s mature architecture, detailing its connector and container components, the underlying design patterns such as composite, observer, and template method, and the custom class‑loading mechanisms that enable modularity, hot‑reloading, and isolation for Java web applications.
Class LoadingJavaTomcat
0 likes · 43 min read

This guide explains step‑by‑step how to load external JAR files into the JVM, configure Spring Boot to recognize them, and choose among four practical solutions—including classpath expansion, Spring Boot loader.path, custom class loaders, and JVM boot classpath tweaks—while highlighting their pros, cons, and required Maven settings.
Class LoadingCustom ClassLoaderJVM
0 likes · 10 min read

This article explains the core principles of Java class loading, including the uniqueness of Class objects per ClassLoader, various loading sources such as dynamic generation, network, ZIP archives, and databases, the lifecycle stages, delegation model, isolation, and practical recommendations for safe and efficient deployment.
Class LoadingJVMJava
0 likes · 7 min read

This article explains how Java classes are loaded into the JVM, details the class loader’s parent‑delegation mechanism, and walks through the execution flow of a sample program, covering stack frames, heap allocation, dynamic linking, method area, program counter, native method stack, and garbage collection.
Class LoadingJVMJava
0 likes · 9 min read

This article provides a comprehensive, step‑by‑step explanation of the JVM class‑loading mechanism, covering the five phases—Loading, Verification, Preparation, Resolution, and Initialization—along with diagrams and detailed descriptions of each operation performed by the JVM.
Class LoadingJVMJava
0 likes · 7 min read

This article explains Java's parent delegation mechanism—a core part of the JVM class‑loading process—detailing its purpose, three main benefits (avoiding duplicate loading, ensuring security, improving efficiency), and the step‑by‑step loading workflow illustrated with diagrams.
BackendClass LoadingJVM
0 likes · 6 min read

This article provides a comprehensive overview of the Java Virtual Machine, detailing its architecture, class loading process, runtime data areas, and execution engine, including interpreter and JIT compilation, to help readers grasp JVM fundamentals for Java development and interview preparation.
Class LoadingJITJVM
0 likes · 8 min read

This article provides a detailed explanation of Java’s parent delegation model, covering its definition, visual diagrams, advantages and disadvantages, and a six-step loading process, helping readers understand how class loaders prioritize parent loaders to ensure security and avoid duplicate class loading.
BackendClass LoadingJVM
0 likes · 5 min read

This article explains the Java class loading mechanism, the parent‑delegation model, how it can be broken, and then details Tomcat’s custom classloader hierarchy—including CommonClassLoader, CatalinaClassLoader, SharedClassLoader, and WebappClassLoader—showing why Tomcat deviates from the standard delegation model.
Class LoadingJavaParent Delegation
0 likes · 15 min read

This article explains how Java objects are created using the new operator, details the JVM memory model (stack and heap), describes the generation and loading of .class files by the ClassLoader, compares Class.newInstance() with new, and outlines the initialization steps and key concepts developers must master.
Class LoadingJVMJava
0 likes · 11 min read

A June 15 Full GC alert in a Spring Data Elasticsearch service led to a deep investigation using jstat, jmap, VisualVM, and OQL, revealing massive class loading from ES PO packages caused by per‑request ElasticsearchRestTemplate instances, which exhausted metaspace and triggered repeated garbage collections.
Class LoadingFullGCJVM
0 likes · 12 min read

This article investigates a production thread‑pool exhaustion issue caused by a JVM class‑initialization deadlock, explains the underlying class‑loading mechanics, presents detailed stack‑trace analysis, and offers a preventive solution with early bean initialization and a reproducible demo.
Class LoadingConcurrencyJVM
0 likes · 17 min read

This article examines the evolution stages of a plugin framework, analyzes performance bottlenecks such as Multidex, Dex2Oat, and class loading on Android devices, and presents detailed optimization strategies—including timing adjustments, forced compilation commands, and native class‑loader hook replacements—to improve app responsiveness and reduce ANR occurrences.
AndroidClass LoadingMultidex
0 likes · 24 min read

The article explains how the HotSpot JVM executes Java by interpreting bytecode, using client or server JIT compilers to translate hot methods into native code, describes the five runtime memory areas, outlines major garbage‑collection algorithms and tuning options, and details the class‑loading process and hierarchical classloader model.
Class LoadingJITJVM
0 likes · 24 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

This article explains why a Spring Boot application that runs fine in an IDE may throw NoSuchMethodError or NoSuchFieldError when packaged as an executable jar, and provides systematic steps—including JVM class‑loading flags, Maven enforcer rules, and class‑path inspection—to locate and resolve the root cause.
Class LoadingMavenNoSuchMethodError
0 likes · 6 min read

This article explores Java’s ClassLoader mechanism, detailing its core API methods, hierarchical delegation model, and the nuances of class loading in Java EE environments, while providing practical code examples and troubleshooting tips for common errors such as NoClassDefFoundError, NoSuchMethodError, and ClassCastException.
Class LoadingClassLoaderJava
0 likes · 17 min read

This article explains how Java creates objects with the new operator, details the JVM's stack and heap memory model, describes class loading and the role of Class objects, and compares newInstance with new, providing code examples and visual diagrams for deeper comprehension.
Class LoadingJVMObject Creation
0 likes · 14 min read

When two JARs contain identically named classes and methods but differ in a method's return type, Java's class‑loading mechanism may load the wrong version, triggering a java.lang.NoSuchMethodError, which can be prevented by detecting duplicate classes with Maven Enforcer rules.
Class LoadingDuplicate ClassesJava
0 likes · 4 min read


政采云技术Mar 15, 2022 · Fundamentals
This article explains how the JVM loads and links class files, describes the five runtime data areas—including the Method Area, Heap, JVM Stacks, Program Counter, and Native Method Stack—and details the class‑loader hierarchy and the parent‑delegation model used during class loading.
Class LoadingClassLoaderJVM
0 likes · 17 min read

This article provides a comprehensive overview of the Java Virtual Machine, covering its core responsibilities, runtime memory layout, class‑loading process, object allocation and layout, garbage‑collection theories and algorithms, common collectors, useful JVM tools, and tuning parameters.
Class LoadingJVMJava
0 likes · 52 min read

This article explains the complete Java class loading lifecycle—including loading, verification, preparation, resolution, initialization, usage, and unloading—details the seven scenarios that trigger active loading, illustrates the parent delegation model, and provides code examples for custom and Tomcat class loaders.
Class LoadingClassLoaderCustom ClassLoader
0 likes · 16 min read

This comprehensive guide explores the inner workings of the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, class‑file structure, bytecode instructions, class loading mechanisms, and method dispatch strategies, providing clear explanations and code examples for developers seeking a deeper understanding of JVM fundamentals.
Class LoadingJVMbytecode
0 likes · 41 min read

This article provides an in-depth exploration of Java's JVM memory architecture, garbage collection algorithms, class file structure, class loading process, bytecode execution, and method dispatch mechanisms, offering practical code examples and visual diagrams to help developers understand and optimize JVM performance.
Class LoadingJVMJava
0 likes · 44 min read

This comprehensive article explains the inner workings of the Java Virtual Machine, covering class file structure, class loaders, memory layout, garbage collection, execution engine, debugging via JPDA, hot deployment, hot swapping, and performance tuning techniques, providing practical code examples and configuration tips.
Class LoadingJVMbytecode enhancement
0 likes · 74 min read

This article provides a comprehensive overview of the Java Virtual Machine, explaining its main purpose, memory regions, class‑loading mechanism, object creation process, memory allocation strategies, object layout, reference handling, garbage‑collection theories, algorithms, and common JVM tuning commands.
Class LoadingJVMJava
0 likes · 51 min read

This comprehensive guide explores Tomcat’s mature architecture, explains its core components such as connectors, containers, endpoints, processors, adapters, and valves, demonstrates the request flow, reveals the custom class‑loading mechanism, and shows how to apply these design patterns to real‑world backend development.
BackendClass LoadingTomcat
0 likes · 42 min read

This article explains the complete Java class compilation and loading lifecycle, covering lexical, syntax, and semantic analysis, annotation processing, syntax‑sugar transformation, bytecode generation, class file structure, the five loading steps, class loader types, the parent‑delegation model, and practical use cases such as dependency conflict resolution, hot‑loading, and code encryption.
AnnotationsClass CompilationClass Loading
0 likes · 22 min read

This article explains how Java source files are compiled into bytecode, how the JVM loads and links classes, and details the roles of lexical, syntax, and semantic analysis, as well as the classloader hierarchy and the parent‑delegation mechanism.
Class LoadingJVMJava
0 likes · 14 min read

This article analyzes Android's class loading and verification process, identifies optimization opportunities to speed up cold starts, compares industry approaches, and presents a semi‑automated analysis tool along with practical solutions for handling verification failures in mobile apps.
AndroidClass LoadingVerification
0 likes · 6 min read

This article explains how an iOS/macOS application is launched, detailing the interaction between dyld and the Objective‑C runtime, the initialization steps performed by _objc_init, and the series of functions such as environ_init, static_init, map_images, read_images, and load_images that together realize classes, selectors, protocols and +load methods before main() is called.
Class LoadingObjective-C++dyld
0 likes · 19 min read

This article provides an in‑depth overview of the Java Virtual Machine, covering JDK/JRE/JVM relationships, compilation process, class loading mechanisms, the parent‑delegation model, runtime memory areas, garbage collection algorithms and collectors, and practical JVM performance tuning tips for backend developers.
Class LoadingJVMJava
0 likes · 50 min read

This article explains the core components of the Java Virtual Machine, including its memory regions, class loading process, object allocation strategies, garbage‑collection algorithms, and tuning tools, providing a comprehensive guide for developers to optimize Java applications.
Class LoadingJVMJava memory management
0 likes · 29 min read

This article explains Java's parent delegation class‑loading model, describes the four built‑in class loaders, details why delegation is needed, shows the loadClass implementation, and discusses how and why the mechanism can be overridden in frameworks such as JDBC, Tomcat, OSGi, and the Java 9 module system.
Class LoadingClassLoaderCustom ClassLoader
0 likes · 14 min read

This comprehensive guide walks through the Java Virtual Machine's runtime data areas, memory model, heap layout, garbage‑collection mechanisms, HotSpot internals, performance tuning flags, and class‑loading process, providing developers with the essential knowledge to optimize Java applications.
Class LoadingJVMJava Memory Model
0 likes · 29 min read

This comprehensive guide explores Java's JVM internals, covering memory leaks, data type sizes, differences between Serial and Parallel GC, reference types, compressed OOPs, JVM bitness detection, heap limits, JRE/JDK/JVM/JIT distinctions, memory regions, garbage collection algorithms, class loading mechanisms, and practical tuning commands and tools, providing developers with deep insights into Java performance and memory management.
Class LoadingJavagarbage collection
0 likes · 63 min read

This article provides a comprehensive overview of the Java Virtual Machine, covering its runtime data areas, the Java Memory Model, heap organization, garbage‑collection algorithms, HotSpot implementation details, JVM tuning parameters, and the class‑loading mechanism.
Class LoadingJMMJVM
0 likes · 29 min read

This article provides a comprehensive guide to Java's static keyword, covering its use on variables, methods, code blocks, inner classes, static imports, memory placement, lifecycle, serialization, class‑loading order, and common patterns such as logging and the double‑checked‑locking singleton.
Class LoadingJavasingleton
0 likes · 12 min read

This article presents a comprehensive collection of JVM interview questions covering memory areas, garbage collection, class loading, and performance tuning, along with eleven detailed Java mind‑map images that visually summarize core concepts such as the JVM architecture, GC algorithms, and thread management.
Class LoadingInterviewJVM
0 likes · 8 min read

This article provides a comprehensive overview of Java Virtual Machine runtime data areas, the Java Memory Model, heap memory segmentation, garbage collection algorithms, HotSpot VM details, and class loading mechanisms, offering practical insights for performance tuning and system design.
Class LoadingJVMJava
0 likes · 28 min read

This article explains the seven stages of Java class loading—Loading, Verification, Preparation, Resolution, Initialization, Using, and Unloading—detailing each step, the underlying mechanisms, code examples, and practical considerations such as class initialization triggers and the distinction between symbolic and direct references.
Class LoadingInitializationJVM
0 likes · 14 min read

This article explains when and how Java classes are loaded, details the JVM's ClassLoader implementation—including the native defineClass1 method, InstanceKlass creation, SystemDictionary registration, and parallel loading locks—then demonstrates breaking the parent‑delegation model with a custom ClassLoader and discusses practical usage scenarios.
Class LoadingClassLoaderJVM
0 likes · 18 min read

This article provides an extensive overview of Java Virtual Machine fundamentals for interview preparation, covering JVM components, runtime data areas, heap vs. stack memory, garbage collection mechanisms, algorithms, collectors, memory allocation strategies, class loading processes, and tuning tools.
Class LoadingJVMgarbage collection
0 likes · 31 min read

This article provides a detailed explanation of the Java Virtual Machine's runtime memory regions, the Java Memory Model, garbage collection mechanisms, heap layout, HotSpot VM internals, class loading process, and performance tuning parameters, offering a solid foundation for Java developers and architects.
Class LoadingJVMJava
0 likes · 29 min read

This article compares three common Java techniques—using the class literal, Class.forName, and an object's getClass method—to obtain a Class object, demonstrating their distinct effects on class loading, static initialization, and instance creation through detailed code examples and test results.
Class LoadingJVMJava
0 likes · 7 min read

This article explains the three phases of Java class loading—loading, linking, and initialization—detailing how the JVM handles class files, the role of different class loaders, and how to implement a custom class loader with practical code examples.
BackendClass LoadingClassLoader
0 likes · 19 min read

When Java executes a new expression, the JVM first ensures the class is loaded using the parent‑delegation model, then follows a five‑step loading and linking process before allocating heap memory, initializing fields, running static and instance code, and finally returning a reference to the new object.
Class LoadingInitializationJVM
0 likes · 8 min read

This article examines common Java interview questions about static field access, demonstrates how the JVM loads and initializes classes, explains why a subclass may not be initialized when referencing a superclass static variable, and details each phase of the JVM class‑loading lifecycle.
Bytecode VerificationClass LoadingInitialization
0 likes · 13 min read

This article explains the JVM class loading mechanism, covering the loading and unloading process, lifecycle stages, the parent‑delegation model, timing of loading and unloading, practical debugging with -verbose:class, and the impact of custom class loaders on application behavior.
Class LoadingJVMJava
0 likes · 9 min read

The article explains how Java 8 parallel streams in Tomcat containers trigger class‑loading failures because ForkJoinWorkerThreads inherit a null context class loader after Tomcat 7.0.74 introduced SafeForkJoinWorkerThreadFactory, leading to deserialization errors and memory‑leak risks, and recommends avoiding dynamic class loading or using custom thread pools.
Class LoadingDubboForkJoinPool
0 likes · 8 min read

An encrypted Spring @Component class causes a startup failure because Spring reads class files as raw byte arrays using ASM before loading them, and the encrypted bytecode violates JVM specifications, leading to an ArrayIndexOutOfBoundsException; the article explains this scanning mechanism and the hidden cause.
ASMClass LoadingJVMTI
0 likes · 10 min read

This article explains Java reflection fundamentals, including Class object usage, dynamic class loading, method and field introspection, generic type handling, and detailed class loader mechanisms, providing code examples and practical insights for backend developers.
Class LoadingJava APIReflection
0 likes · 8 min read

This article provides a comprehensive overview of the Java Virtual Machine, detailing its main components, runtime data areas, class loading mechanism, garbage collection algorithms and collectors, heap vs stack differences, object reclamation criteria, and common JVM tuning tools and parameters.
Class LoadingJVMJava
0 likes · 10 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

This article provides an in‑depth overview of how Java objects are created and initialized, covering class loading, the various ways to instantiate objects (new, reflection, clone, deserialization), the step‑by‑step memory allocation and field initialization sequence, and the order of static and instance initialization across inheritance hierarchies.
Class LoadingInitializationJVM
0 likes · 16 min read

This article explains the complete lifecycle of a Java class within the JVM, covering memory areas such as the method, heap, and stack regions, and detailing the five stages—loading, linking, initialization, usage, and unloading—along with code examples illustrating active and passive references.
Class LoadingInitializationJVM
0 likes · 16 min read

This article explains the JVM execution process, details the hierarchy and delegation model of class loaders, provides a custom ClassLoader implementation with example code, and describes the structure and function of the runtime data area including heap, method area, stacks, and program counter.
Class LoadingCustom ClassLoaderJVM
0 likes · 11 min read

This article explains the Java Virtual Machine's class loading lifecycle—including loading, verification, preparation, resolution, and initialization—illustrated with multiple code examples that show when static blocks and fields are executed and why certain classes may not be initialized.
Class LoadingInitializationJVM
0 likes · 13 min read

This article provides a comprehensive overview of core Java concepts, including the hierarchy of I/O streams, checked and unchecked exceptions, built‑in and custom annotations, the class‑loader delegation model, important language keywords, multithreading techniques, thread‑pool implementations, and the Java memory model.
AnnotationsClass Loadingexceptions
0 likes · 17 min read

This article explains how Java class loading works, describing the hierarchical delegation model, the three loading phases (loading, linking, initialization), common ClassLoader‑related exceptions, and practical tips for troubleshooting class‑loading issues.
Class Loadingdelegation-modelexceptions
0 likes · 8 min read
