Dynamic Loading of JAR Files in Spring Boot Applications

This article explains how to dynamically load JAR packages in a Spring Boot application, covering basic concepts and practical implementation using Spring Boot's class loader and third‑party libraries.

1. Introduction

Dynamic loading of components is common in modern web applications. Loading JARs at runtime improves flexibility and extensibility.

Spring Boot provides a convenient way to integrate dynamic JAR loading via its class loader and third‑party libraries.

2. Basic Concepts of Dynamic JAR Loading

2.1 What is dynamic JAR loading?

It refers to loading and unloading classes and resources from a JAR while the application is running, allowing updates without restart.

2.2 Benefits

Improves system flexibility by modularizing functionality.

Enables hot‑plugging of components.

Accelerates development by allowing rapid iteration.

3. Implementing Dynamic JAR Loading in Spring Boot

3.1 Using SpringBootClassLoader

Spring Boot includes SpringBootClassLoader , which extends URLClassLoader and supports dynamic JAR loading.

3.2 Creating a JAR

Example command to create a JAR containing MainClass :

jar cfm example.jar com/example/demo/MainClass .class -C src/main/java .

3.3 Loading the JAR

Code snippet that uses SpringBootClassLoader to launch the JAR:

import org.springframework.boot.loader.JarLauncher;
import org.springframework.boot.loader.Launcher;

public class DynamicLoading {
    public static void main(String[] args) throws Exception {
        Launcher launcher = new JarLauncher();
        launcher.launch(args, new String[]{"com.example.demo.MainClass"});
    }
}

4. Using a Third‑Party Library (osgi‑resource‑locator)

4.1 Adding the Dependency

<dependencies>
    <!-- osgi-resource-locator dependency -->
    <dependency>
        <groupId>org.osgi</groupId>
        <artifactId>org.osgi.resource.locator</artifactId>
        <version>1.0.1</version>
    </dependency>
</dependencies>

4.2 Implementing Dynamic Loading

Sample code that creates a ResourceLocator to locate and load classes from a JAR:

import org.osgi.resource.locator.*;

public class DynamicLoading {
    public static void main(String[] args) throws Exception {
        ResourceLocator resourceLocator = new ResourceLocator() {
            @Override
            public ResourceContent getResourceContent(Resource resource) throws ResourceException {
                return new ResourceContent() {
                    @Override
                    public InputStream getInputStream() throws IOException {
                        return new FileInputStream("example.jar");
                    }
                    @Override
                    public String getURI() {
                        return "jar:file:/path/to/example.jar!/";
                    }
                };
            }
        };
        Resource resource = resourceLocator.locate("org.osgi.resource.locator", "()");
        if (resource != null) {
            Class
clazz = resource.loadClass("com.example.demo.MainClass");
            clazz.newInstance();
        }
    }
}

5. Conclusion

The article demonstrated the concept, benefits, and concrete steps to achieve dynamic JAR loading in Spring Boot, using both the built‑in class loader and an OSGi‑based third‑party solution.