<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>${maven.dependency.plugin}</version>
<executions>
<!-- erstmal Abhängigkeiten für den Class-Path kopieren -->
<execution>
<id>copy-dependencies</id>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/modules</outputDirectory>
<excludeGroupIds>org.openjfx</excludeGroupIds>
<includeScope>runtime</includeScope>
<artifactItems>
<artifactItem>
<groupId>${project.groupId}</groupId>
<artifactId>${project.artifactId}</artifactId>
<version>${project.version}</version>
<type>${project.packaging}</type>
</artifactItem>
</artifactItems>
<overWriteReleases>false</overWriteReleases>
<overWriteSnapshots>false</overWriteSnapshots>
<overWriteIfNewer>true</overWriteIfNewer>
</configuration>
</execution>
<!-- dazu noch das Projekt-JAR -->
<execution>
<id>copy</id>
<phase>install</phase>
<goals>
<goal>copy</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/modules</outputDirectory>
<artifactItems>
<artifactItem>
<groupId>${project.groupId}</groupId>
<artifactId>${project.artifactId}</artifactId>
<version>${project.version}</version>
<type>${project.packaging}</type>
<destFileName>${project.build.finalName}.jar</destFileName>
</artifactItem>
</artifactItems>
<overWriteIfNewer>true</overWriteIfNewer>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>com.github.akman</groupId>
<artifactId>jpackage-maven-plugin</artifactId>
<version>${jpackage.maven.plugin}</version>
<configuration>
<name>${appName}</name>
<type>IMAGE</type>
<modulepath>
<dependencysets>
<dependencyset>
<includenames>
<includename>javafx\..*</includename>
</includenames>
</dependencyset>
</dependencysets>
</modulepath>
<addmodules>
<addmodule>javafx.controls</addmodule>
<addmodule>javafx.graphics</addmodule>
<addmodule>javafx.fxml</addmodule>
</addmodules>
<mainclass>${main.class}</mainclass>
<input>${project.build.directory}/modules</input>
<mainjar>${jar.file}.jar</mainjar>
</configuration>
<executions>
<execution>
<phase>install</phase>
<goals>
<goal>jpackage</goal>
</goals>
</execution>
</executions>
</plugin>
implementation 'com.google.api-client:google-api-client:2.0.0'
wird dann ein<dependency>
<groupId>com.google.api-client</groupId>
<artifactId>google-api-client</artifactId>
<version>2.0.0</version>
</dependency>
Es wird dann sinnvoll, wenn das Programm z.B. auch mit Parametern aufgerufen können werden muss, von einer anderen Software aus etwa oder wenn DLL-Libraries mit eingebunden werden müssen usw.Schön und gut mit den EXE-Wrappers. Sie sind für mich aber überflüssig, weil sie die Performance kill und den Sachverhalt verkomplizieren.
Leonardo Da Vinci said “simplicity is the ultimate sophistication.” Es is viel einfacher ausführbare JAR als Desktop app (mit icon) zu erstellen als mit irgendeinem EXE Wrapper. Ich habe meine Java App auf Windows 10 & Linux-Mint Cinnamon 21.1 (siehe Bild)
IDE usually has its own CLASSPATH settings which are often different from "installed" JAVA CLASSPATH settings. You should check for the installed CLASSPATH for the jar of package org.kordamp.ikonliin der ide funktioniert ja alles
post mal das Manifest deiner Jar-Datei.Wenn ich die eifnach via java -jar starten will ...
Manifest-Version: 1.0post mal das Manifest deiner Jar-Datei.
Manifest-Version: 1.0
Bundle-Description: JSR305 Annotations for Findbugs
Bundle-License: http://www.apache.org/licenses/LICENSE-2.0.txt
Bundle-SymbolicName: org.jsr-305
Archiver-Version: Plexus Archiver
Built-By: lan
Bnd-LastModified: 1490936130302
Bundle-ManifestVersion: 2
Tool: Bnd-2.1.0.20130426-122213
Export-Package: javax.annotation;uses:="javax.annotation.meta";version="
3.0.2",javax.annotation.concurrent;version="3.0.2",javax.annotation.met
a;uses:="javax.annotation";version="3.0.2"
Bundle-Name: FindBugs-jsr305
Bundle-Version: 3.0.2
Created-By: Apache Maven Bundle Plugin
Build-Jdk: 1.8.0_101
Die jar Datei erstelle ich via Artifacts in der Projectstructure (bei intellij).Ich würde da einfach etwas früher ansetzen: Wie genau baust Du die jar Datei denn? Wenn Du dazu ein gradle Projekt verwendest, dann könntest Du das einmal zeigen. Dann kann man da relativ einfach sagen, was wie zu verbessern wäre.
Das Schlimmste an executable JAR Files ist aus meiner Sicht die Hölle, sowas bei Kunden zu unterstützen. Spätestens, wenn da dann mehrere solche Anwendungen mit unterschiedlichen Versionsanforderungen zusammen kommen, dann wird das relativ schwer.
plugins {
id 'com.github.ben-manes.versions' version '0.46.0'
id 'com.github.johnrengelman.shadow' version '8.1.0'
}
apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: 'java'
apply plugin: 'application'
mainClassName = 'main'
sourceCompatibility = 11
targetCompatibility = 11
version = '1.0'
repositories {
mavenCentral()
google()
}
dependencies {
implementation 'com.google.api-client:google-api-client:2.2.0'
implementation 'com.google.oauth-client:google-oauth-client-jetty:1.34.1'
implementation 'com.google.apis:google-api-services-drive:v3-rev20230212-2.0.0'
implementation 'mysql:mysql-connector-java:8.0.32'
implementation 'com.google.api-client:google-api-client:1.31.1'
implementation 'org.apache.pdfbox:pdfbox:2.0.24'
implementation 'org.bytedeco:javacpp:1.5.6'
implementation 'org.slf4j:slf4j-simple:2.0.0-alpha1'
implementation 'org.postgresql:postgresql:42.3.1'
implementation 'org.kordamp.ikonli:ikonli-swing:12.3.1'
implementation 'org.kordamp.ikonli:ikonli-materialdesign-pack:12.3.1'
}
Wenn Du ein Gradle Projekt hast, dann solltest Du das Projekt auch über Gradle bauen. Das hat den Vorteil, dass man dir dann einfach an den Gradle Projektdateien Änderungen geben kann.Die jar Datei erstelle ich via Artifacts in der Projectstructure (bei intellij).
jar {
manifest {
attributes 'Main-Class': 'deine.MainClass'
}
}
Oh okay. Ich werde mir FAT jar mal angucken. Dachte Intellij macht das alles schon.Wenn Du ein Gradle Projekt hast, dann solltest Du das Projekt auch über Gradle bauen. Das hat den Vorteil, dass man dir dann einfach an den Gradle Projektdateien Änderungen geben kann.
Wenn Du es über IntelliJ machen lässt, dann müsste man da genau prüfen, was Du da alles eingestellt hast und das ist blöd, da man dann an vielen Stellen diverse Dinge anschauen müsste in der Oberfläche. Und Du mischt dann zwei Projekttypen: Einmal Gradle und einmal IntelliJ. Das kann sich dann auch durchaus einmal beissen.
Um in Gradle dem jar eine Manifest Datei zu geben, könntest Du sowas einfügen:
(deine.MainClass natürlich mit der Klasse ersetzen, die die main Methode enthält.JSON:jar { manifest { attributes 'Main-Class': 'deine.MainClass' } }
Dann hast Du eine ganze Menge Abhängigkeiten. Die müssen natürlich auch zur Verfügung stehen. Das könnte man über eine FAT jar machen, d.h. Gradle packt alles, was dein Code braucht, da mit in die JAR Datei:
Da werden diverse Möglichkeiten aufgezeigt.
gradlew shadowJar
Du willst doch das Projekt mit Gradle bauen, dann mach das doch auch mit Gradle.Dachte Intellij macht das alles schon.
Werds nachher mal probieren, habs eben nicht gefunden. Gradle Tool Window shcon, aber nicht wie man da builden kann.Ach ja - hatte ich ganz übersehen - Du hast ja schon ein Plugin für ein ShadowJar (das ist das, was man auch als fat jar bezeichnet). Damit hast Du das Ziel shadowJar und der gezeigte Manifest EIntrag sollte ausreichen.
Also wird nach dem einfügen des gezeigten EIntrags ein
gradlew shadowJar
ausreichen, damit das richtig gebaut wird.
Du willst doch das Projekt mit Gradle bauen, dann mach das doch auch mit Gradle.
Natürlich geht es auch mit IntelliJ, aber Du solltest Dich auf ein Tool festlegen. Das sollte dann bei Dir Gradle sein.
Statt dem Befehl mit dem Gradle Wrapper auf der Kommandozeile solltest Du in IntelliJ ein Gradle Toolfenster haben - darüber solltest Du das Ziel shadowJar auch ausführen können.
Es ist so traurig, dass das der Fehler war.Ach ja - hatte ich ganz übersehen - Du hast ja schon ein Plugin für ein ShadowJar (das ist das, was man auch als fat jar bezeichnet). Damit hast Du das Ziel shadowJar und der gezeigte Manifest EIntrag sollte ausreichen.
Also wird nach dem einfügen des gezeigten EIntrags ein
gradlew shadowJar
ausreichen, damit das richtig gebaut wird.
Du willst doch das Projekt mit Gradle bauen, dann mach das doch auch mit Gradle.
Natürlich geht es auch mit IntelliJ, aber Du solltest Dich auf ein Tool festlegen. Das sollte dann bei Dir Gradle sein.
Statt dem Befehl mit dem Gradle Wrapper auf der Kommandozeile solltest Du in IntelliJ ein Gradle Toolfenster haben - darüber solltest Du das Ziel shadowJar auch ausführen können.