Spring Web类加载依赖：Fat Jar独立运行与Spring Boot动态加载问题

Hey there! Let's walk through solving your class loading challenges step by step. Your scenario—dynamically loading a Spring Web fat jar (built with maven-assembly-plugin) from another Spring Boot app—has a few key pitfalls around class isolation and dependency conflicts, but we can fix them with targeted config and code changes.

1. Adjust Your Maven Assembly & Dependency Setup #

First, let's avoid dependency bloat and conflicts. Since your host Spring Boot app already includes spring-web and other core Spring dependencies, you don't want to package these into your fat jar (they'll clash with the host's versions).

Update Your spring-web Dependency Scope #

Set the spring-web dependency to provided so it's not included in your fat jar:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <scope>provided</scope>
</dependency>

Tweak maven-assembly-plugin Configuration #

Make sure your assembly plugin excludes provided dependencies and packages only your project's classes + non-provided dependencies. Here's a sample config:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.6.0</version>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <excludeGroupIds>org.springframework</excludeGroupIds>
        <archive>
            <manifest>
                <!-- Optional: If you have a main class, but not necessary for dynamic loading -->
                <mainClass>com.yourpackage.YourMainClass</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

This ensures your fat jar only contains your application code and dependencies that aren't already present in the host Spring Boot app.

2. Use a Custom Class Loader for Dynamic Loading #

Spring Boot uses its own LaunchedURLClassLoader which isolates its dependencies from the system class loader. To avoid conflicts, you need to load your fat jar with a dedicated URLClassLoader that uses the host app's class loader as its parent (following the delegation model, but isolating your jar's classes).

Here's a code snippet to load your jar and instantiate a class:

import java.net.URL;
import java.net.URLClassLoader;
import java.lang.reflect.Method;

public class JarLoader {
    public static Object loadAndInstantiate(String jarPath, String className) throws Exception {
        // Create a URL for your fat jar
        URL jarUrl = new URL("file:" + jarPath);
        // Use the host app's class loader as parent to access shared dependencies (like spring-web)
        URLClassLoader customClassLoader = new URLClassLoader(new URL[]{jarUrl}, 
            JarLoader.class.getClassLoader());
        
        // Load the target class
        Class<?> targetClass = customClassLoader.loadClass(className);
        // Instantiate the class (adjust constructor args if needed)
        return targetClass.getDeclaredConstructor().newInstance();
    }
}

3. Handle Spring Context Initialization (If Applicable) #

If your jar contains Spring-managed beans, you need to initialize a separate Spring Application Context using your custom class loader to avoid mixing with the host app's context:

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringContextLoader {
    public static AnnotationConfigApplicationContext loadSpringContext(String jarPath, Class<?> configClass) throws Exception {
        URL jarUrl = new URL("file:" + jarPath);
        URLClassLoader customClassLoader = new URLClassLoader(new URL[]{jarUrl}, 
            SpringContextLoader.class.getClassLoader());
        
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        // Set the custom class loader for the context
        context.setClassLoader(customClassLoader);
        // Register your configuration class
        context.register(configClass);
        context.refresh();
        
        return context;
    }
}

This ensures Spring uses your isolated class loader to scan and instantiate beans from your jar.

4. Key Troubleshooting Tips #

• Check for Dependency Conflicts: Run mvn dependency:tree on your Spring Web project to identify dependencies that might clash with the host Spring Boot app. Exclude any duplicates in your assembly config.
• Avoid ClassLoader Leaks: Make sure to close your custom URLClassLoader when you're done with the loaded jar (call customClassLoader.close()) to prevent memory leaks.
• Debug Class Loading: Add JVM arguments like -verbose:class to see which class loader is loading which classes, helping you spot conflicts.

内容的提问来源于stack exchange，提问作者Vishal Biyani