Tagged articles
jar
29 articles · Page 1 of 1
When a Spring Boot project is packaged as a jar it runs with the embedded Tomcat using the application's own configuration, while a war package relies on an external Tomcat container, adopts the container's settings such as the default 8080 port, and requires additional Maven configuration and a ServletInitializer class.
MavenSpring BootTomcat
0 likes · 14 min read

This article explains why a Spring Boot executable JAR runs with an embedded Tomcat while a WAR relies on an external Tomcat, how port and context‑path settings differ, how to modify them, and which packaging is preferable for interviews and production.
Embedded TomcatSpring Bootcontext-path
0 likes · 8 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

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 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 why a Spring Boot application fails to locate a template file when packaged as a JAR, details the step‑by‑step debugging process, and provides code solutions using ClassPathResource or PathMatchingResourcePatternResolver to correctly read resources inside the JAR.
BackendDebuggingJava
0 likes · 5 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 guide explains why SpringBoot JAR files become large when bundled with many external libraries, and provides a step‑by‑step method—including Maven configuration changes and runtime loader settings—to shrink the JAR by removing the BOOT‑INF/lib folder while preserving application functionality.
deploymentjarjar-reduction
0 likes · 5 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 explains why a Spring Boot application runs with the configured port when packaged as a JAR using the embedded Tomcat, but switches to Tomcat's default port and context path when deployed as a WAR, and provides step‑by‑step instructions to package and deploy both formats along with historical context and technical differences.
JavaMavenSpring Boot
0 likes · 14 min read

This article explains the differences between JAR and WAR files, why Spring Boot runs with an embedded Tomcat when packaged as a JAR, how deployment changes when using an external Tomcat, and provides step‑by‑step instructions with Maven configurations to build Spring Boot applications as either JAR or WAR packages.
MavenSpring BootTomcat
0 likes · 14 min read

This article explains the differences between JAR and WAR packaging for Spring Boot applications, shows why embedded Tomcat behaves differently from external Tomcat, and provides step‑by‑step instructions with Maven commands and pom.xml modifications to build both JAR and WAR artifacts.
MavenServletSpring Boot
0 likes · 13 min read

This guide explains what JAR files are, the typical formats they contain for Java applications, and provides step‑by‑step command‑line commands—including jar and unzip—to list, extract, and examine the contents of JAR archives without modifying the original files.
JavaUnzipcommand-line
0 likes · 3 min read

This article explains why a Spring Boot project runs differently when packaged as a JAR versus a WAR, outlines the historical evolution of Java web containers, compares the characteristics of JAR and WAR files, and provides step‑by‑step Maven commands and pom.xml configurations for building both package types.
MavenServletSpring Boot
0 likes · 13 min read

This article explains why a Spring Boot application behaves differently when run as a JAR versus deployed as a WAR, outlines the historical context of servlet containers, compares JAR and WAR formats, and provides step‑by‑step Maven commands and pom.xml modifications for packaging both types.
MavenSpring BootTomcat
0 likes · 13 min read

This article explains common Maven commands, describes why a JAR built for execution cannot be imported by a third‑party project, and provides step‑by‑step solutions using the maven‑compiler‑plugin and maven‑assembly‑plugin to create dependency‑inclusive JARs.
Build ToolsDependency ManagementJava
0 likes · 8 min read

This article describes Qunar's end‑to‑end automated workflow for detecting high‑risk Jar component vulnerabilities, collecting asset information, orchestrating remediation with a SOAR platform, and leveraging the TCDEV auto‑upgrade service to reduce manual effort and improve security operations efficiency.
SOARTCDEVautomation
0 likes · 8 min read

This guide shows how to locate a jar’s source code in Eclipse, edit it (e.g., add a log statement), export the modified project as a new jar—using the FatJar plugin when third‑party dependencies exist—and replace the original jar in a Java application to see the changes.
EclipseFatJarJava
0 likes · 2 min read

This article explains the structure and purpose of JAR files, the META-INF directory, manifest syntax, name‑value pairs, main and per‑entry attributes, signing mechanisms, verification steps, JAR indexing, service‑provider configuration, Class‑Path handling, and package sealing in Java.
JavaService ProviderSigning
0 likes · 26 min read

This guide explains how to place a JAR file on a Windows server, create a batch script that runs the JAR, and configure the Windows Startup folder so the application launches automatically after the system restarts.
Batch fileWindowsautomation
0 likes · 3 min read

This article provides a comprehensive overview of the JAR file format, detailing the structure and purpose of the META-INF directory, manifest sections, signing files, index files, class‑path attributes, and service provider configuration, while also presenting the formal syntax specifications and examples for each component.
IndexService ProviderSigning
0 likes · 23 min read

This guide explains step‑by‑step how to decompile a JAR with JD‑GUI, edit the extracted Java source in Eclipse, recompile the class, replace it in the original JAR, and rebuild the package, providing a practical method for updating embedded class files.
EclipseJD-GUIdecompilation
0 likes · 3 min read

This article explains the fundamentals of Java SPI and JAR mechanisms, showing how to define and load service implementations, explore JAR metadata and commands, understand class‑loader hierarchies, Tomcat’s loader architecture, Spring Boot’s nested JAR handling, and how to create custom class loaders.
ClassLoaderJavaSPI
0 likes · 10 min read

This guide lists the core Spring 3 and Spring 4 modules, explains the purpose of each module, and provides the exact JAR dependencies you need to include when using Spring without Spring Boot, helping avoid compilation and runtime errors.
BackendDependency ManagementJava
0 likes · 4 min read

Learn how to manually upload third‑party JAR files to a Nexus repository by following three simple steps—selecting the upload interface, adding the JAR, and saving the changes—complete with illustrated screenshots for clear guidance.
JavaNexusRepository
0 likes · 2 min read
