Dynamic Loading of JAR Files in Spring Boot Applications

This article introduces the concept of dynamically loading JAR packages at runtime in Java applications, emphasizing how it improves flexibility, modularity, and hot‑plug capability without restarting the service.

It first defines dynamic JAR loading, lists its advantages such as increased system flexibility, hot‑swap support, and faster development cycles.

Implementation with Spring Boot

The SpringBootClassLoader, which extends URLClassLoader , is used to load classes and resources from external JARs. A simple command to create a JAR is shown:

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

A Java class DynamicLoading demonstrates how to launch the JAR using JarLauncher :

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"});
    }
}

Using a Third‑Party Library (OSGi Resource Locator)

Adding the osgi-resource-locator dependency in pom.xml enables an alternative loading mechanism:

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

A custom ResourceLocator implementation reads the JAR content via NIO and loads the target class:

import org.osgi.resource.locator.Resource;
import org.osgi.resource.locator.ResourceContent;
import org.osgi.resource.locator.ResourceException;
import org.osgi.resource.locator.ResourceLocator;
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!/";
                    }
                };
            }
        };
            // Locate and load class
            Resource resource = resourceLocator.locate("org.osgi.resource.locator", "()");
            if (resource != null) {
                Class
clazz = resource.loadClass("com.example.demo.MainClass");
                clazz.newInstance();
            }
    }
}

The article concludes that by mastering these techniques, developers can enhance Spring Boot applications with modular, hot‑replaceable components, improving both development efficiency and runtime extensibility.