Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Driver Amazon QLDB per Java — Tutorial di avvio rapido
<a name="driver-quickstart-java"></a>

**Importante**  
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).

In questo tutorial, imparerai come configurare una semplice applicazione utilizzando l'ultima versione del driver Amazon QLDB per Java. Questa guida include i passaggi per l'installazione del driver e brevi esempi in codice delle operazioni di base di *creazione, lettura, aggiornamento ed eliminazione* (CRUD). Per esempi più approfonditi che illustrano queste operazioni in un'applicazione di esempio completa, consulta la. [Tutorial su Java](getting-started.java.tutorial.md)

**Topics**
+ [Prerequisiti](#driver-quickstart-java.prereqs)
+ [Fase 1: Configurazione del progetto](#driver-quickstart-java.step-1)
+ [Fase 2: Inizializzare il driver](#driver-quickstart-java.step-2)
+ [Fase 3: Creare una tabella e un indice](#driver-quickstart-java.step-3)
+ [Fase 4: Inserimento di un documento](#driver-quickstart-java.step-4)
+ [Fase 5: Interrogare il documento](#driver-quickstart-java.step-5)
+ [Fase 6: Aggiornare il documento](#driver-quickstart-java.step-6)
+ [Esecuzione dell'applicazione completa](#driver-quickstart-java.complete)

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

Prima di iniziare, assicurati di fare quanto segue:

1. Completa il driver [Prerequisiti](getting-started.java.md#getting-started.java.prereqs) per il Java, se non l'hai già fatto. Ciò include la registrazione AWS, la concessione dell'accesso programmatico per lo sviluppo e l'installazione di un ambiente di sviluppo integrato (IDE) Java.

1. Crea un libro mastro denominato. `quick-start`

   Per informazioni su come creare un libro mastro, consulta [Operazioni di base per i registri Amazon QLDB](ledger-management.basics.md) o [Fase 1: Creare un nuovo libro contabile](getting-started-step-1.md) in *Guida introduttiva alla console*.

## Fase 1: Configurazione del progetto
<a name="driver-quickstart-java.step-1"></a>

Innanzitutto, configura il tuo progetto Java. Ti consigliamo di utilizzare il sistema di gestione delle dipendenze [Maven](https://maven.apache.org/index.html) per questo tutorial.

**Nota**  
Se utilizzi un IDE con funzionalità per automatizzare questi passaggi di configurazione, puoi passare direttamente a. [Fase 2: Inizializzare il driver](#driver-quickstart-java.step-2)

1. Crea una cartella per la tua applicazione.

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

1. Inserisci il seguente comando per inizializzare il tuo progetto da un modello Maven. Sostituisci *project-package* e *maven-template* con i tuoi valori*project-name*, a seconda dei casi.

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

   Per *maven-template* esempio, puoi usare il modello Maven di base: `maven-archetype-quickstart`

1. Per aggiungere il [driver QLDB per](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/2.3.1/jar) Java come dipendenza del progetto, accedi al file appena `pom.xml` creato e aggiungi il seguente elemento.

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

   Questo elemento include automaticamente il modulo [AWS SDK for Java 2.x](https://aws.amazon.com/sdk-for-java)principale, le librerie [Amazon Ion](ion.md) e altre dipendenze richieste. Il tuo `pom.xml` file dovrebbe ora avere un aspetto simile al seguente.

   ```
   <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. Apri il file `App.java`.

   Quindi, aggiungi in modo incrementale gli esempi di codice nei passaggi seguenti per provare alcune operazioni CRUD di base. [In alternativa, puoi saltare il step-by-step tutorial ed eseguire invece l'applicazione completa.](#driver-quickstart-java.complete)

## Fase 2: Inizializzare il driver
<a name="driver-quickstart-java.step-2"></a>

Inizializza un'istanza del driver che si connette al registro denominato. `quick-start` Aggiungi il codice seguente al tuo `App.java` file.

```
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();
    }
}
```

## Fase 3: Creare una tabella e un indice
<a name="driver-quickstart-java.step-3"></a>

Il seguente esempio di codice mostra come eseguire le `CREATE INDEX` istruzioni `CREATE TABLE` e le istruzioni.

Nel `main` metodo, aggiungete il codice seguente che crea una tabella denominata `People` e un indice per il `lastName` campo di tale tabella. [Gli indici](ql-reference.create-index.md) sono necessari per ottimizzare le prestazioni delle query e aiutano a limitare le eccezioni ai conflitti [OCC (Optimistic Concurrency Control)](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)");
});
```

## Fase 4: Inserimento di un documento
<a name="driver-quickstart-java.step-4"></a>

Il seguente esempio di codice mostra come eseguire un'`INSERT`istruzione. QLDB supporta il linguaggio di interrogazione [PartiQL](ql-reference.md) (compatibile con SQL) e il formato dati [Amazon](ion.md) Ion (superset di JSON).

Aggiungi il codice seguente che inserisce un documento nella tabella. `People`

```
// 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);
});
```

Questo esempio utilizza un punto interrogativo (`?`) come segnaposto variabile per passare le informazioni del documento all'istruzione. Quando si utilizzano i segnaposto, è necessario passare un valore di tipo. `IonValue`

**Suggerimento**  
Per inserire più documenti utilizzando una sola [INSERT](ql-reference.insert.md) istruzione, potete passare un parametro di tipo [IonList](driver-working-with-ion.md#driver-ion-list)(espresso esplicitamente come un`IonValue`) all'istruzione nel modo seguente.  

```
// people is an IonList explicitly cast as an IonValue
txn.execute("INSERT INTO People ?", (IonValue) people);
```
Non racchiudete la variabile placeholder (`?`) tra parentesi angolari doppie () quando passate un. `<<...>>` `IonList` *Nelle istruzioni PartiQL manuali, le parentesi doppie angolari indicano una raccolta non ordinata nota come borsa.*

## Fase 5: Interrogare il documento
<a name="driver-quickstart-java.step-5"></a>

Il seguente esempio di codice mostra come eseguire un'`SELECT`istruzione.

Aggiungere il codice seguente per interrogare un documento dalla `People` tabella.

```
// 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
});
```

## Fase 6: Aggiornare il documento
<a name="driver-quickstart-java.step-6"></a>

Il seguente esempio di codice mostra come eseguire un'`UPDATE`istruzione.

1. Aggiungere il codice seguente che aggiorna un documento nella `People` tabella eseguendo l'aggiornamento `age` a`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. Interroga nuovamente il documento per vedere il valore aggiornato.

   ```
   // 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. Usa Maven o il tuo IDE per compilare ed eseguire il file. `App.java`

## Esecuzione dell'applicazione completa
<a name="driver-quickstart-java.complete"></a>

Il seguente esempio di codice è la versione completa dell'`App.java`applicazione. Invece di eseguire i passaggi precedenti singolarmente, potete anche copiare ed eseguire questo esempio di codice dall'inizio alla fine. Questa applicazione dimostra alcune operazioni CRUD di base sul registro denominato. `quick-start`

**Nota**  
Prima di eseguire questo codice, assicuratevi di non avere già una tabella attiva denominata `People` nel registro. `quick-start`  
Nella prima riga, sostituiscila *project-package* con il `groupId` valore che hai usato per il comando Maven in. [Fase 1: Configurazione del progetto](#driver-quickstart-java.step-1)

```
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
        });
    }
}
```

Usa Maven o il tuo IDE per compilare ed eseguire il file. `App.java`