Starten Java App(s) (.jar) aus einem Java Programm

[ralfb1105]

Hallo zusammen,
ich habe diese Frage schon mal indirekt in einem Thread zu meiner DB Anfrage gestellt, glaube aber das es sinnvoller ist dieses Thema als eigenen Thread hier noch einmal "sauber" zu formulieren.

Problemstellung:
Ich habe zwei Java FX Programme als Runnable jar Files. Nun möchte ich eine kleine Applikation schreiben die abfragt welches der zwei FX Programme gestartet werden soll, dieses dann startet und sich danach beendet. Die Runnable jar Files möchte ich gerne innerhalb der kleinen Wrapper App verpacken, damit ich dann am Ende nur ein Executable habe.

Ich habe bei der ersten Recherche das Oracle Tutorial zu "JarClassLoader" gefunden, bin daraus aber nicht ganz schlau geworden.

Wenn ich es richtig verstehe muss ich so einen Jar Class Loader selbst implemntieren - fertig gibt es den als Klasse im JDK nicht - richtig?

Ich habe es mal folgendermassen versucht:

package application;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.jar.Attributes;

public class JarClassLoader extends java.net.URLClassLoader {

    URL url;

    public JarClassLoader(URL url) {
        super(new URL[] { url });
        this.url = url;
    }

    public String getMainClassName() throws IOException {
        URL u = new URL("jar", "", url + "!/");
        JarURLConnection uc = (JarURLConnection) u.openConnection();
        Attributes attr = uc.getMainAttributes();
        return attr != null ? attr.getValue(Attributes.Name.MAIN_CLASS) : null;
    }

    public void invokeClass(String name, String[] args)
            throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException {
        Class c = loadClass(name);
        Method m = c.getMethod("main", new Class[] { args.getClass() });
        m.setAccessible(true);
        int mods = m.getModifiers();
        if (m.getReturnType() != void.class || !Modifier.isStatic(mods) || !Modifier.isPublic(mods)) {
            throw new NoSuchMethodException("main");
        }
        try {
            m.invoke(null, new Object[] { args });
        } catch (IllegalAccessException e) {
            // This should not happen, as we have disabled access checks
        }
    }
}

Das ergibt in Eclipse erst einmal keinen Fehler.

Jetzt weiß ich aber nicht ob so etwas für mein Problem geeignet ist?
Ist das nur für JARs die ich von einer URL lade oder kann man so etwas auch für JARs innerhalb des eigenen Projektes (VuildPath) nehmen?

Wenn ja, wie müsste ich denn jetzt diesen ClassLoader anwenden um z.B. in einer Methode meines Controller (Java FX Appl) die main-Methode eines der .jar Applikation in meinem Build Path zu starten?

Wie Ihr seht - mehr Fragezeichen als Antworten - hoffe Ihr könnt da ein wenig Licht in's dunkle bringen.

Gruß
Ralf

 

[Flown]

Für sowas dynamisches gibt es eine SPI und da musst du dich um vieles nicht selbst kümmern und ist auch typsicher.

 

[ralfb1105]

Hallo Flown,
auch wenn Du es bestimmst geahnt hast und mich vielleicht auch verfluchen wirst - was genau meinst Du mit SPI?
Hättest Du ein paar Code Schnipsel die mich auf den Weg bringen würden?
Gruß
Ralf

 

[mrBrown]

Wenn ich dicht richtig verstehe, möchtest einfach nur ein anderes Java-Programm starten?

Dann brauchst du weder ClassLoader noch SPI: https://stackoverflow.com/questions...jar-in-a-java-program?answertab=votes#tab-top

 

[ralfb1105]

Hallo mrBrown,
im Prinzip ja, allerdings wäre es schön wenn dieses Java Programm (.jar File) Bestandteil meiner Wrapper App wäre und ich somit nur ein Programm habe, welches dann z.B. zwei .jar Files, meine eigentliche JavFX Applikationen, einmal mit und dann ohne Debug Treiber, enthält.
Wenn ich das Beispiel aus Stackoverflow richtig vesrtehe befindet sich das Programm auf OS Ebene und wird dann mittels

Runtime.getRuntime().exec("java -jar OraSimpleConnectFX.jar");

gestartet.

Das von Stackoverflow beschriebene Beispiel habe ich mal implemntiert und es funktioniert wenn mein .jar Datei(en) die ich aus dem Wrapper heraus starten möchte auf Betriebssystem Ebene vorhanden sind:
== Main.java ==

package application;
  
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.stage.Stage;
import javafx.scene.Parent;
import javafx.scene.Scene;


public class Main extends Application {
    @Override
    public void start(Stage primaryStage) {
        try {
            Parent root = FXMLLoader.load(getClass().getResource("main.fxml"));
            Scene scene = new Scene(root);
            scene.getStylesheets().add(getClass().getResource("application.css").toExternalForm());
            primaryStage.setScene(scene);
            primaryStage.show();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
  
    public static void main(String[] args) {
        launch(args);
    }
}

== Controller.java ==

package application;

import java.io.IOException;
import java.io.InputStream;

import javafx.fxml.FXML;
import javafx.scene.control.Button;

public class Controller {

    Process proc;

    @FXML
    Button startButtonTapped;

    public void startJar() {
        try {
            proc = Runtime.getRuntime().exec("java -jar OraSimpleConnectFX.jar");
        } catch (IOException e) {
            e.printStackTrace();
        }
        InputStream in = proc.getInputStream();
        InputStream err = proc.getErrorStream();
    }

}

== main.fxml ==

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.*?>
<?import java.lang.*?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.layout.AnchorPane?>

<VBox maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="157.0" prefWidth="306.0" xmlns="http://javafx.com/javafx/8" xmlns:fx="http://javafx.com/fxml/1" fx:controller="application.Controller">
   <children>
      <HBox alignment="CENTER" prefHeight="61.0" prefWidth="306.0">
         <children>
            <Button fx:id="startButtonTapped" mnemonicParsing="false" onAction="#startJar" text="Start" />
         </children>
      </HBox>
   </children>
</VBox>

Ich habe mein Runnable Application JAR File als "Add External JARs..." im Projekt unter "Java Build Path" hinzugefügt, bin mir aber nicht sicher ob das der Weg wäre.
Wenn ich die Wrapper App starte und auf OS Ebene mein JAR File nicht vorhanden ist wird nicht das aus dem Package genommen - es passiert gar nichts.

Ich hoffe ich habe mich verständlich ausgedrückt und mein Problem verständlich beschrieben. Ohne es im Detail zu wissen muss ich doch irgendwie auf die Main Klasse dieses "externen JAR" zugreifen um meine Applikation "Main.java" zu starten .. ich weiß nur nicht wie
Gruß
Ralf

 

[ralfb1105]

Hallo Flown, mrBrown,

könnt Ihr mir kurz mitteilen ob ich mit meiner Idee (siehe letzen Kommentar von mir) vollkommen daneben liege, soll heißen das es so in keinem Fall machbar ist? Das würde mir die Entscheidung leichter machen dieses Thema zu "kippen" und darin keine Zeit mehr zu investieren. Die Resonanz zeigt ja das ich hier scheinbar keine "offene Türen einrenn kann"

Gruß
Ralf

 

[mrBrown]

In der "Jars normal starten" Variante, kannst du die Jars einfach aus der Haupt-Jar entpacken und irgendwo im Dateisystem speichern.

Die Variante mit eigenem ClassLoader dürfte auch klappen, ist aber deutlich komplizierter.

 

[ralfb1105]

Hallo mrBrown,

Interessanter Ansatz ... ich habe mal ein bisschen gesucht und folgendes gefunden. Wäre das so in etwa das was Du meinst?

   /**
     * Copy a file from source to destination.
     *
     * @param source
     *        the source
     * @param destination
     *        the destination
     * @return True if succeeded , False if not
     */
    public static boolean copy(InputStream source , String destination) {
        boolean succeess = true;

        System.out.println("Copying ->" + source + "\n\tto ->" + destination);

        try {
            Files.copy(source, Paths.get(destination), StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException ex) {
            logger.log(Level.WARNING, "", ex);
            succeess = false;
        }

        return succeess;

    }

Der Aufruf wäre dann in etwa:

copy(getClass().getResourceAsStream("???OraSimpleConnectFX.jar"),getBasePathForClass(Main.class)+"icon.png");

Wie müsste ich denn jetzt mein .jar File in mein Projekt integrieren? Als Library im BuildPath doch nicht — oder?
Ich nutze Eclipse, wäre das dann einfach als „File hinzufügen“?

Gruß

Ralf

 

[mrBrown]

Wie müsste ich denn jetzt mein .jar File in mein Projekt integrieren? Als Library im BuildPath doch nicht — oder?
Ich nutze Eclipse, wäre das dann einfach als „File hinzufügen“?

Ja, als normale File sollte klappen

 

[Flown]

Ich persönlich mag das rumgefrickle nicht mit den ClassLoadern, ist einfach zu fehleranfällig IMHO. Hier ist ein SPI (Service Provider Interface) Beispiel, da dein Classpath ja schon vordefiniert ist: HIER.

 

[mrBrown]

Ich persönlich mag das rumgefrickle nicht mit den ClassLoadern, ist einfach zu fehleranfällig IMHO. Hier ist ein SPI (Service Provider Interface) Beispiel, da dein Classpath ja schon vordefiniert ist: HIER.

In diesem Fall ist das Problem, dass die Klassen doppelt in Classpath liegen, und entweder die aus der einen Jar oder die aus der anderen geladen werden müssen.
Ging aus irgendeinem anderen Thread hervor.

 

[ralfb1105]

Hallo Flown, mrBrown,

Danke erst einmal für Eure Ideen und Ratschläge. Da die Lösung mit ClassLoader und/oder SPI für mich zur Zeit noch mehrere Nummern zu hoch ist, habe ich die Idee von mrBrown aufgegriffen und mit Hilfe von einem StackOverflow Beitrag nun folgende Lösung implementiert. Es gibt hier erst einmal nur ein JAR File, welches dann je nach Auswahl ein weiteres JAR File aus dem Projekt Package in das Filesystem kopiert und dann dort ausführt. Bezogen auf das Beipiel aus diesem Thread habe ich nun folgenden Controller implementiert, wohl wissend das einige Methoden in ein Model gehören - aber das kommt dann noch

package application;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.logging.Level;
import java.util.logging.Logger;

import javafx.fxml.FXML;
import javafx.scene.control.Button;

public class Controller {

    Process proc;
    String jarFileName1 = "OraSimpleConnectFX.jar";

    @FXML
    Button startButtonTapped;

    public void copyJar() {
        copy(getClass().getResourceAsStream("/jars/" + jarFileName1),
                getBasePathForClass(Controller.class) + jarFileName1);
        startJar(jarFileName1);
    }

    public void startJar(String jarName) {
        try {
            String cmd = "java -jar " + jarName;
            proc = Runtime.getRuntime().exec(cmd);
        } catch (IOException e) {
            e.printStackTrace();
        }
        InputStream in = proc.getInputStream();
        InputStream err = proc.getErrorStream();
        System.exit(0);
    }

    /**
     * Copy a file from source to destination.
     *
     * @param source      the source
     * @param destination the destination
     * @return True if succeeded , False if not
     */
    public static boolean copy(InputStream source, String destination) {
        boolean succeess = true;
        // System.out.println("Copying ->" + source + "\n\tto ->" + destination);
        try {
            Files.copy(source, Paths.get(destination), StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException ex) {
            ex.printStackTrace();
            succeess = false;
        }
        return succeess;
    }

    /**
     * Returns the absolute path of the current directory in which the given class
     * file is.
     *
     * @param classs
     * @return The absolute path of the current directory in which the class file
     *         is.
     * @author GOXR3PLUS[StackOverFlow user] + bachden [StackOverFlow user]
     */
    public static final String getBasePathForClass(Class<?> classs) {

        // Local variables
        File file;
        String basePath = "";
        boolean failed = false;

        // Let's give a first try
        try {
            file = new File(classs.getProtectionDomain().getCodeSource().getLocation().toURI().getPath());

            if (file.isFile() || file.getPath().endsWith(".jar") || file.getPath().endsWith(".zip")) {
                basePath = file.getParent();
            } else {
                basePath = file.getPath();
            }
        } catch (URISyntaxException ex) {
            failed = true;
            Logger.getLogger(classs.getName()).log(Level.WARNING,
                    "Cannot firgue out base path for class with way (1): ", ex);
        }

        // The above failed?
        if (failed) {
            try {
                file = new File(classs.getClassLoader().getResource("").toURI().getPath());
                basePath = file.getAbsolutePath();

                // the below is for testing purposes...
                // starts with File.separator?
                // String l = local.replaceFirst("[" + File.separator +
                // "/\\\\]", "")
            } catch (URISyntaxException ex) {
                Logger.getLogger(classs.getName()).log(Level.WARNING,
                        "Cannot firgue out base path for class with way (2): ", ex);
            }
        }

        // fix to run inside eclipse
        if (basePath.endsWith(File.separator + "lib") || basePath.endsWith(File.separator + "bin")
                || basePath.endsWith("bin" + File.separator) || basePath.endsWith("lib" + File.separator)) {
            basePath = basePath.substring(0, basePath.length() - 4);
        }
        // fix to run inside netbeans
        if (basePath.endsWith(File.separator + "build" + File.separator + "classes")) {
            basePath = basePath.substring(0, basePath.length() - 14);
        }
        // end fix
        if (!basePath.endsWith(File.separator)) {
            basePath = basePath + File.separator;
        }
        return basePath;
    }

}

Dem Start Button wird die copyJar() Methode zugewiesen. Jetzt kann man die Wrapper App noch um eine ChoiceBox/RadioButton erweitern in der man die zu startende Anwendung auswählt.

Wenn auch vielleicht nicht die eleganteste Lösung, aber immerhin eine die ich einigermaßen verstehe und implemntieren kann .

Gruß

Ralf

 

[Flown]

In diesem Fall ist das Problem, dass die Klassen doppelt in Classpath liegen, und entweder die aus der einen Jar oder die aus der anderen geladen werden müssen.
Ging aus irgendeinem anderen Thread hervor.

Es geht doch darum die Runnable Jars zu starten oder? Egal welche Klassen darin enthalten sind oder nicht?

 

[ralfb1105]

Hallo Flown,
ja, ich möchte die Runnable Jar, je nach vorheriger Selection, starten und die Wrapper App beenden. Die Runnable Jar(s) liegen z.B. wie im Beispiel oben, als "File" im package "jars".

Gruß
Ralf

 

[mrBrown]

Es geht doch darum die Runnable Jars zu starten oder? Egal welche Klassen darin enthalten sind oder nicht?

So wie ich das verstanden hab, ist es die Fortführung dieses Threads: https://www.java-forum.org/thema/zwei-ojdbc-driver-in-einer-applikation.183822/

 

[ralfb1105]

Hallo zusammen,

So wie ich das verstanden hab, ist es die Fortführung dieses Threads: https://www.java-forum.org/thema/zwei-ojdbc-driver-in-einer-applikation.183822/

Im Prinzip ja, allerdings hatte der o.g. Thread einen anderen Ansatz verfolgt -> zwei unterschiedliche (Debug mit und ohne) JDBC Treiber in einer Applikation. Im Laufe des Threads kamen dann aber andere Ansätze hinzu:

1. Wrapper App (stg)
2. JDBC Debugging programatically (mihe7)

Ansatz 2. habe ich mit Hilfe von mihe7 hinbekommen, allerdings habe ich gemerkt das es noch viele Randbedingungen gibt (logging.properties, System.properties) die es dann widerrum schwierig macht so dass ich diese Lösung verworfen habe

Ich habe mich dann dem Ansatz 1. gewidmet, eine Wrapper App. Da ich es für sinnvoll hielt das nicht unter dem Datenbank Threat weiter zu thematisieren habe ich diesen neuen Threat eröffnet , und damit bei Euch leider Verwirrung gestiftet - SORRY.

Das Ziel dieses Threats istes das ich eine Java Applikation schreibe die ein oder mehrere andere Applikationen (Runnable Jar's oder als External JAR??) im Bauch hat und je nach User Selektion in der Wrapper App dann die ausgewählte Applikation startet. Die Auswahl wäre dann z.B. einmal mein Programm mit ojdbc*_g.jar (Debug) und einmal ojdbc.jar (ohne Debug). Den Ansatz von mrBrown konnte ich erfolgreich realisieren (s.o) ich kopiere die enthaltenen Files (Runnable jars) aus der Wrapper App in das Filesystem und starte diese dann aus der Wrapper App heraus mittels "proc = Runtime.getRuntime().exec(cmd);" Aufruf.

Vor dieser Idee war mein Ansatz, welcher laut mrBrown aber um einiges schwieriger ist, einen eigenen ClassLoader zu haben der je nach Selektion die Main Klasse aus dem "External Jar??", oder wie immer man das richtig einbindet, startet.Damit hätte ich das kopieren in das Filesystem gespart.

Ich hoffe ich habe jetzt ein wenig Licht in's Dunkel gebracht
Wenn jemand ein Beispiel für einen solchen ClassLoader hat, bin ich gerne bereit das mal zu testen.

Gruß
Ralf

 

[ralfb1105]

Hallo,
noch eine Korrektur, falls jemand den Thread verfolgt und den Code verwenden möchte. Die Methode "public static final String getBasePathForClass(Class<?> classs)" schmeißt bei mir eine NPE wenn ich die Wrapper App als Runnable jar starte - unter Eclipse läuft alles rund. Ich habe die Ermittlung des BasePath nun wie folgt realisiert:

model.copy(getClass().getResourceAsStream("/jars/" + applicationChoiceBox.getValue() + ".jar"),
                Paths.get(".").toAbsolutePath().normalize().toString() + File.separator
                        + applicationChoiceBox.getValue() + ".jar");

Die Zeile

Paths.get(".").toAbsolutePath().normalize().toString() + File.separator

liefert den Absoluten Pfad zurück incl. "/" oder "\" - getestet under Windows 10 und Mac OS.

Gruß
Ralf

 

[mihe7]

Ich weiß ja nicht, was Du loggen willst. Aber wäre nicht etwas wie https://drill.apache.org/api/1.2/jdbc/org/apache/drill/jdbc/proxy/TracingProxyDriver.html der einfachere Weg?

 

[ralfb1105]

Hallo mihe7,

Ich weiß ja nicht, was Du loggen willst.

Mir geht es um detailierte Trace Meldungen des JDBC Treibers, was genau kann man im Support im Vorfeld nicht genau sagen So wie ich

https://drill.apache.org/api/1.2/jdbc/org/apache/drill/jdbc/proxy/TracingProxyDriver.html

verstehe/lese werden hier die Values/Parameter und die Exceptions protkolliert. Der Debug JDBC Treiber gibt mehr Einblick in den Aufbau der Verbindung (TCP/IP etc.). Das weitere Problem für mich wäre das der o.g. ProxyTreiber nur auf stdout protokolliert .. man kann das bestimmt irgendwie auffangen und an mein Text Feld übergeben, aber da fehlt mir dann wahrscheinlich wieder das Know-How.

Trotzdem Danke für Deinen Tipp, ich behalte das mal im Hinterkopf, werde erst einmal mit der WrapperApp weiter machen.

Gruß
Ralf