java通过URLClassLoader类加载器加载外部jar代码示例

更新时间：2024年01月31日 15:17:48 作者：luffy5459

ClassLoader翻译过来就是类加载器,普通的java开发者其实用到的不多,但对于某些框架开发者来说却非常常见,下面这篇文章主要给大家介绍了关于java通过URLClassLoader类加载器加载外部jar的相关资料,需要的朋友可以参考下

相信在实际工作中，大家可能会遇到这种需求，这个jar是外部的，并没有添加到项目依赖中，只能通过类加载器加载并调用相关方法。

这种jar加载，其实也简单，我们通过普通的URLClassLoader就可以加载。代码如下所示：

public static URLClassLoader getClassLoader(String url) {
    URLClassLoader classLoader = new URLClassLoader(new URL[]{}, ClassLoader.getSystemClassLoader());
    try {
        Method method = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
        if (!method.isAccessible()) {
            method.setAccessible(true);
        }
        method.invoke(classLoader, new URL("file:" + url));
        return classLoader;
    } catch (NoSuchMethodException | MalformedURLException | InvocationTargetException | IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

这里，只是把jar加载到了虚拟机中，要调用，我们需要根据类名与类加载器来获取类对象。

public static List<Class<?>> getClassListByInterface(String url, ClassLoader classLoader, Class<?> clazz) {
	List<Class<?>> classList = new ArrayList<>();
	if (!clazz.isInterface()) {
		return classList;
	}
	List<String> classNames = new ArrayList<>();
	try (JarFile jarFile = new JarFile(url)) {
		Enumeration<JarEntry> entries = jarFile.entries();
		while (entries.hasMoreElements()) {
			JarEntry jarEntry = entries.nextElement();
			String entryName = jarEntry.getName();
			if (entryName != null && entryName.endsWith(".class")) {
				entryName = entryName.replace("/", ".").substring(0, entryName.lastIndexOf("."));
				classNames.add(entryName);
			}
		}
	} catch (IOException e) {
		throw new RuntimeException(e);
	}

	if (classNames.size() > 0) {
		for (String className : classNames) {
			try {
				Class<?> theClass = classLoader.loadClass(className);
				if (clazz.isAssignableFrom(theClass) && !theClass.equals(clazz)) {
					classList.add(theClass);
				}
			} catch (ClassNotFoundException e) {
				throw new RuntimeException(e);
			}
		}
	}
	return classList;
}

还需要做一些准备：

1，定义一个接口，外部去实现：

import java.util.Map;

public interface IService {
    String name();

    Object process(Map<String, Object> params);
}

2、三方实现：

import com.example.service.IService;
import com.example.util.FileUtil;

import java.util.HashMap;
import java.util.Map;

public class BusinessService implements IService {
    @Override
    public String name() {
        return "Test";
    }

    @Override
    public Object process(Map<String, Object> params) {
        Map<String, Object> result = new HashMap<>();
        result.put("name", name());
        result.put("path", FileUtil.getPath("tmp"));
        return result;
    }
}

我们在这个实现里面，故意调用了另一个三方的依赖FileUtil：

import java.io.File;

public class FileUtil {

    public static String getPath(String name) {
        return String.join(File.separator, "D:", name);
    }
}

打包插件配置：

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>

            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.2</version>
                <configuration>
                    <archive>
                        <manifest>
                            <!--告知maven-jar-plugin添加一个classpath到manifest.mf文件，以及在class-path元素中包含所有依赖项-->
                            <addClasspath>true</addClasspath>
                            <!--所有依赖应该位于lib包 -->
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/classes/lib</outputDirectory>
                            <!--是否不包含间接依赖包-->
                            <excludeTransitive>false</excludeTransitive>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

我们会把三方实现打jar包，jar包含了所需的依赖：

实际中使用，我们需要先获取类加载器，然后获取类对象，再实例化，最后调用对象的方法。

public class BusinessTest {
    public static void main(String[] args) {
        String url = "E:\\workspace\\java\\classloaderexample\\common-test\\target\\common-test-1.0-SNAPSHOT.jar";
        URLClassLoader classLoader = ClassLoaderUtil.getClassLoader(url);
        // URLClassLoader classLoader = ClassLoaderUtil.loadAllJar(url);
        List<Class<?>> classList = ClassLoaderUtil.getClassListByInterface(url, classLoader, IService.class);
        System.out.println(classList);
        for (Class clazz : classList) {
            try {
                IService service = (IService) clazz.newInstance();
                System.out.println(service.process(null));
            } catch (InstantiationException e) {
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

运行报错：

这里报错信息，提示是NoClassDefFoundError:com/example/util/FileUtil。

但是我们进行打包的时候，明明把FileUtil的jar打到了common-test-1.0-SNAPSHOT.jar中了，为什么找不到呢？

这里其实就是今天要说的重点，我们通过URLClassLoader加载jar，确实能加载到相关的类对象，而且实例化也不会有问题，但是我们在调用实例方法的时候，因为这里面使用了其他三方的jar，但是这个三方jar是包含在common-test本身jar内部的，它不能再像文件系统那样读取自己内部的资源。

解决办法就是把common-test里面lib下的jar资源读出来，写入本地。

public static URLClassLoader loadAllJar(String url) {
        URLClassLoader classLoader = new URLClassLoader(new URL[]{}, ClassLoader.getSystemClassLoader());
        Method method;
        try {
            method = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
            if (!method.isAccessible()) {
                method.setAccessible(true);
            }
            method.invoke(classLoader, new URL("file:" + url));
        } catch (NoSuchMethodException | MalformedURLException | InvocationTargetException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        // write to local lib
        try {
            String jarResourceStr = "jar:file:" + url + "!/";
            URL libUrl = new URL(jarResourceStr);
            URLConnection urlConnection = libUrl.openConnection();
            if (urlConnection instanceof JarURLConnection) {
                JarURLConnection jarURLConnection = (JarURLConnection) urlConnection;
                JarFile jarFile = jarURLConnection.getJarFile();
                Enumeration<JarEntry> entries = jarFile.entries();
                String parentPath = Paths.get(url).getParent().toString();
                File libDir = Paths.get(parentPath, "lib").toFile();
                libDir.deleteOnExit();
                boolean isSuccess = libDir.mkdirs();
                if (!isSuccess) {
                    System.out.println("create lib dir fail");
                }
                while (entries.hasMoreElements()) {
                    JarEntry jarEntry = entries.nextElement();
                    String entryName = jarEntry.getName();
                    if (entryName.endsWith(".jar")) {
                        try (InputStream inputStream = classLoader.getResourceAsStream(entryName)) {
                            File target = new File(parentPath, entryName);
                            FileUtils.copyInputStreamToFile(inputStream, target);
                            method.invoke(classLoader, new URL("file:" + target.getPath()));
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        } catch (InvocationTargetException e) {
                            throw new RuntimeException(e);
                        } catch (IllegalAccessException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return classLoader;
    }

这里重新定义了一个类加载器方法，加载jar，获取类加载器之后，把jar包中lib下的jar也写入本地，同样的，也需要把这些jar加载起来。

最后运行调用示例，正确打印：

这里成功调用之后，我们可以看看本地的jar结构：

在common-test-1.0-SNAPSHOT.jar同级目录下，还有一个lib文件夹，这里面就是common-test-1.0-SNAPSHOT.jar依赖的两个jar。

其实本地文件系统有了lib这个目录之后，我们再回过去用getClassLoader()那种方式调用，也是没有问题的。

这是为什么呢？我们可以看看 common-test jar包中的manifest.mf信息：

Manifest-Version: 1.0
Class-Path: lib/common-api-1.0-SNAPSHOT.jar lib/third-party-1.0-SNAPSH
 OT.jar
Build-Jdk-Spec: 1.8
Created-By: Maven JAR Plugin 3.2.2

这里指定的Class-Path是lib/comon-api-1.0-SNAPSHOT.jar lib/third-party-1.0-SNAPSHOT.jar，我们通过类加载器加载了common-test jar，但是它内部的lib路径是common-test-1.0-SNAPSHOT.jar!/lib/xxx.jar，通过普通的文件路径lib/xxx.jar是无法加载的。

上面的代码，如果使用loadAllJar()方法，虽然不会有问题，但是，如果我们获取类加载器，得到类对象信息，在实例化之前，我们不小心调用了classloader.close()把类加载器关闭了，同样会执行报错，如下所示：

本文主要讲如何动态调用外部jar，以及调用外部jar过程中可能遇到的问题。我们需要注意，外部jar内部依赖的jar，虽然在jar中，但是因为路径中包含了!/，并不能被访问到，所以需要将内部jar读出来，并写入本地。

本文其实也隐含了一个知识点，就是如何提取jar内部的资源。我们需要借助流读取的方式来将他们写出来。

完整代码：https://gitee.com/buejee/classloaderexample/

总结

到此这篇关于java通过URLClassLoader类加载器加载外部jar的文章就介绍到这了,更多相关java URLClassLoader加载外部jar内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java中parallelStream().forEach()的踩坑日记
本文主要介绍了Java中parallelStream().forEach()的踩坑日记，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-06-06
SpringBoot集成Nacos的项目实践
本文主要介绍了SpringBoot集成Nacos的项目实践，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-07-07
利用Java连接Hadoop进行编程
这篇文章主要介绍了利用Java连接Hadoop进行编程，文章围绕主题展开详细的内容介绍，具有一定的参考价值，感兴趣的小伙伴可以参考一下
2022-06-06
以Java代码的方式总结几个典型的内存溢出案例
作为程序员,多多少少都会遇到一些内存溢出的场景,如果你还没遇到,说明你工作的年限可能比较短,或者你根本就是个假程序员！哈哈,开个玩笑.今天分享给大家Java内存溢出的相关案例,希望大家在日常工作中,尽量避免写这些low水平的代码,需要的朋友可以参考下
2021-06-06
Java使用Knife4j优化Swagger接口文档的操作步骤
在现代微服务开发中,接口文档的质量直接影响了前后端协作效率,Swagger 作为一个主流的接口文档工具,虽然功能强大,但其默认界面和部分功能在实际使用中略显不足,而 Knife4j 的出现为我们提供了一种增强的选择,本篇文章将详细介绍如何在项目中集成和使用 Knife4j
2024-12-12
spring boot创建项目包依赖问题的解决
本篇文章主要介绍了spring boot创建项目包依赖问题的解决，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-11-11
Hystrix Dashboard断路监控仪表盘的实现详细介绍
这篇文章主要介绍了Hystrix Dashboard断路监控仪表盘的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-09-09
IntelliJ IDEA 2022安装注册永久激活
java开发工具IntelliJ IDEA深受用户喜爱，很多朋友对这个idea开发工具比较忠心，一旦有新版本发出，很多小伙伴就迫不及待的想更新，今天小编给大家带来了idea2022.1最新永久激活码，亲测有效，喜欢的朋友快来下载体验吧
2022-08-08
链表的原理及java实现代码示例
这篇文章主要介绍了链表的原理及java实现代码示例，涉及单向链表的基本介绍，单向链表的Java实现代码分享等相关内容，具有一定参考价值，需要的朋友可以参考下。
2017-11-11
Java多例设计模式实例详解
这篇文章主要介绍了Java多例设计模式,结合实例形式分析了基于Java的多例模式概念、原理、定义与使用方法,需要的朋友可以参考下
2018-05-05

java通过URLClassLoader类加载器加载外部jar代码示例

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具