Jak dynamicznie ładować pliki JAR w Runtime?

Dlaczego tak trudno jest to zrobić w Javie? Jeśli chcesz mieć dowolny system modułowy, musisz mieć możliwość dynamicznego ładowania plików JAR. Powiedziano mi, że można to zrobić, pisząc własne ClassLoader, ale jest to dużo pracy dla czegoś, co powinno (przynajmniej moim zdaniem) być tak proste, jak wywołanie metody z plikiem JAR jako argumentem.

Wszelkie sugestie dotyczące prostego kodu, który to robi?

Przyczyną tego jest bezpieczeństwo. Programy ładujące klasy mają być niezmienne; nie powinieneś być w stanie nie chcąc dodawać do niego klas w czasie wykonywania. Jestem bardzo zaskoczony, że działa z systemowym modułem ładującym. Oto, jak to robisz, tworząc własny moduł ładujący dziecko:

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

Bolesne, ale jest.

Poniższe rozwiązanie jest hackerskie, ponieważ wykorzystuje odbicie do obejścia enkapsulacji, ale działa bezbłędnie:

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

Powinieneś spojrzeć na OSGi , np. Zaimplementowane w platformie Eclipse . Robi dokładnie to. Możesz instalować, odinstalowywać, uruchamiać i zatrzymywać tak zwane pakiety, które są faktycznie plikami JAR. Ale robi to nieco więcej, ponieważ oferuje np. Usługi, które można dynamicznie wykrywać w plikach JAR w czasie wykonywania.

Lub zobacz specyfikację Java Module System .

Co powiesz na framework ładujący klasy JCL ? Muszę przyznać, że go nie użyłem, ale wygląda obiecująco.

Przykład użycia:

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

Oto wersja, która nie jest przestarzała. Zmodyfikowałem oryginał, aby usunąć przestarzałą funkcjonalność.

/**************************************************************************************************
 * 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();
    }
}

Podczas gdy większość wymienionych tutaj rozwiązań to albo hacki (przed JDK 9) trudne do skonfigurowania (agenty), albo po prostu już nie działają (po JDK 9), uważam za naprawdę szokujące, że nikt nie wspomniał o jasno udokumentowanej metodzie .

Możesz utworzyć niestandardowy moduł ładujący klasy systemowej, a następnie możesz robić, co chcesz. Nie wymaga refleksji, a wszystkie klasy korzystają z tego samego modułu ładującego klasy.

Podczas uruchamiania maszyny JVM dodaj tę flagę:

java -Djava.system.class.loader=com.example.MyCustomClassLoader

Moduł ładujący klasy musi mieć konstruktor akceptujący moduł ładujący, który musi być ustawiony jako jego element nadrzędny. Konstruktor zostanie wywołany podczas uruchamiania JVM i przekaże prawdziwy system ładujący klasy, klasa główna zostanie załadowana przez moduł ładujący niestandardowy.

Aby dodać słoiki, po prostu zadzwoń ClassLoader.getSystemClassLoader()i rzuć je na swoją klasę.

Sprawdź tę implementację, aby uzyskać starannie spreparowany moduł ładujący klasy. Uwaga: możesz zmienić add()metodę na publiczną.

W Javie 9 odpowiedzi z URLClassLoaderteraz dają błąd taki jak:

java.lang.ClassCastException: java.base/jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to java.base/java.net.URLClassLoader

Jest tak, ponieważ zmieniły się używane ładowarki klas. Zamiast tego, aby dodać do modułu ładującego klasy systemowe, można użyć interfejsu API Instrumentacji za pośrednictwem agenta.

Utwórz klasę agenta:

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

Dodaj META-INF / MANIFEST.MF i umieść go w pliku JAR z klasą agenta:

Manifest-Version: 1.0
Agent-Class: ClassPathAgent.ClassPathAgent

Uruchom agenta:

Używa biblioteki byte-buddy-agent, aby dodać agenta do działającej maszyny 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());
    }
}

Najlepsze, co znalazłem, to org.apache.xbean.classloader.JarFileClassLoader, który jest częścią projektu XBean .

Oto krótka metoda, której użyłem w przeszłości, aby utworzyć moduł ładujący klasy ze wszystkich plików lib w określonym katalogu

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

Następnie, aby użyć modułu ładującego klasy, po prostu wykonaj:

classLoader.loadClass(name);

Jeśli pracujesz na Androidzie, działa następujący kod:

String jarFile = "path/to/jarfile.jar";
DexClassLoader classLoader = new DexClassLoader(jarFile, "/data/data/" + context.getPackageName() + "/", null, getClass().getClassLoader());
Class<?> myClass = classLoader.loadClass("MyClass");

Oto krótkie obejście metody Allain w celu zapewnienia jej zgodności z nowszymi wersjami Javy:

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

Pamiętaj, że opiera się on na wiedzy na temat wewnętrznej implementacji konkretnej maszyny JVM, więc nie jest idealna i nie jest rozwiązaniem uniwersalnym. Jest to jednak szybkie i łatwe obejście, jeśli wiesz, że zamierzasz używać standardowego OpenJDK lub Oracle JVM. Może się również zepsuć w przyszłości, gdy zostanie wydana nowa wersja JVM, dlatego należy o tym pamiętać.

Rozwiązanie zaproponowane przez jodonnell jest dobre, ale należy je nieco ulepszyć. Wykorzystałem ten post do udanego opracowania mojej aplikacji.

Przypisz bieżący wątek

Najpierw musimy dodać

Thread.currentThread().setContextClassLoader(classLoader);

lub nie będziesz mógł załadować zasobu (takiego jak spring /ext.xml) przechowywanego w słoiku.

Nie zawiera

twoje słoiki do modułu ładującego klasy nadrzędnej, inaczej nie zrozumiesz, kto co ładuje.

zobacz także Problem z przeładowaniem słoika za pomocą URLClassLoader

Jednak środowisko OSGi pozostaje najlepszym sposobem.

Inna wersja hackish rozwiązania Allain, która działa również na 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});

W JDK 11 daje pewne ostrzeżenia o wycofaniu, ale służy jako rozwiązanie tymczasowe dla tych, którzy używają rozwiązania Allain w JDK 11.

Kolejne działające rozwiązanie z wykorzystaniem Instrumentacji, które działa dla mnie. Ma tę zaletę, że modyfikuje wyszukiwanie modułu ładującego klasy, unikając problemów z widocznością klas dla klas zależnych:

Utwórz klasę agenta

W tym przykładzie musi znajdować się w tym samym słoju wywołanym z wiersza poleceń:

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

Zmodyfikuj plik MANIFEST.MF

Dodanie odwołania do agenta:

Launcher-Agent-Class: agent.Agent
Agent-Class: agent.Agent
Premain-Class: agent.Agent

Właściwie korzystam z Netbeans, więc ten post pomaga zmienić sposób manifestu.mf

Bieganie

Launcher-Agent-ClassJest obsługiwana tylko w JDK 9+ i jest odpowiedzialny za ładowanie agenta bez wyraźnego zdefiniowania go w wierszu poleceń:

 java -jar <your jar>

Sposób, w jaki działa JDK 6+, polega na zdefiniowaniu -javaagentargumentu:

java -javaagent:<your jar> -jar <your jar>

Dodanie nowego słoika w Runtime

Następnie możesz dodać słoik, jeśli to konieczne, za pomocą następującego polecenia:

Agent.appendJarFile(new JarFile(<your file>));

Nie znalazłem żadnych problemów z korzystaniem z tego w dokumentacji.

Jeśli ktoś będzie tego szukał w przyszłości, ten sposób działa dla mnie z OpenJDK 13.0.2.

Mam wiele klas, które muszę dynamicznie tworzyć w czasie wykonywania, każda potencjalnie z inną ścieżką klas.

W tym kodzie mam już obiekt o nazwie paczka, który przechowuje metadane dotyczące klasy, którą próbuję załadować. Metoda getObjectFile () zwraca położenie pliku klasy dla klasy. Metoda getObjectRootPath () zwraca ścieżkę do katalogu bin / zawierającego pliki klas zawierające klasę, którą próbuję utworzyć. Metoda getLibPath () zwraca ścieżkę do katalogu zawierającego pliki jar stanowiące ścieżkę klas dla modułu, którego klasa jest częścią.

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;

Używałem wcześniej zależności Maven: org.xeustechnologies: jcl-core: 2.8, ale po przejściu przez JDK 1.8 czasami się zawiesił i nigdy nie powrócił, utknął „czekając na referencje” w Reference :: waitForReferencePendingList ().

Przechowuję również mapę programów ładujących klasy, aby można było ich ponownie użyć, jeśli klasa, którą próbuję utworzyć, znajduje się w tym samym module co klasa, którą już utworzyłem, co poleciłbym.

proszę spojrzeć na ten projekt, który rozpocząłem: proxy-object lib

Ta biblioteka załaduje jar z systemu plików lub dowolnej innej lokalizacji. Poświęci moduł ładujący dla słoika, aby upewnić się, że nie ma konfliktów bibliotek. Użytkownicy będą mogli utworzyć dowolny obiekt z załadowanego słoika i wywołać dowolną metodę na nim. Ta biblioteka została zaprojektowana do ładowania słoików skompilowanych w Javie 8 z bazy kodu obsługującej Javę 7.

Aby utworzyć obiekt:

    File libDir = new File("path/to/jar");

    ProxyCallerInterface caller = ObjectBuilder.builder()
            .setClassName("net.proxy.lib.test.LibClass")
            .setArtifact(DirArtifact.builder()
                    .withClazz(ObjectBuilderTest.class)
                    .withVersionInfo(newVersionInfo(libDir))
                    .build())
            .build();
    String version = caller.call("getLibVersion").asString();

ObjectBuilder obsługuje metody fabryczne, wywoływanie funkcji statycznych i implementacje interfejsu zwrotnego. Będę publikować więcej przykładów na stronie readme.

Może to być spóźniona odpowiedź, mogę to zrobić w ten sposób (prosty przykład dla fastutil-8.2.2.jar) za pomocą klasy jhplot.Web z DataMelt ( http://jwork.org/dmelt )

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

Zgodnie z dokumentacją plik ten zostanie pobrany w „lib / user”, a następnie załadowany dynamicznie, dzięki czemu można natychmiast rozpocząć korzystanie z klas z tego pliku jar w tym samym programie.

Musiałem załadować plik jar w czasie wykonywania dla java 8 i java 9+ (powyższe komentarze nie działają dla obu tych wersji). Oto metoda, aby to zrobić (używając Spring Boot 1.5.2, jeśli może się to odnosić).

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

Ja osobiście uważam, że java.util.ServiceLoader wykonuje to zadanie całkiem dobrze. Można dostać przykład tutaj .