# Erstellen und Testen Java mit Maven

Erfahren Sie, wie Sie einen CI-Workflow (Continuous Integration) in GitHub Actions erstellen und testen, um Ihr Java Projekt mit Maven zu erstellen und zu testen.

> \[!NOTE]
> Auf GitHub Enterprise Server gehostete Runner werden aktuell nicht auf GitHub unterstützt.

## Einleitung

In diesem Leitfaden erfahren Sie, wie Sie einen Workflow erstellen, der eine kontinuierliche Integration (CI) für Ihr Java Projekt mithilfe des Maven Software-Projektmanagementtools durchführt. Der Workflow, den du erstellst, zeigt Dir, wenn Commits zu einem Pull-Request zu Build- oder Testfehlern für deinen Standard-Zweig führen. Dieser Ansatz kann dazu beitragen, dass dein Code immer brauchbar ist. Sie können Ihren CI-Workflow zum Zwischenspeichern von Dateien und Hochladen von Artefakten aus einer Workflowausführung hochladen.

GitHub-gehostete Runner verfügen über einen Toolcache mit vorinstallierter Software, einschließlich Java-Entwicklungskits (JDKs) und Maven. Die Liste der Software und der vorinstallierten Versionen für JDK und Maven finden Sie unter [Von GitHub gehostete Runner](/de/enterprise-server@3.22/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images).

## Voraussetzungen

Sie sollten mit YAML und der Syntax für GitHub Actions vertraut sein. Weitere Informationen finden Sie unter

* [Workflowsyntax für GitHub Actions](/de/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax)
* [Schreiben von Workflows](/de/enterprise-server@3.22/actions/how-tos/write-workflows)

Es wird empfohlen, ein grundlegendes Verständnis von Java und dem Maven-Framework zu haben. Weitere Informationen findest du in der Maven-Dokumentation im [Maven-Leitfaden zu den ersten Schritten](https://maven.apache.org/guides/getting-started/index.html).

### Verwenden von selbstgehosteten Runnern in GitHub Enterprise Server

Wenn du Setupaktionen (z. B. `actions/setup-LANGUAGE`) in GitHub Enterprise Server mit selbst gehosteten Runnern verwendest, musst du eventuell den Toolscache für Runner ohne Internetzugriff einrichten. Weitere Informationen finden Sie unter [Einrichten des Toolcaches auf selbstgehosteten Runnern ohne Internetzugriff](/de/enterprise-server@3.22/admin/managing-github-actions-for-your-enterprise/managing-access-to-actions-from-githubcom/setting-up-the-tool-cache-on-self-hosted-runners-without-internet-access).

## Verwenden einer Maven-Workflowvorlage

Fügen Sie für einen schnellen Einstieg dem Verzeichnis `.github/workflows` Ihres Repositorys eine Workflowvorlage hinzu.

GitHubstellt eine Workflowvorlage für Maven bereit, die für die meisten Java mit Maven-Projekten funktionieren sollte. In den folgenden Abschnitten dieser Anleitung finden Sie Beispiele dafür, wie diese Workflowvorlage angepasst werden kann.

1. Navigieren Sie auf GitHub zur Hauptseite des Repositorys.

2. Klicke unter dem Repositorynamen auf **<svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-play" aria-label="play" role="img"><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path></svg> Actions**.

   ![Screenshot: Registerkarten für das Repository „github/docs“. Die Registerkarte „Aktionen“ ist mit einem orangefarbenen Rahmen hervorgehoben.](/assets/images/help/repository/actions-tab-global-nav-update.png)

3. Wenn du bereits über einen Workflow im Repository verfügst, klicke auf **Neuer Workflow**.

4. Auf der Seite „Workflow auswählen“ wird eine Auswahl empfohlener Workflowvorlagen angezeigt. Suchen Sie nach "Java mit Maven".

5. Klicken Sie im Workflow "Java mit Maven" auf **Configure**.

   Wenn Sie die Workflowvorlage "Java mit Maven" nicht finden, kopieren Sie den folgenden Workflowcode in eine neue Datei namens `maven.yml` im Verzeichnis `.github/workflows` Ihres Repositorys.

   ```yaml copy
   # Dieser Workflow verwendet Aktionen, die nicht von GitHub zertifiziert sind.
   # Sie werden von einem Drittanbieter bereitgestellt und unterliegen
   # separaten Nutzungsbedingungen, Datenschutzbestimmungen und Support
   # Onlinedokumentation.
   name: Java CI with Maven

   on:
     push:
       branches: [ "main" ]
     pull_request:
       branches: [ "main" ]

   jobs:
     build:
       runs-on: ubuntu-latest

       steps:
       - uses: actions/checkout@v6
       - name: Set up JDK 17
         uses: actions/setup-java@v4
         with:
           java-version: '17'
           distribution: 'temurin'
           cache: maven
       - name: Build with Maven
         run: mvn -B package --file pom.xml

       # Optional: Uploads the full dependency graph to GitHub to improve the quality of Dependabot alerts this repository can receive
       - name: Update dependency graph
         uses: advanced-security/maven-dependency-submission-action@571e99aab1055c2e71a1e2309b9691de18d6b7d6
   ```

6. Bearbeiten Sie den Workflow nach Bedarf. Ändern Sie beispielsweise die Java-Version.

7. Klicke auf **Änderungen committen**.

### Spezifizieren der Java-Version und -Architektur

Die Workflowvorlage richtet `PATH` so ein, dass OpenJDK 8 für die x64-Plattform enthalten ist. Wenn du eine andere Java-Version verwenden willst oder auf eine andere Architektur (`x64` oder `x86`) abzielen möchtest, kannst du die `setup-java`-Aktion verwenden, um eine andere Java-Laufzeitumgebung auszuwählen.

Um etwa Version 11 des JDK zu verwenden, das von Adoptium für die x64-Plattform bereitgestellt wird, kannst du die Aktion `setup-java` verwenden und die Parameter `java-version`, `distribution` und `architecture` für `'11'`, `'temurin'` und `x64` konfigurieren.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - name: Set up JDK 11 for x64
    uses: actions/setup-java@v4
    with:
      java-version: '11'
      distribution: 'temurin'
      architecture: x64
```

Weitere Informationen findest du unter der Aktion [`setup-java`](https://github.com/actions/setup-java).

## Deinen Code bauen und testen

Du kannst die gleichen Befehle verwenden, die du auch lokal verwendest, um deinen Code zu bauen und zu testen.

Die Workflowvorlage führt standardmäßig das `package`-Ziel aus. In der Standard-Maven-Konfiguration lädt dieser Befehl Abhängigkeiten herunter, baut Klassen, führt Tests durch und paketiert Klassen in ihr verteilbares Format, zum Beispiel eine JAR-Datei.

Wenn du zum Bauen deines Projekts andere Befehle verwenden oder ein anderes Ziel auszuführen möchtest, kannst du dies angeben. Sie können beispielsweise das `verify`-Ziel ausführen, das in einer `pom-ci.xml`-Datei konfiguriert ist.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - uses: actions/setup-java@v4
    with:
      java-version: '17'
      distribution: 'temurin'
  - name: Run the Maven verify phase
    run: mvn --batch-mode --update-snapshots verify
```

## Abhängigkeiten „cachen“ (zwischenspeichern)

Du kannst deine Abhängigkeiten zwischenspeichern, um die Workflow-Ausführungen zu beschleunigen. Nach einer erfolgreichen Ausführung wird dein lokales Maven-Repository in einem Cache gespeichert. Bei zukünftigen Workflow-Ausführungen wird der Cache wiederhergestellt, so dass Abhängigkeiten nicht aus entfernten Maven-Repositories heruntergeladen werden müssen. Sie können Abhängigkeiten einfach mithilfe der [`setup-java`-Aktion zwischenspeichern](https://github.com/marketplace/actions/setup-java-jdk) oder die [`cache`-Aktion](https://github.com/actions/cache) verwenden, um eine benutzerdefinierte und stärker erweiterte Konfiguration zu verwenden.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - name: Set up JDK 17
    uses: actions/setup-java@v4
    with:
      java-version: '17'
      distribution: 'temurin'
      cache: maven
  - name: Build with Maven
    run: mvn --batch-mode --update-snapshots verify
```

Dieser Workflow speichert den Inhalt deines lokalen Maven-Repositorys, das sich im Verzeichnis `.m2` des Basisverzeichnisses auf dem Runner befindet. Der Cacheschlüssel ist der Hashinhalt von `pom.xml`, sodass Änderungen an `pom.xml` den Cache ungültig machen.

## Workflow-Daten als Artefakte paketieren

Nachdem ihr Build erfolgreich war und Ihre Tests bestanden wurden, sollten Sie die resultierenden Java Pakete als Buildartefakt hochladen. Dies speichert die gebauten Pakete als Teil der Workflow-Ausführung und ermöglicht Dir, sie herunterzuladen. Artefakte können Dir helfen, Pull-Requests in deiner lokalen Umgebung zu testen und zu debuggen, bevor sie zusammengeführt werden („merge“). Weitere Informationen finden Sie unter [Speichern und Freigeben von Daten mit Workflowartefakten](/de/enterprise-server@3.22/actions/tutorials/store-and-share-data).

Maven erstellt normalerweise Ausgabedateien wie JARs, EARs oder WARs im Verzeichnis `target`. Um diese als Artefakte hochzuladen, kannst du sie in ein neues Verzeichnis kopieren, welches Artefakte zum Hochladen enthält. Zum Beispiel kannst du ein Verzeichnis namens `staging` erstellen. Anschließend kannst du den Inhalt dieses Verzeichnisses mithilfe der Aktion `upload-artifact` hochladen.

```yaml copy
steps:
  - uses: actions/checkout@v6
  - uses: actions/setup-java@v4
    with:
      java-version: '17'
      distribution: 'temurin'
  - run: mvn --batch-mode --update-snapshots verify
  - run: mkdir staging && cp target/*.jar staging
  - uses: actions/upload-artifact@v3
    with:
      name: Package
      path: staging
```