Tagged articles
Class Loader
18 articles · Page 1 of 1
This article provides a comprehensive technical walkthrough of Tomcat, covering its connector and container architecture, lifecycle management, key design patterns such as Composite and Template Method, custom class‑loading mechanisms, hot‑reload process, and includes essential code snippets and diagrams for developers.
Class LoaderJavaTomcat
0 likes · 43 min read

This tutorial explains Java class loaders—including bootstrap, platform, and system loaders—their delegation model, visibility rules, and how to create custom loaders, providing code examples and a clear overview of their role in the JVM.
Class LoaderJVMcustom-loader
0 likes · 17 min read

Spring Boot’s Fat Jar packages all application code, dependencies, and an embedded server into a single executable JAR, breaking the parent‑delegation model with a custom class loader and protocol handler, enabling simple ‘java -jar’ execution, streamlined deployment, and benefits for microservices and Docker layering.
Class LoaderFat JARJava
0 likes · 10 min read

This guide explains how Spring Boot applications can dynamically load and unload JAR files at runtime—covering the underlying concepts, benefits such as modularity and hot‑plugging, and step‑by‑step implementations using SpringBootClassLoader as well as the OSGi resource‑locator library.
Class LoaderDynamic JAR LoadingJava
0 likes · 9 min read

This article explains why JDBC breaks Java’s parent delegation model, describing how the SPI mechanism combined with the thread‑context class loader enables dynamic loading of third‑party drivers, preserving core advantages while allowing flexible driver discovery and loading.
Class LoaderJDBCJava
0 likes · 5 min read

This article explains the Java Virtual Machine's two subsystems—Class Loader and Execution Engine—and its two main components—Runtime Data Area and Native Interface—detailing their functions, internal structures, and the overall execution workflow of Java programs.
Class LoaderExecution EngineJVM
0 likes · 5 min read

This article dissects Tomcat’s mature architecture, explaining its macro and micro design, startup flow, connector and container components, lifecycle management, class‑loader hierarchy, hot‑reload mechanism, and how developers can apply the demonstrated patterns such as composite, observer, template method, and strategy in real projects.
Class LoaderJavaTomcat
0 likes · 43 min read

This article reviews Java’s default class loading mechanism, explains the parent‑delegation model, then details how Tomcat’s custom class loaders (Common, Catalina, Shared, Webapp, Jasper) intentionally deviate from that model to achieve isolation, versioning, and hot‑swap capabilities for web applications.
Class LoaderJVMJava
0 likes · 15 min read


ITPUBSep 4, 2022 · Backend Development
This article explores Tomcat’s mature architecture, detailing its macro and micro design, the roles of connectors, containers, lifecycle management, class loaders, and the design patterns that enable modularity, extensibility, and hot‑reloading, while offering practical tips for reading and applying its source code.
Class LoaderJavaTomcat
0 likes · 42 min read

Explore Tomcat’s mature architecture, from its connector and container components to class loader hierarchy, revealing how design patterns like composite, observer, and template method shape its modular, extensible system and offering practical insights for mastering Java web server internals.
Class LoaderJavaTomcat
0 likes · 42 min read

This article explains how the spring-boot-maven-plugin creates a self‑contained executable JAR, describes its internal structure, the manifest configuration, and details the function of Spring Boot Loader classes such as JarLauncher and LaunchedURLClassLoader in launching the application.
Class LoaderJarLauncherJava
0 likes · 11 min read

This article introduces the Java Virtual Machine’s overall architecture and its runtime data areas, covering class files, class loaders, execution engine components, native interfaces, and detailed explanations of the program counter, stacks, heap, method area, and constant pool, providing a solid foundation for Java developers.
Class LoaderExecution EngineJava
0 likes · 24 min read

This article provides an in‑depth analysis of Tomcat’s architecture, covering its core components such as connectors, containers, lifecycle management, class‑loader hierarchy, and design patterns like composite, observer, and template method, while offering practical guidance for reading source code and applying these concepts in real projects.
BackendClass LoaderJava
0 likes · 40 min read

This article explains how Spring Boot’s spring-boot-maven-plugin packages an application into an executable JAR, details the internal jar layout, the role of the MANIFEST.MF and JarLauncher, and walks through the custom class‑loading mechanism that launches the Spring application.
Class LoaderJarLauncherMaven Plugin
0 likes · 12 min read

This article explains the Java Virtual Machine’s architecture, covering its role as the JRE implementation, the three main subsystems—class loader, runtime data area, and execution engine—and detailing components such as class loading phases, memory areas, the interpreter, JIT compiler, and garbage collection.
Class LoaderJITJVM
0 likes · 7 min read

This article explains the JVM and Tomcat class‑loading mechanisms, describes the parent‑delegation model, outlines the specific loaders Tomcat creates at startup, and shows why classes compiled from a project's src folder are preferred over those packaged in JARs.
BackendClass LoaderJVM
0 likes · 7 min read

This article provides a comprehensive overview of the Java Virtual Machine, covering its cross‑platform nature, core components, class‑loader mechanisms, memory layout, object creation steps, various garbage‑collection algorithms and collectors, as well as common interview questions and answers.
Class LoaderInterviewJVM
0 likes · 35 min read

This article explains where the JVM resides within the JDK, describes its four main components—ClassLoader, Native Interface, Execution Engine, and Runtime Data Areas—and details memory management, garbage‑collection algorithms, collector types, diagnostic commands, and the Java class‑file structure.
Class FileClass LoaderJVM
0 likes · 21 min read
