Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Amazon QLDB-Treiber für Java — Schnellstartanleitung
<a name="driver-quickstart-java"></a>

**Wichtig**  
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.

In diesem Tutorial erfahren Sie, wie Sie eine einfache Anwendung mit der neuesten Version des Amazon QLDB-Treibers für Java einrichten. Dieses Handbuch enthält Schritte zum Installieren des Treibers und kurze Codebeispiele für grundlegende CRUD-Vorgänge (*Create, Read, Update und Delete*). Ausführlichere Beispiele, die diese Vorgänge in einer vollständigen Beispielanwendung veranschaulichen, finden Sie im [Java-Lernprogramm](getting-started.java.tutorial.md).

**Topics**
+ [Voraussetzungen](#driver-quickstart-java.prereqs)
+ [Schritt 1: Einrichten des Projekts](#driver-quickstart-java.step-1)
+ [Schritt 2: Initialisieren des Treibers](#driver-quickstart-java.step-2)
+ [Schritt 3: Erstellen einer Tabelle und eines Index](#driver-quickstart-java.step-3)
+ [Schritt 4: Einfügen eines Dokuments](#driver-quickstart-java.step-4)
+ [Schritt 5: Abfragen des Dokuments](#driver-quickstart-java.step-5)
+ [Schritt 6: Aktualisieren des Dokuments](#driver-quickstart-java.step-6)
+ [Ausführen der vollständigen Anwendung](#driver-quickstart-java.complete)

## Voraussetzungen
<a name="driver-quickstart-java.prereqs"></a>

Bevor Sie beginnen, stellen Sie sicher, dass die folgende Voraussetzung erfüllt ist:

1. Füllen Sie den [Voraussetzungen](getting-started.java.md#getting-started.java.prereqs) für den Java-Treiber aus, falls Sie dies noch nicht getan haben. Dazu gehören die Registrierung für AWS, die Gewährung des programmatischen Zugriffs für die Entwicklung und die Installation einer integrierten Java-Entwicklungsumgebung (IDE).

1. Ledger mit dem Namen `quick-start` erstellen.

   Informationen zum Erstellen eines Ledgers finden Sie unter [Grundlegende Operationen für Amazon QLDB-Ledger](ledger-management.basics.md) oder [Schritt 1: Erstellen Sie ein neues Hauptbuch](getting-started-step-1.md) in *Erste Schritte mit der Konsole*.

## Schritt 1: Einrichten des Projekts
<a name="driver-quickstart-java.step-1"></a>

Richten Sie zunächst Ihr Java-Projekt ein. Wir empfehlen, für dieses Tutorial das [Maven-Abhängigkeitsverwaltungssystem](https://maven.apache.org/index.html) zu verwenden.

**Anmerkung**  
Wenn Sie eine IDE verwenden, die über Funktionen zur Automatisierung dieser Einrichtungsschritte verfügt, können Sie mit folgenden Schritten fortfahren[Schritt 2: Initialisieren des Treibers](#driver-quickstart-java.step-2).

1. Erstellen Sie einen Ordner für Ihre Anwendung.

   ```
   $ mkdir myproject
   $ cd myproject
   ```

1. Geben Sie den folgenden Befehl ein, um Ihr Projekt anhand einer Maven-Vorlage zu initialisieren. Ersetzen Sie *project-package**project-name*, und gegebenenfalls *maven-template* durch Ihre eigenen Werte.

   ```
   $ mvn archetype:generate
     -DgroupId=project-package \
     -DartifactId=project-name \
     -DarchetypeArtifactId=maven-template \
     -DinteractiveMode=false
   ```

   Für *maven-template* können Sie die grundlegende Maven-Vorlage verwenden: `maven-archetype-quickstart`

1. Um den [QLDB-Treiber für Java](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/2.3.1/jar) als Projektabhängigkeit hinzuzufügen, navigieren Sie zu Ihrer neu erstellten `pom.xml` Datei und fügen Sie das folgende Artefakt hinzu.

   ```
   <dependency>
       <groupId>software.amazon.qldb</groupId>
       <artifactId>amazon-qldb-driver-java</artifactId>
       <version>2.3.1</version>
   </dependency>
   ```

   Dieses Artefakt enthält automatisch das [AWS SDK for Java 2.x](https://aws.amazon.com/sdk-for-java)-Core-Modul, [Amazon Ion](ion.md)-Bibliotheken und andere erforderliche Abhängigkeiten. Ihre `pom.xml` Datei sollte jetzt in etwa wie folgt aussehen.

   ```
   <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/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>software.amazon.qldb</groupId>
     <artifactId>qldb-quickstart</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>qldb-quickstart</name>
     <url>http://maven.apache.org</url>
     <dependencies>
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>software.amazon.qldb</groupId>
           <artifactId>amazon-qldb-driver-java</artifactId>
           <version>2.3.1</version>
       </dependency>
     </dependencies>
   </project>
   ```

1. Öffnen Sie die `App.java` Datei.

   Fügen Sie dann schrittweise die Codebeispiele in den folgenden Schritten hinzu, um einige grundlegende CRUD-Operationen auszuprobieren. Sie können das step-by-step Tutorial auch überspringen und stattdessen die [gesamte](#driver-quickstart-java.complete) Anwendung ausführen.

## Schritt 2: Initialisieren des Treibers
<a name="driver-quickstart-java.step-2"></a>

Initialisieren Sie eine Instance des Treibers, der eine Verbindung mit dem Ledger `quick-start` herstellt. Fügen Sie nun folgenden Code in die Datei `App.java` ein:

```
import java.util.*;
import com.amazon.ion.*;
import com.amazon.ion.system.*;
import software.amazon.awssdk.services.qldbsession.QldbSessionClient;
import software.amazon.qldb.*;

public final class App {
    public static IonSystem ionSys = IonSystemBuilder.standard().build();
    public static QldbDriver qldbDriver;

    public static void main(final String... args) {
        System.out.println("Initializing the driver");
        qldbDriver = QldbDriver.builder()
            .ledger("quick-start")
            .transactionRetryPolicy(RetryPolicy
                .builder()
                .maxRetries(3)
                .build())
            .sessionClientBuilder(QldbSessionClient.builder())
            .build();
    }
}
```

## Schritt 3: Erstellen einer Tabelle und eines Index
<a name="driver-quickstart-java.step-3"></a>

Im folgenden Codebeispiel wird veranschaulicht, wie `CREATE TABLE`- und `CREATE INDEX`-Anweisungen ausgeführt werden.

Fügen Sie der `main` Methode den folgenden Code hinzu, der eine Tabelle mit dem Namen `People` und einen Index für das `lastName` Feld in dieser Tabelle erstellt. [Indizes](ql-reference.create-index.md) sind erforderlich, um die Abfrageleistung zu optimieren und zur Begrenzung von Konfliktausnahmen bei der [optimistischen Parallelitätssteuerung (OCC) beizutragen](concurrency.md).

```
// Create a table and an index in the same transaction
qldbDriver.execute(txn -> {
    System.out.println("Creating a table and an index");
    txn.execute("CREATE TABLE People");
    txn.execute("CREATE INDEX ON People(lastName)");
});
```

## Schritt 4: Einfügen eines Dokuments
<a name="driver-quickstart-java.step-4"></a>

Im folgenden Codebeispiel wird veranschaulicht, wie eine `INSERT`-Anweisung ausgeführt wird. QLDB unterstützt die [PartiQL-Abfragesprache](ql-reference.md) (SQL-kompatibel) und das [Amazon Ion-Datenformat](ion.md) (Superset von JSON).

Fügen Sie den folgenden Code hinzu, der ein Dokument in die Tabelle `People` einfügt.

```
// Insert a document
qldbDriver.execute(txn -> {
    System.out.println("Inserting a document");
    IonStruct person = ionSys.newEmptyStruct();
    person.put("firstName").newString("John");
    person.put("lastName").newString("Doe");
    person.put("age").newInt(32);
    txn.execute("INSERT INTO People ?", person);
});
```

In diesem Beispiel wird ein Fragezeichen (`?`) als Variablenplatzhalter verwendet, um die Dokumentinformationen an die Anweisung zu übergeben. Wenn Sie Platzhalter verwenden, müssen Sie einen Wert vom Typ `IonValue` übergeben.

**Tipp**  
Um mehrere Dokumente mithilfe einer einzigen [INSERT](ql-reference.insert.md) Anweisung einzufügen, können Sie der Anweisung wie folgt einen Typparameter [IonList](driver-working-with-ion.md#driver-ion-list)(explizit als ein umgewandelt`IonValue`) übergeben.  

```
// people is an IonList explicitly cast as an IonValue
txn.execute("INSERT INTO People ?", (IonValue) people);
```
Sie schließen den variablen Platzhalter (`?`) nicht in doppelte spitze Klammern (`<<...>>`) ein, wenn Sie eine übergeben. `IonList` *In manuellen PartiQL-Anweisungen bezeichnen doppelte spitze Klammern eine ungeordnete Sammlung, die als Tasche bezeichnet wird.*

## Schritt 5: Abfragen des Dokuments
<a name="driver-quickstart-java.step-5"></a>

Im folgenden Codebeispiel wird veranschaulicht, wie eine `SELECT`-Anweisung ausgeführt wird.

Fügen Sie den folgenden Code hinzu, der ein Dokument aus der Tabelle `People` abfragt.

```
// Query the document
qldbDriver.execute(txn -> {
    System.out.println("Querying the table");
    Result result = txn.execute("SELECT * FROM People WHERE lastName = ?",
            ionSys.newString("Doe"));
    IonStruct person = (IonStruct) result.iterator().next();
    System.out.println(person.get("firstName")); // prints John
    System.out.println(person.get("lastName")); // prints Doe
    System.out.println(person.get("age")); // prints 32
});
```

## Schritt 6: Aktualisieren des Dokuments
<a name="driver-quickstart-java.step-6"></a>

Im folgenden Codebeispiel wird veranschaulicht, wie eine `UPDATE`-Anweisung ausgeführt wird.

1. Fügen Sie den folgenden Code hinzu, der ein Dokument in der `People` Tabelle aktualisiert, indem Sie auf aktualisieren. `age` `42`

   ```
   // Update the document
   qldbDriver.execute(txn -> {
       System.out.println("Updating the document");
       final List<IonValue> parameters = new ArrayList<>();
       parameters.add(ionSys.newInt(42));
       parameters.add(ionSys.newString("Doe"));
       txn.execute("UPDATE People SET age = ? WHERE lastName = ?", parameters);
   });
   ```

1. Fragen Sie das Dokument erneut ab, um den aktualisierten Wert zu sehen.

   ```
   // Query the updated document
   qldbDriver.execute(txn -> {
       System.out.println("Querying the table for the updated document");
       Result result = txn.execute("SELECT * FROM People WHERE lastName = ?",
               ionSys.newString("Doe"));
       IonStruct person = (IonStruct) result.iterator().next();
       System.out.println(person.get("firstName")); // prints John
       System.out.println(person.get("lastName")); // prints Doe
       System.out.println(person.get("age")); // prints 32
   });
   ```

1. Verwenden Sie Maven oder Ihre IDE, um die `App.java` Datei zu kompilieren und auszuführen.

## Ausführen der vollständigen Anwendung
<a name="driver-quickstart-java.complete"></a>

Das folgende Codebeispiel ist die vollständige Version der `App.java` Anwendung. Anstatt die vorherigen Schritte einzeln auszuführen, können Sie dieses Codebeispiel auch kopieren und von Anfang bis Ende ausführen. Diese Anwendung demonstriert einige grundlegende CRUD-Operationen für den Ledger namens `quick-start`.

**Anmerkung**  
Bevor Sie diesen Code ausführen, stellen Sie sicher, dass Sie noch keine aktive Tabelle mit dem Namen `People` im `quick-start`-Ledger besitzen.  
Ersetzen Sie in der ersten Zeile *project-package* durch den `groupId` Wert, den Sie für den Maven-Befehl in [Schritt 1: Einrichten des Projekts](#driver-quickstart-java.step-1) verwendet haben.

```
package project-package;

import java.util.*;
import com.amazon.ion.*;
import com.amazon.ion.system.*;
import software.amazon.awssdk.services.qldbsession.QldbSessionClient;
import software.amazon.qldb.*;

public class App {
    public static IonSystem ionSys = IonSystemBuilder.standard().build();
    public static QldbDriver qldbDriver;

    public static void main(final String... args) {
        System.out.println("Initializing the driver");
        qldbDriver = QldbDriver.builder()
            .ledger("quick-start")
            .transactionRetryPolicy(RetryPolicy
                .builder()
                .maxRetries(3)
                .build())
            .sessionClientBuilder(QldbSessionClient.builder())
            .build();

        // Create a table and an index in the same transaction
        qldbDriver.execute(txn -> {
            System.out.println("Creating a table and an index");
            txn.execute("CREATE TABLE People");
            txn.execute("CREATE INDEX ON People(lastName)");
        });
        
        // Insert a document
        qldbDriver.execute(txn -> {
            System.out.println("Inserting a document");
            IonStruct person = ionSys.newEmptyStruct();
            person.put("firstName").newString("John");
            person.put("lastName").newString("Doe");
            person.put("age").newInt(32);
            txn.execute("INSERT INTO People ?", person);
        });
        
        // Query the document
        qldbDriver.execute(txn -> {
            System.out.println("Querying the table");
            Result result = txn.execute("SELECT * FROM People WHERE lastName = ?",
                    ionSys.newString("Doe"));
            IonStruct person = (IonStruct) result.iterator().next();
            System.out.println(person.get("firstName")); // prints John
            System.out.println(person.get("lastName")); // prints Doe
            System.out.println(person.get("age")); // prints 32
        });
        
        // Update the document
        qldbDriver.execute(txn -> {
            System.out.println("Updating the document");
            final List<IonValue> parameters = new ArrayList<>();
            parameters.add(ionSys.newInt(42));
            parameters.add(ionSys.newString("Doe"));
            txn.execute("UPDATE People SET age = ? WHERE lastName = ?", parameters);
        });
        
        // Query the updated document
        qldbDriver.execute(txn -> {
            System.out.println("Querying the table for the updated document");
            Result result = txn.execute("SELECT * FROM People WHERE lastName = ?",
                    ionSys.newString("Doe"));
            IonStruct person = (IonStruct) result.iterator().next();
            System.out.println(person.get("firstName")); // prints John
            System.out.println(person.get("lastName")); // prints Doe
            System.out.println(person.get("age")); // prints 42
        });
    }
}
```

Verwenden Sie Maven oder Ihre IDE, um die Datei zu kompilieren und auszuführen. `App.java`