为什么在Java中这么做呢？如果您想拥有任何类型的模块系统，您需要能够动态加载jar。我被告知有一种方法可以通过编写自己的ClassLoader来做到这一点，但这对于应该（至少在我看来）像调用带有jar文件的方法一样容易的事情来做很多工作。参数。
对于执行此操作的简单代码有何建议？
答案 0 :(得分：220)
安全的原因很难。类加载器意味着不可变;你不应该在运行时不断添加类。我真的很惊讶它与系统类加载器一起工作。以下是制作自己的子类加载器的方法：
URLClassLoader child = new URLClassLoader(
new URL[] {myJar.toURI().toURL()},
this.getClass().getClassLoader()
);
Class classToLoad = Class.forName("com.MyClass", true, child);
Method method = classToLoad.getDeclaredMethod("myMethod");
Object instance = classToLoad.newInstance();
Object result = method.invoke(instance);
痛苦，但确实存在。
答案 1 :(得分：133)
以下解决方案是hackish，因为它使用反射来绕过封装，但它可以完美地工作：
File file = ...
URL url = file.toURI().toURL();
URLClassLoader classLoader = (URLClassLoader)ClassLoader.getSystemClassLoader();
Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(classLoader, url);
答案 2 :(得分：48)
你应该看看OSGi，例如在Eclipse Platform中实施。它正是如此。您可以安装，卸载，启动和停止所谓的捆绑包，这些捆绑包实际上是JAR文件。但它提供了更多，因为它提供了例如可以在运行时在JAR文件中动态发现的服务。
或者查看Java Module System的规范。
答案 3 :(得分：40)
JCL class loader framework怎么样？我不得不承认，我没有用它，但看起来很有希望。
用法示例：
JarClassLoader jcl = new JarClassLoader();
jcl.add("myjar.jar"); // Load jar file
jcl.add(new URL("http://myserver.com/myjar.jar")); // Load jar from a URL
jcl.add(new FileInputStream("myotherjar.jar")); // Load jar file from stream
jcl.add("myclassfolder/"); // Load class folder
jcl.add("myjarlib/"); // Recursively load all jar files in the folder/sub-folder(s)
JclObjectFactory factory = JclObjectFactory.getInstance();
// Create object of loaded class
Object obj = factory.create(jcl, "mypackage.MyClass");
答案 4 :(得分：24)
虽然这里列出的大多数解决方案要么是黑客（JDK 9之前的版本）很难配置（代理程序），要么就是不再工作（JDK 9之后），我发现没有人提到clearly documented method实在令人惊讶。 / p>
您可以创建一个自定义系统类加载器，然后您可以自由地做任何您想做的事情。不需要反射，所有类都共享同一个类加载器。
启动JVM时，添加以下标志：
java -Djava.system.class.loader=com.example.MyCustomClassLoader
类加载器必须具有接受类加载器的构造函数，该类加载器必须设置为其父类。在JVM启动时将调用构造函数，并传递真实的系统类加载器，而主类将由自定义加载器加载。
要添加jar，只需调用ClassLoader.getSystemClassLoader()并将其转换为您的班级即可。
检出this implementation，以获取精心制作的类加载器。请注意，您可以将add()方法更改为public。
答案 5 :(得分：21)
这是一个未弃用的版本。我修改了原始文件以删除已弃用的功能。
/**************************************************************************************************
* Copyright (c) 2004, Federal University of So Carlos *
* *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted *
* provided that the following conditions are met: *
* *
* * Redistributions of source code must retain the above copyright notice, this list of *
* conditions and the following disclaimer. *
* * Redistributions in binary form must reproduce the above copyright notice, this list of *
* * conditions and the following disclaimer in the documentation and/or other materials *
* * provided with the distribution. *
* * Neither the name of the Federal University of So Carlos nor the names of its *
* * contributors may be used to endorse or promote products derived from this software *
* * without specific prior written permission. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT *
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR *
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR *
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
**************************************************************************************************/
/*
* Created on Oct 6, 2004
*/
package tools;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
/**
* Useful class for dynamically changing the classpath, adding classes during runtime.
*/
public class ClasspathHacker {
/**
* Parameters of the method to add an URL to the System classes.
*/
private static final Class<?>[] parameters = new Class[]{URL.class};
/**
* Adds a file to the classpath.
* @param s a String pointing to the file
* @throws IOException
*/
public static void addFile(String s) throws IOException {
File f = new File(s);
addFile(f);
}
/**
* Adds a file to the classpath
* @param f the file to be added
* @throws IOException
*/
public static void addFile(File f) throws IOException {
addURL(f.toURI().toURL());
}
/**
* Adds the content pointed by the URL to the classpath.
* @param u the URL pointing to the content to be added
* @throws IOException
*/
public static void addURL(URL u) throws IOException {
URLClassLoader sysloader = (URLClassLoader)ClassLoader.getSystemClassLoader();
Class<?> sysclass = URLClassLoader.class;
try {
Method method = sysclass.getDeclaredMethod("addURL",parameters);
method.setAccessible(true);
method.invoke(sysloader,new Object[]{ u });
} catch (Throwable t) {
t.printStackTrace();
throw new IOException("Error, could not add URL to system classloader");
}
}
public static void main(String args[]) throws IOException, SecurityException, ClassNotFoundException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException{
addFile("C:\\dynamicloading.jar");
Constructor<?> cs = ClassLoader.getSystemClassLoader().loadClass("test.DymamicLoadingTest").getConstructor(String.class);
DymamicLoadingTest instance = (DymamicLoadingTest)cs.newInstance();
instance.test();
}
}
答案 6 :(得分：14)
使用 Java 9 ，URLClassLoader的答案现在会出现如下错误：
java.lang.ClassCastException: java.base/jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to java.base/java.net.URLClassLoader
这是因为使用的类加载器已经改变。相反，要添加到系统类加载器，您可以通过代理使用Instrumentation API。
创建代理类：
package ClassPathAgent;
import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.util.jar.JarFile;
public class ClassPathAgent {
public static void agentmain(String args, Instrumentation instrumentation) throws IOException {
instrumentation.appendToSystemClassLoaderSearch(new JarFile(args));
}
}
添加META-INF / MANIFEST.MF并将其放入具有代理类的JAR文件中：
Manifest-Version: 1.0
Agent-Class: ClassPathAgent.ClassPathAgent
运行代理：
这使用byte-buddy-agent库将代理添加到正在运行的JVM：
import java.io.File;
import net.bytebuddy.agent.ByteBuddyAgent;
public class ClassPathUtil {
private static File AGENT_JAR = new File("/path/to/agent.jar");
public static void addJarToClassPath(File jarFile) {
ByteBuddyAgent.attach(AGENT_JAR, String.valueOf(ProcessHandle.current().pid()), jarFile.getPath());
}
}
答案 7 :(得分：9)
我发现的最好的是org.apache.xbean.classloader.JarFileClassLoader，它是XBean项目的一部分。
这是我过去使用的一个简短方法，用于从特定目录中的所有lib文件创建类加载器
public void initialize(String libDir) throws Exception {
File dependencyDirectory = new File(libDir);
File[] files = dependencyDirectory.listFiles();
ArrayList<URL> urls = new ArrayList<URL>();
for (int i = 0; i < files.length; i++) {
if (files[i].getName().endsWith(".jar")) {
urls.add(files[i].toURL());
//urls.add(files[i].toURI().toURL());
}
}
classLoader = new JarFileClassLoader("Scheduler CL" + System.currentTimeMillis(),
urls.toArray(new URL[urls.size()]),
GFClassLoader.class.getClassLoader());
}
然后使用类加载器，只需执行：
classLoader.loadClass(name);
答案 8 :(得分：6)
如果您使用的是Android，则可以使用以下代码：
String jarFile = "path/to/jarfile.jar";
DexClassLoader classLoader = new DexClassLoader(jarFile, "/data/data/" + context.getPackageName() + "/", null, getClass().getClassLoader());
Class<?> myClass = classLoader.loadClass("MyClass");
答案 9 :(得分：4)
jodonnell提出的解决方案很好，但应该稍微增强一点。我用这篇文章成功开发了我的应用程序。
首先我们要添加
Thread.currentThread().setContextClassLoader(classLoader);
或者您将无法加载存储在jar中的资源（例如spring / context.xml）。
您的罐子进入父类加载器，否则您将无法理解谁正在加载什么。
另见Problem reloading a jar using URLClassLoader
然而，OSGi框架仍然是最佳方式。
答案 10 :(得分：3)
Allain的另一种hackish解决方案版本，也可以在JDK 11上使用：
File file = ...
URL url = file.toURI().toURL();
URLClassLoader sysLoader = new URLClassLoader(new URL[0]);
Method sysMethod = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
sysMethod.setAccessible(true);
sysMethod.invoke(sysLoader, new Object[]{url});
在JDK 11上，它给出了一些过时警告，但作为在JDK 11上使用Allain解决方案的人的临时解决方案。
答案 11 :(得分：3)
另一个适用于我的使用Instrumentation的工作解决方案。它具有修改类加载器搜索的优势，避免了相关类的类可见性问题：
创建座席类别
对于此示例，它必须位于命令行调用的同一jar中：
package agent;
import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.util.jar.JarFile;
public class Agent {
public static Instrumentation instrumentation;
public static void premain(String args, Instrumentation instrumentation) {
Agent.instrumentation = instrumentation;
}
public static void agentmain(String args, Instrumentation instrumentation) {
Agent.instrumentation = instrumentation;
}
public static void appendJarFile(JarFile file) throws IOException {
if (instrumentation != null) {
instrumentation.appendToSystemClassLoaderSearch(file);
}
}
}
修改MANIFEST.MF
添加对代理的引用：
Launcher-Agent-Class: agent.Agent
Agent-Class: agent.Agent
Premain-Class: agent.Agent
我实际上使用的是Netbeans，因此this post有助于如何更改manifest.mf
正在运行
Launcher-Agent-Class仅在JDK 9+上受支持，并且负责加载代理，而无需在命令行上明确定义它：
java -jar <your jar>
在JDK 6+上工作的方式是定义-javaagent参数：
java -javaagent:<your jar> -jar <your jar>
在运行时添加新的Jar
然后您可以根据需要使用以下命令添加jar：
Agent.appendJarFile(new JarFile(<your file>));
在文档中使用此工具我没有发现任何问题。
答案 12 :(得分：3)
这是Allain方法的快速解决方法，以使其与Java的较新版本兼容：
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
try {
Method method = classLoader.getClass().getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(classLoader, new File(jarPath).toURI().toURL());
} catch (NoSuchMethodException e) {
Method method = classLoader.getClass()
.getDeclaredMethod("appendToClassPathForInstrumentation", String.class);
method.setAccessible(true);
method.invoke(classLoader, jarPath);
}
请注意，它依赖于特定JVM内部实现的知识，因此它不是理想的，也不是通用的解决方案。但是，如果您知道将要使用标准的OpenJDK或Oracle JVM，则这是一个快速简便的解决方法。在将来发布新的JVM版本时，它可能还会在某个时候中断，因此您需要牢记这一点。
答案 13 :(得分：3)
万一将来有人搜索它，这种方式对我来说适用于OpenJDK 13.0.2。
我需要在运行时动态实例化许多类，每个类可能具有不同的类路径。
在这段代码中，我已经有一个名为pack的对象，其中包含一些有关我要加载的类的元数据。 getObjectFile（）方法返回该类的类文件的位置。 getObjectRootPath（）方法返回到bin /目录的路径，该目录包含类文件，这些文件包括我要实例化的类。 getLibPath（）方法将路径返回到包含jar文件的目录，该jar文件构成该类所属模块的类路径。
File object = new File(pack.getObjectFile()).getAbsoluteFile();
Object packObject;
try {
URLClassLoader classloader;
List<URL> classpath = new ArrayList<>();
classpath.add(new File(pack.getObjectRootPath()).toURI().toURL());
for (File jar : FileUtils.listFiles(new File(pack.getLibPath()), new String[] {"jar"}, true)) {
classpath.add(jar.toURI().toURL());
}
classloader = new URLClassLoader(classpath.toArray(new URL[] {}));
Class<?> clazz = classloader.loadClass(object.getName());
packObject = clazz.getDeclaredConstructor().newInstance();
} catch (Exception e) {
e.printStackTrace();
throw e;
}
return packObject;
我以前使用Maven依赖项：org.xeustechnologies：jcl-core：2.8来完成此操作，但是在移过JDK 1.8之后，它有时会冻结，并且永远不会返回在Reference :: waitForReferencePendingList（ ）。
我还保留了一个类加载器的映射，以便在我要实例化的类与我已经实例化的类在同一模块中时可以重用它们，我建议这样做。
答案 14 :(得分：2)
这可能是一个较晚的响应，我可以使用DataMelt（http://jwork.org/dmelt）中的jhplot.Web类来做到这一点（fastutil-8.2.2.jar的简单示例）
import jhplot.Web;
Web.load("http://central.maven.org/maven2/it/unimi/dsi/fastutil/8.2.2/fastutil-8.2.2.jar"); // now you can start using this library
根据文档，此文件将在“ lib / user”中下载，然后动态加载，因此您可以在同一程序中立即使用此jar文件中的类。
答案 15 :(得分：1)
请看一下我开始的这个项目：proxy-object lib
此lib将从文件系统或任何其他位置加载jar。它将为jar专用一个类加载器，以确保没有库冲突。用户将能够从加载的jar中创建任何对象并调用其上的任何方法。 此lib旨在从支持Java 7的代码库加载在Java 8中编译的jar。
创建对象：
class Example extends React.Component {
constructor(props) {
super(props);
this.state = {
myArr = []; // this is an array of objects
status:false
}
}
modifyArr = () => {
//some array modifications
this.setState({status:true})
}
render() {
return (
{this.state.status ? null : (<div>`Display your array here`</div>)}
);
}
}
ObjectBuilder支持工厂方法，调用静态函数和回调接口实现。 我将在自述页面上发布更多示例。
答案 16 :(得分：1)
要动态上传jar文件，可以使用我对URLClassLoader的修改。像标准URLClassloader这样，此修改在应用程序运行期间更改jar文件没有问题。所有已加载的jar文件都已加载到RAM中，因此与原始文件无关。
答案 17 :(得分：1)
我需要在运行时为Java 8和Java 9+加载一个jar文件（以上注释对这两个版本均无效）。这是执行此操作的方法（如果可能，请使用Spring Boot 1.5.2）。
public static synchronized void loadLibrary(java.io.File jar) {
try {
java.net.URL url = jar.toURI().toURL();
java.lang.reflect.Method method = java.net.URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{java.net.URL.class});
method.setAccessible(true); /*promote the method to public access*/
method.invoke(Thread.currentThread().getContextClassLoader(), new Object[]{url});
} catch (Exception ex) {
throw new RuntimeException("Cannot load library from jar file '" + jar.getAbsolutePath() + "'. Reason: " + ex.getMessage());
}
}
答案 18 :(得分：0)
我知道我参加晚会很晚，但是我一直在使用pf4j，它是一个插件框架，效果很好。
答案 19 :(得分：-2)
我个人认为java.util.ServiceLoader做得很好。您可以获得示例here。