Ausführbare jar-Datei mittels Maven generieren

Für bestimmte Java-Projekte ist es durchaus praktisch als Ergebnis eine jar-Datei inklusive der benötigten Abhängigkeiten zu generieren. So kann das Projekt in Form einer einzelnen Datei unkompliziert ausgeliefert werden. Mittels Maven lässt sich dies relativ einfach bewerkstelligen. Dabei wird eine Basis-POM (pom.xml) benötigt, in welcher das Plugin maven-assembly-plugin konfiguriert wird:

<plugin>
	<artifactId>maven-assembly-plugin</artifactId>
	<version>3.1.0</version>
	<configuration>
		<archive>
			<manifest>
				<mainClass>com.example.webservice.Webservice</mainClass>
			</manifest>
		</archive>
		<descriptorRefs>
			<descriptorRef>jar-with-dependencies</descriptorRef>
		</descriptorRefs>
	</configuration>
</plugin>

Soll nach erfolgter Entwicklung die jar-Datei mit den Abhängigkeiten erzeugt werden, muss das Kommando:

mvn clean compile assembly:single

genutzt werden. Damit das Ganze auch beim gewöhnlichen:

mvn package

funktioniert, muss die pom.xml angepasst werden. Dabei wird zur Plugin-Definition ein executions-Block hinzugefügt, welcher dafür sorgt das dass Ziel single auch während der Phase package ausgeführt wird. Die komplette pom.xml sieht dann wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>webservice</artifactId>
    <version>1.0.0</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.1.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.example.webservice.Webservice</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Alle im dependencies-Block verwendeten Abhängigkeiten, werden somit in die jar-Datei übernommen.

jar-Datei in eine exe-Datei verpacken

Bei der Entwicklung von Java-Applikationen kommt am Ende meist eine jar-Datei (die Kurzform von Java Archive) heraus. Soll diese Datei an Otto Normalverbraucher unter Windows ausgeliefert werden, so wundert sich dieser sicherlich etwas. Immerhin erwarten die meisten Normalverbraucher eine ausführbare Datei in Form einer exe-Datei. Mit Hilfe des Tools Launch4j ist das genau das möglich. Launch4j wrappt die jar-Datei und erzeugt eine ausführbare exe-Datei. Daneben kann Launch4j einfache Starter erzeugen, ohne das ganze in eine ausführbare Datei zu wrappen.

Die Projektseite von Launch4j

Launch4j erzeugt zwar ausführbare Dateien für Windows, allerdings kann das es selber neben Windows auch unter macOS und Linux genutzt werden. Die offizielle Seite des Projektes ist unter launch4j.sourceforge.net zu finden. Lizenziert ist Launch4j unter der BSD-Lizenz und damit freie Software. Der Quellcode ist auf SourceForge zu finden, daneben existiert ein Mirror auf GitHub.

APK Dateien dekompilieren

Manchmal ist es doch sehr praktisch eine APK Datei zu dekompilieren, z.B. um ein wenig Reverse Engineering zu betreiben. Nachdem wir die gewünschte APK auf der Festplatte haben laden wir uns dex2jar unter http://code.google.com/p/dex2jar herunter. Mit diesem Tool wandeln wir den Dalvik Intermediate Code in eine JAR (sprich Java) Datei um. Wir wenden dex2jar mittels

dex2jar.sh test.apk

auf unsere APK an. Heraus kommt eine JAR Datei welche wir mit der JD-GUI (zu finden unter http://java.decompiler.free.fr/?q=jdgui) öffnen und uns so anschauen können.

Weitere Informationen gibt es unter:
http://stackoverflow.com/questions/3122635/android-decompile-apk
http://stackoverflow.com/questions/1249973/decompiling-dex-into-java-sourcecode