Eigene .jar mit anderer .jar öffnen

[FelixBaum]

Hallo Leute,

ich habe ein kleines Programm geschrieben, mit dem Programm soll dann ein anderes ebenfalls von mir geschriebenes Programm geöffnet werden, ich weiß nur nicht welchen Pfad ich angeben muss. Die beiden .jar's liegen in einem Verzeichnis.

try {
     Process p = Runtime.getRuntime().exec("notepad");
} catch (Exception e) {
     e.printStackTrace();
}

Damit kann ich notepad öffnen, nur wie öffne ich damit mein anderes Programm ?

 

[Gucky]

Ich glaube es ist möglich die main Methode des anderen Programmes anzusteuern. Aber ich weiß nicht, ob es dann ein "Programm im Programm" oder ein eigenständiges neues wird. Sonst kannst du auch das JRE ansteuern und diesem dein Programm übergeben. Oder mit Desktop.getDesktop().open(PFAD) öffnest du Dateien oder Programme mit dem mit ihnen verknüpften Programm.

 

[Beatsleigher]

    private void start() {
        ProcessBuilder process = new ProcessBuilder(System.getProperty ("java.home") + "/bin/java", "-jar", System.getProperty("user.home") + "/JarZumÖffnen.jar");
Process pr = process.start();
    }

Sent from my GT-I9505 using Tapatalk

 

[notepass]

Das Stichwort hier: Reflections

Damit ist es möglich zur Laufzeit Methoden anderer Java-Dateien auszuführen.

Ich habe ein bespiel in meinen "generals" (Auch wenns sehr verkorst ist und überarbeitet wird in den nächsten Tagen...)

Diese kannst du hier finden: https://github.com/notepass/npGenerals/blob/master/src/de/notepass/general/util/Util.java
Dort findest du die Methode "execMethod" welche eine angegebene Methode aus einer anderen Jar-Datei ausführt. Ich werden den Quellcode noch einmal hier hinein kopieren, jedoch wird dieser im gegensatz zum GitHub-Code wahrscheinlich nicht upgedatet... Schau also besser da nach 😉

Hier der zu diesem Zeitpunkt aktuelle Code:

/**
     * <p>Executes a method from a external jar</p>
     * @param AjarFile Jar-File from that the code should be excuted
     * @param sourceClass Class from which the code should be executed
     * @param method Execution method
     * @param parameterTypes List of classes to use for the call
     * @param args Value of the parameters
     * @return Return of method
     * @throws IOException
     * @throws ClassNotFoundException
     * @throws NoSuchMethodException
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws InvocationTargetException
     */
    //Executes an Method form an external Java-Application
    public static Object execMethod(File AjarFile, String sourceClass, String method, Class<?> [] parameterTypes, Object [] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //Load .jar Files
        String jarFilePath=AjarFile.getAbsolutePath();

        JarFile jarFile = new JarFile( jarFilePath/*path*/);
        Enumeration e = jarFile.entries();

        URL[] urls = {new URL("jar:file:"+jarFilePath+"!/")};
        URLClassLoader c1 = URLClassLoader.newInstance(urls);

        while (e.hasMoreElements()) {
            JarEntry je = (JarEntry) e.nextElement();
            if (je.isDirectory() || !je.getName().endsWith(".class")) {
                continue;
            }
            String className = je.getName().substring(0,je.getName().length()-6);
            className = className.replace("/",".");
            Class<?> endClass = c1.loadClass(className);
            if (className.equals(sourceClass)) {
                Method m1 = endClass.getDeclaredMethod(method,parameterTypes);
                return m1.invoke(endClass.newInstance(),args);
            }
        }
        return null;
    }

Das ist jetzt natürlich nur schlechter C&P-Code, aber um es in etwa zu verstehen müsste es reichen...
Wenn nicht, google doch einfach mal nach Reflections 😉


MFG,
note

 

[FelixBaum]

Danke erstmal für die schnellen und umfangreichen Antworten. :toll:

Ich hatte jetzt an irgendwie sowas gedacht:

try {
     Process p = Runtime.getRuntime().exec("./Dateizumöffnen.jar");
} catch (Exception e) {
     e.printStackTrace();
}

Ist sowas nicht möglich ? :rtfm:

 

[Beatsleigher]

Danke erstmal für die schnellen und umfangreichen Antworten. :toll:

Ich hatte jetzt an irgendwie sowas gedacht:

try {
     Process p = Runtime.getRuntime().exec("./Dateizumöffnen.jar");
} catch (Exception e) {
     e.printStackTrace();
}

Ist sowas nicht möglich ? :rtfm:

Wenn du mit Process arbeiten willst, musst du den Code nehmen, den ich geschrieben habe. Da ist alles drin, was zum Starten der Jar benötigt wird.

Sent from my GT-I9505 using Tapatalk

 

[FelixBaum]

Wenn du mit Process arbeiten willst, musst du den Code nehmen, den ich geschrieben habe. Da ist alles drin, was zum Starten der Jar benötigt wird.

Sent from my GT-I9505 using Tapatalk

Und was muss ich dann als Pfad angeben ? Muss dann auch bei dem 2. System.getProperty "user.home" in die Klammer ? Wenn ich nicht weiß, wo der User die Dateien liegen hat, was muss ich dann eintragen ?

 

[Beatsleigher]

Und was muss ich dann als Pfad angeben ? Muss dann auch bei dem 2. System.getProperty "user.home" in die Klammer ? Wenn ich nicht weiß, wo der User die Dateien liegen hat, was muss ich dann eintragen ?

Als Pfad gibst du den Pfad zur Jar ein. Das war nur ein Beispiel.
Das Beispiel war darauf bezogen, dass du die Jar in dem Nutzerordner gespeichert hattest, und ja, da es eine Methode ist, muss es

 System.getProperty("user.home");

sein.

Wenn du nicht weißt, wo der user die Datein hat, kannst du ganz einfach mit ein paar rekursiven Funktionen danach suchen.

Hier ist eine Beispiel-Methode aus eines meiner Programme, die jedoch nicht Datein sucht, sondern diese löscht. Aber mit ein bisschen Willenskraft, kriegst du es schon heraus 🙂

private void delete(File file) throws IOException {
        if (file.isDirectory()) {
            if (file.list().length == 0) {
                file.delete();
            } else {
                for (String tmp : file.list()) {
                    File fileToDelete = new File(file, tmp);
                    
                    // Delete files recursively
                    delete(fileToDelete);
                }
            }
            if (file.list().length == 0) {
                file.delete();
            }
            
        } else {
            file.delete();
        }
    }