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
**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/).
Per utilizzare i dati nel registro, puoi connetterti ad Amazon QLDB dall'applicazione Java utilizzando un driver fornito. AWS I seguenti argomenti descrivono come iniziare a usare il driver QLDB per Java.
**Topics**
+ [Risorse per i driver](#getting-started.java.resources)
+ [Prerequisiti](#getting-started.java.prereqs)
+ [Impostazione delle AWS credenziali e della regione predefinite](#getting-started.java.credentials)
+ [Installazione](#getting-started.java.install)
+ [Tutorial di avvio rapido](driver-quickstart-java.md)
+ [Riferimento al libro di cucina](driver-cookbook-java.md)
## Risorse per i driver
Per ulteriori informazioni sulle funzionalità supportate dal driver Java, consultate le seguenti risorse:
+ [Riferimento API: [2.x, 1.x](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/)](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/1.1.0/index.html)
+ [Codice sorgente del driver () GitHub](https://github.com/awslabs/amazon-qldb-driver-java)
+ [Codice sorgente dell'applicazione di esempio (GitHub)](https://github.com/aws-samples/amazon-qldb-dmv-sample-java)
+ [Framework Ledger Loader () GitHub](https://github.com/awslabs/amazon-qldb-ledger-load-java)
+ [Esempi di codice Amazon Ion](ion.code-examples.md)
## Prerequisiti
Prima di iniziare a utilizzare il driver QLDB per Java, è necessario effettuare le seguenti operazioni:
1. Segui le istruzioni di AWS configurazione riportate in. [Accesso ad Amazon QLDB](accessing.md) Questo include gli output seguenti:
1. Iscriviti a AWS.
1. Crea un utente con le autorizzazioni QLDB appropriate.
1. Concedi l'accesso programmatico per lo sviluppo.
1. Configura un ambiente di sviluppo Java scaricando e installando quanto segue:
1. Kit di sviluppo Java SE 8, ad esempio [Amazon Corretto 8](https://docs.aws.amazon.com/corretto/latest/corretto-8-ug/downloads-list.html).
1. (Facoltativo) Ambiente di sviluppo integrato Java (IDE) a scelta, come [Eclipse](http://www.eclipse.org) o [IntelliJ](https://www.jetbrains.com/idea/).
1. Configura il tuo ambiente di sviluppo per il AWS SDK per Java momento. [Impostazione delle AWS credenziali e della regione predefinite](#getting-started.java.credentials)
Successivamente, puoi scaricare l'applicazione di esempio completa del tutorial oppure puoi installare solo il driver in un progetto Java ed eseguire brevi esempi di codice.
+ Per installare il driver QLDB e AWS SDK per Java poi in un progetto esistente, procedi con. [Installazione](#getting-started.java.install)
+ Per configurare un progetto ed eseguire brevi esempi di codice che illustrano le transazioni di dati di base su un registro, consulta il. [Tutorial di avvio rapido](driver-quickstart-java.md)
+ Per eseguire esempi più approfonditi delle operazioni delle API relative ai dati e alla gestione nell'applicazione di esempio completa del tutorial, consulta il. [Tutorial su Java](getting-started.java.tutorial.md)
## Impostazione delle AWS credenziali e della regione predefinite
Il driver QLDB e il [AWS SDK per Java](https://aws.amazon.com/sdk-for-java)sottostante richiedono l'immissione di credenziali all'applicazione AWS in fase di esecuzione. *Gli esempi di codice in questa guida presuppongono che tu stia utilizzando un file di AWS credenziali, come descritto in [Impostare credenziali e regione predefinite](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) nella Guida per gli sviluppatori.AWS SDK for Java 2.x *
Come parte di questi passaggi, è inoltre necessario impostare il valore predefinito Regione AWS per determinare l'endpoint QLDB predefinito. Gli esempi di codice si connettono a QLDB come impostazione predefinita. Regione AWS Per un elenco completo delle regioni in cui è disponibile QLDB, consulta gli endpoint e le quote di [Amazon QLDB](https://docs.aws.amazon.com/general/latest/gr/qldb.html) nel. *Riferimenti generali di AWS*
Di seguito è riportato un esempio di file di AWS credenziali denominato`~/.aws/credentials`, in cui il carattere tilde () rappresenta la tua home directory. `~`
```
[default]
aws_access_key_id = your_access_key_id
aws_secret_access_key = your_secret_access_key
```
Sostituite i valori AWS delle vostre credenziali con i valori e. *your\$1access\$1key\$1id* *your\$1secret\$1access\$1key*
## Installazione
QLDB supporta le seguenti versioni dei driver Java e AWS le relative dipendenze SDK.
****
| Versione driver | AWS SDK | Stato | Data di rilascio più recente |
| --- | --- | --- | --- |
| [1.x](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/1.1.0/jar) | AWS SDK per Java 1.x | Rilascio di produzione | 20 marzo 2020 |
| [2.x](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/2.3.1/jar) | AWS SDK for Java 2.x | Versione di produzione | 4 giugno 2021 |
Per installare il driver QLDB, consigliamo di utilizzare un sistema di gestione delle dipendenze, come Gradle o Maven. Ad esempio, aggiungi il seguente elemento come dipendenza nel tuo progetto Java.
------
#### [ 2.x ]
**Gradle**
Aggiungi questa dipendenza nel tuo `build.gradle` file di configurazione.
```
dependencies {
compile group: 'software.amazon.qldb', name: 'amazon-qldb-driver-java', version: '2.3.1'
}
```
**Maven**
Aggiungi questa dipendenza nel tuo `pom.xml` file di configurazione.
```
software.amazon.qldb
amazon-qldb-driver-java
2.3.1
```
Questo elemento include automaticamente il modulo AWS SDK for Java 2.x principale, le librerie [Amazon Ion](ion.md) e altre dipendenze richieste.
------
#### [ 1.x ]
**Gradle**
Aggiungi questa dipendenza nel tuo `build.gradle` file di configurazione.
```
dependencies {
compile group: 'software.amazon.qldb', name: 'amazon-qldb-driver-java', version: '1.1.0'
}
```
**Maven**
Aggiungi questa dipendenza nel tuo `pom.xml` file di configurazione.
```
software.amazon.qldb
amazon-qldb-driver-java
1.1.0
```
Questo elemento include automaticamente il modulo AWS SDK per Java principale, le librerie [Amazon Ion](ion.md) e altre dipendenze richieste.
**Importante**
Spazio **dei nomi Amazon Ion**: quando importi classi Amazon Ion nella tua applicazione, devi utilizzare il pacchetto che si trova nello spazio dei nomi. `com.amazon.ion` AWS SDK per Java Dipende da un altro pacchetto Ion nello spazio dei nomi`software.amazon.ion`, ma si tratta di un pacchetto legacy non compatibile con il driver QLDB.
------
Per brevi esempi di codice su come eseguire transazioni di dati di base su un registro, consulta il. [Riferimento al libro di cucina](driver-cookbook-java.md)
### Altre librerie opzionali
Facoltativamente, puoi anche aggiungere le seguenti utili librerie al tuo progetto. Questi artefatti sono dipendenze obbligatorie nell'applicazione di esempio. [Tutorial su Java](getting-started.java.tutorial.md)
1. [aws-java-sdk-qldb](https://search.maven.org/artifact/com.amazonaws/aws-java-sdk-qldb/1.11.785/jar)— Il modulo QLDB di. AWS SDK per Java La versione minima supportata da QLDB è. `1.11.785`
Utilizza questo modulo nella tua applicazione per interagire direttamente con le operazioni dell'API di gestione elencate in. [Riferimento all'API Amazon QLDB](api-reference.md)
1. [jackson-dataformat-ion](https://search.maven.org/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-ion/2.10.0/bundle)— Il modulo di formato dati Jackson di FasterXML per Ion. L'applicazione di esempio richiede una versione `2.10.0` o successiva.
------
#### [ Gradle ]
Aggiungi queste dipendenze nel tuo file `build.gradle` di configurazione.
```
dependencies {
compile group: 'com.amazonaws', name: 'aws-java-sdk-qldb', version: '1.11.785'
compile group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-ion', version: '2.10.0'
}
```
------
#### [ Maven ]
Aggiungi queste dipendenze nel tuo `pom.xml` file di configurazione.
```
com.amazonaws
aws-java-sdk-qldb
1.11.785
com.fasterxml.jackson.dataformat
jackson-dataformat-ion
2.10.0
```
------
# Driver Amazon QLDB per Java — Tutorial di avvio rapido
**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
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
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.
```
software.amazon.qldb
amazon-qldb-driver-java
2.3.1
```
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.
```
4.0.0
software.amazon.qldb
qldb-quickstart
jar
1.0-SNAPSHOT
qldb-quickstart
http://maven.apache.org
junit
junit
3.8.1
test
software.amazon.qldb
amazon-qldb-driver-java
2.3.1
```
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
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
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
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
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
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 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
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 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`
# Driver Amazon QLDB per Java: riferimento al libro di cucina
**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/).
Questa guida di riferimento mostra i casi d'uso comuni del driver Amazon QLDB per Java. Fornisce esempi di codice Java che dimostrano come utilizzare il driver per eseguire operazioni di base di *creazione, lettura, aggiornamento ed eliminazione* (CRUD). Include anche esempi di codice per l'elaborazione dei dati di Amazon Ion. Inoltre, questa guida illustra le migliori pratiche per rendere le transazioni idempotenti e implementare vincoli di unicità.
**Nota**
Ove applicabile, alcuni casi d'uso hanno esempi di codice diversi per ogni versione principale supportata del driver QLDB per Java.
**Contents**
+ [Importazione del driver](#cookbook-java.importing)
+ [Istanziazione del driver](#cookbook-java.instantiating)
+ [Operazioni CRUD](#cookbook-java.crud)
+ [Creazione di tabelle](#cookbook-java.crud.creating-tables)
+ [Creazione di indici](#cookbook-java.crud.creating-indexes)
+ [Leggere documenti](#cookbook-java.crud.reading)
+ [Inserimento di documenti](#cookbook-java.crud.inserting)
+ [Inserimento di più documenti in un'unica dichiarazione](#cookbook-java.crud.inserting.multiple)
+ [Aggiornamento dei documenti](#cookbook-java.crud.updating)
+ [Eliminazione di documenti](#cookbook-java.crud.deleting)
+ [Esecuzione di più istruzioni in una transazione](#cookbook-java.crud.multi-statement)
+ [Logica di ripetizione dei tentativi](#cookbook-java.crud.retry-logic)
+ [Implementazione di vincoli di unicità](#cookbook-java.crud.uniqueness-constraints)
+ [Lavorare con Amazon Ion](#cookbook-java.ion)
+ [Importazione dei pacchetti Ion](#cookbook-java.ion.importing)
+ [Inizializzazione di Ion](#cookbook-java.ion.initializing)
+ [Creazione di oggetti Ion](#cookbook-java.ion.creating)
+ [Leggere oggetti Ion](#cookbook-java.ion.reading)
## Importazione del driver
Il seguente esempio di codice importa il driver, il client di sessione QLDB, i pacchetti Amazon Ion e altre dipendenze correlate.
------
#### [ 2.x ]
```
import com.amazon.ion.IonStruct;
import com.amazon.ion.IonSystem;
import com.amazon.ion.IonValue;
import com.amazon.ion.system.IonSystemBuilder;
import software.amazon.awssdk.services.qldbsession.QldbSessionClient;
import software.amazon.qldb.QldbDriver;
import software.amazon.qldb.Result;
```
------
#### [ 1.x ]
```
import com.amazon.ion.IonStruct;
import com.amazon.ion.IonSystem;
import com.amazon.ion.IonValue;
import com.amazon.ion.system.IonSystemBuilder;
import com.amazonaws.services.qldbsession.AmazonQLDBSessionClientBuilder;
import software.amazon.qldb.PooledQldbDriver;
import software.amazon.qldb.Result;
```
------
## Istanziazione del driver
Il seguente esempio di codice crea un'istanza di driver che si connette a un nome di registro specificato e utilizza una [logica di ripetizione specificata con un limite](#cookbook-java.crud.retry-logic) di tentativi personalizzato.
**Nota**
Questo esempio crea anche un'istanza di un oggetto di sistema Amazon Ion ()`IonSystem`. È necessario questo oggetto per elaborare i dati Ion durante l'esecuzione di alcune operazioni sui dati in questo riferimento. Per ulteriori informazioni, consulta [Lavorare con Amazon Ion](#cookbook-java.ion).
------
#### [ 2.x ]
```
QldbDriver qldbDriver = QldbDriver.builder()
.ledger("vehicle-registration")
.transactionRetryPolicy(RetryPolicy
.builder()
.maxRetries(3)
.build())
.sessionClientBuilder(QldbSessionClient.builder())
.build();
IonSystem SYSTEM = IonSystemBuilder.standard().build();
```
------
#### [ 1.x ]
```
PooledQldbDriver qldbDriver = PooledQldbDriver.builder()
.withLedger("vehicle-registration")
.withRetryLimit(3)
.withSessionClientBuilder(AmazonQLDBSessionClientBuilder.standard())
.build();
IonSystem SYSTEM = IonSystemBuilder.standard().build();
```
------
## Operazioni CRUD
QLDB *esegue operazioni di creazione, lettura, aggiornamento ed* eliminazione (CRUD) come parte di una transazione.
**avvertimento**
Come best practice, rendi le tue transazioni di scrittura strettamente idempotenti.
**Rendere le transazioni idempotenti**
Si consiglia di rendere le transazioni di scrittura idempotenti per evitare effetti collaterali imprevisti in caso di nuovi tentativi. Una transazione è *idempotente* se può essere eseguita più volte e produrre risultati identici ogni volta.
Ad esempio, si consideri una transazione che inserisce un documento in una tabella denominata. `Person` La transazione deve innanzitutto verificare se il documento esiste già o meno nella tabella. Senza questo controllo, la tabella potrebbe finire con documenti duplicati.
Supponiamo che QLDB esegua correttamente il commit della transazione sul lato server, ma che il client scada in attesa di una risposta. Se la transazione non è idempotente, lo stesso documento potrebbe essere inserito più di una volta in caso di nuovo tentativo.
**Utilizzo degli indici per evitare scansioni complete della tabella**
Si consiglia inoltre di eseguire istruzioni con una clausola di `WHERE` predicato utilizzando un operatore di *uguaglianza* su un campo indicizzato o un ID di documento, ad esempio o. `WHERE indexedField = 123` `WHERE indexedField IN (456, 789)` *Senza questa ricerca indicizzata, QLDB deve eseguire una scansione della tabella, che può portare a timeout delle transazioni o conflitti ottimistici di controllo della concorrenza (OCC).*
[Modello di concorrenza Amazon QLDB](concurrency.md)Per ulteriori informazioni su OCC, vedere.
**Transazioni create implicitamente**
Il metodo [QldbDriver.execute](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/QldbDriver.html) accetta una funzione lambda che riceve un'istanza di [Executor](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/Executor.html), che può essere utilizzata per eseguire istruzioni. L'`Executor`istanza racchiude una transazione creata implicitamente.
È possibile eseguire istruzioni all'interno della funzione lambda utilizzando il metodo. `Executor.execute` Il driver esegue implicitamente la transazione quando ritorna la funzione lambda.
Le sezioni seguenti mostrano come eseguire operazioni CRUD di base, specificare una logica di ripetizione personalizzata e implementare vincoli di unicità.
**Nota**
Ove applicabile, queste sezioni forniscono esempi di codice per l'elaborazione dei dati di Amazon Ion utilizzando sia la libreria Ion integrata che la libreria Jackson Ion mapper. Per ulteriori informazioni, consulta [Lavorare con Amazon Ion](#cookbook-java.ion).
**Contents**
+ [Creazione di tabelle](#cookbook-java.crud.creating-tables)
+ [Creazione di indici](#cookbook-java.crud.creating-indexes)
+ [Leggere documenti](#cookbook-java.crud.reading)
+ [Inserimento di documenti](#cookbook-java.crud.inserting)
+ [Inserimento di più documenti in un'unica dichiarazione](#cookbook-java.crud.inserting.multiple)
+ [Aggiornamento dei documenti](#cookbook-java.crud.updating)
+ [Eliminazione di documenti](#cookbook-java.crud.deleting)
+ [Esecuzione di più istruzioni in una transazione](#cookbook-java.crud.multi-statement)
+ [Logica di ripetizione dei tentativi](#cookbook-java.crud.retry-logic)
+ [Implementazione di vincoli di unicità](#cookbook-java.crud.uniqueness-constraints)
### Creazione di tabelle
```
qldbDriver.execute(txn -> {
txn.execute("CREATE TABLE Person");
});
```
### Creazione di indici
```
qldbDriver.execute(txn -> {
txn.execute("CREATE INDEX ON Person(GovId)");
});
```
### Leggere documenti
```
// Assumes that Person table has documents as follows:
// { GovId: "TOYENC486FH", FirstName: "Brent" }
qldbDriver.execute(txn -> {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'");
IonStruct person = (IonStruct) result.iterator().next();
System.out.println(person.get("GovId")); // prints TOYENC486FH
System.out.println(person.get("FirstName")); // prints Brent
});
```
**Utilizzo dei parametri di interrogazione**
Il seguente esempio di codice utilizza un parametro di query di tipo Ion.
```
qldbDriver.execute(txn -> {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?",
SYSTEM.newString("TOYENC486FH"));
IonStruct person = (IonStruct) result.iterator().next();
System.out.println(person.get("GovId")); // prints TOYENC486FH
System.out.println(person.get("FirstName")); // prints Brent
});
```
Il seguente esempio di codice utilizza più parametri di query.
```
qldbDriver.execute(txn -> {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ? AND FirstName = ?",
SYSTEM.newString("TOYENC486FH"),
SYSTEM.newString("Brent"));
IonStruct person = (IonStruct) result.iterator().next();
System.out.println(person.get("GovId")); // prints TOYENC486FH
System.out.println(person.get("FirstName")); // prints Brent
});
```
Il seguente esempio di codice utilizza un elenco di parametri di query.
```
qldbDriver.execute(txn -> {
final List parameters = new ArrayList<>();
parameters.add(SYSTEM.newString("TOYENC486FH"));
parameters.add(SYSTEM.newString("ROEE1"));
parameters.add(SYSTEM.newString("YH844"));
Result result = txn.execute("SELECT * FROM Person WHERE GovId IN (?,?,?)", parameters);
IonStruct person = (IonStruct) result.iterator().next();
System.out.println(person.get("GovId")); // prints TOYENC486FH
System.out.println(person.get("FirstName")); // prints Brent
});
```
#### Utilizzo del mappatore Jackson
```
// Assumes that Person table has documents as follows:
// {GovId: "TOYENC486FH", FirstName: "Brent" }
qldbDriver.execute(txn -> {
try {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'");
Person person = MAPPER.readValue(result.iterator().next(), Person.class);
System.out.println(person.getFirstName()); // prints Brent
System.out.println(person.getGovId()); // prints TOYENC486FH
} catch (IOException e) {
e.printStackTrace();
}
});
```
**Utilizzo dei parametri di interrogazione**
Il seguente esempio di codice utilizza un parametro di query di tipo Ion.
```
qldbDriver.execute(txn -> {
try {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?",
MAPPER.writeValueAsIonValue("TOYENC486FH"));
Person person = MAPPER.readValue(result.iterator().next(), Person.class);
System.out.println(person.getFirstName()); // prints Brent
System.out.println(person.getGovId()); // prints TOYENC486FH
} catch (IOException e) {
e.printStackTrace();
}
});
```
Il seguente esempio di codice utilizza più parametri di query.
```
qldbDriver.execute(txn -> {
try {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ? AND FirstName = ?",
MAPPER.writeValueAsIonValue("TOYENC486FH"),
MAPPER.writeValueAsIonValue("Brent"));
Person person = MAPPER.readValue(result.iterator().next(), Person.class);
System.out.println(person.getFirstName()); // prints Brent
System.out.println(person.getGovId()); // prints TOYENC486FH
} catch (IOException e) {
e.printStackTrace();
}
});
```
Il seguente esempio di codice utilizza un elenco di parametri di query.
```
qldbDriver.execute(txn -> {
try {
final List parameters = new ArrayList<>();
parameters.add(MAPPER.writeValueAsIonValue("TOYENC486FH"));
parameters.add(MAPPER.writeValueAsIonValue("ROEE1"));
parameters.add(MAPPER.writeValueAsIonValue("YH844"));
Result result = txn.execute("SELECT * FROM Person WHERE GovId IN (?,?,?)", parameters);
Person person = MAPPER.readValue(result.iterator().next(), Person.class);
System.out.println(person.getFirstName()); // prints Brent
System.out.println(person.getGovId()); // prints TOYENC486FH
} catch (IOException e) {
e.printStackTrace();
}
});
```
**Nota**
Quando si esegue una query senza una ricerca indicizzata, viene richiamata una scansione completa della tabella. In questo esempio, si consiglia di disporre di un [indice](ql-reference.create-index.md) sul campo per ottimizzare le `GovId` prestazioni. Senza un indice attivo`GovId`, le query possono avere una maggiore latenza e possono anche portare a eccezioni nei conflitti OCC o a timeout delle transazioni.
### Inserimento di documenti
Il seguente esempio di codice inserisce i tipi di dati Ion.
```
qldbDriver.execute(txn -> {
// Check if a document with GovId:TOYENC486FH exists
// This is critical to make this transaction idempotent
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?",
SYSTEM.newString("TOYENC486FH"));
// Check if there is a result
if (!result.iterator().hasNext()) {
IonStruct person = SYSTEM.newEmptyStruct();
person.put("GovId").newString("TOYENC486FH");
person.put("FirstName").newString("Brent");
// Insert the document
txn.execute("INSERT INTO Person ?", person);
}
});
```
#### Utilizzo del mappatore Jackson
Il seguente esempio di codice inserisce i tipi di dati Ion.
```
qldbDriver.execute(txn -> {
try {
// Check if a document with GovId:TOYENC486FH exists
// This is critical to make this transaction idempotent
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?",
MAPPER.writeValueAsIonValue("TOYENC486FH"));
// Check if there is a result
if (!result.iterator().hasNext()) {
// Insert the document
txn.execute("INSERT INTO Person ?",
MAPPER.writeValueAsIonValue(new Person("Brent", "TOYENC486FH")));
}
} catch (IOException e) {
e.printStackTrace();
}
});
```
Questa transazione inserisce un documento nella `Person` tabella. Prima dell'inserimento, controlla innanzitutto se il documento esiste già nella tabella. **Questo controllo rende la transazione di natura idempotente.** Anche se esegui questa transazione più volte, non causerà effetti collaterali indesiderati.
**Nota**
In questo esempio, consigliamo di avere un indice sul `GovId` campo per ottimizzare le prestazioni. Senza un indice attivo`GovId`, le istruzioni possono avere una maggiore latenza e possono anche portare a eccezioni nei conflitti OCC o a timeout delle transazioni.
#### Inserimento di più documenti in un'unica dichiarazione
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 come segue.
```
// 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.*
##### Perché è richiesto il cast esplicito?
Il metodo [TransactionExecutor.execute](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/TransactionExecutor.html) è sovraccarico. Accetta un numero variabile di `IonValue` argomenti (*varargs*) o un singolo argomento. `List` In [ion-java](https://www.javadoc.io/doc/com.amazon.ion/ion-java/latest/index.html), `IonList` è implementato come. `List`
Java utilizza per impostazione predefinita l'implementazione del metodo più specifica quando si chiama un metodo sovraccaricato. In questo caso, quando si passa un `IonList` parametro, per impostazione predefinita viene utilizzato il metodo che richiede un. `List` Quando viene richiamata, questa implementazione del metodo passa `IonValue` gli elementi dell'elenco come valori distinti. Quindi, per richiamare invece il metodo varargs, è necessario eseguire il cast esplicito di un parametro come. `IonList` `IonValue`
### Aggiornamento dei documenti
```
qldbDriver.execute(txn -> {
final List parameters = new ArrayList<>();
parameters.add(SYSTEM.newString("John"));
parameters.add(SYSTEM.newString("TOYENC486FH"));
txn.execute("UPDATE Person SET FirstName = ? WHERE GovId = ?", parameters);
});
```
#### Usando il mappatore Jackson
```
qldbDriver.execute(txn -> {
try {
final List parameters = new ArrayList<>();
parameters.add(MAPPER.writeValueAsIonValue("John"));
parameters.add(MAPPER.writeValueAsIonValue("TOYENC486FH"));
txn.execute("UPDATE Person SET FirstName = ? WHERE GovId = ?", parameters);
} catch (IOException e) {
e.printStackTrace();
}
});
```
**Nota**
In questo esempio, consigliamo di avere un indice sul `GovId` campo per ottimizzare le prestazioni. Senza un indice attivo`GovId`, le istruzioni possono avere una maggiore latenza e possono anche portare a eccezioni nei conflitti OCC o a timeout delle transazioni.
### Eliminazione di documenti
```
qldbDriver.execute(txn -> {
txn.execute("DELETE FROM Person WHERE GovId = ?",
SYSTEM.newString("TOYENC486FH"));
});
```
#### Usando il mappatore Jackson
```
qldbDriver.execute(txn -> {
try {
txn.execute("DELETE FROM Person WHERE GovId = ?",
MAPPER.writeValueAsIonValue("TOYENC486FH"));
} catch (IOException e) {
e.printStackTrace();
}
});
```
**Nota**
In questo esempio, consigliamo di avere un indice sul `GovId` campo per ottimizzare le prestazioni. Senza un indice attivo`GovId`, le istruzioni possono avere una maggiore latenza e possono anche portare a eccezioni nei conflitti OCC o a timeout delle transazioni.
### Esecuzione di più istruzioni in una transazione
```
// This code snippet is intentionally trivial. In reality you wouldn't do this because you'd
// set your UPDATE to filter on vin and insured, and check if you updated something or not.
public static boolean InsureCar(QldbDriver qldbDriver, final String vin) {
final IonSystem ionSystem = IonSystemBuilder.standard().build();
final IonString ionVin = ionSystem.newString(vin);
return qldbDriver.execute(txn -> {
Result result = txn.execute(
"SELECT insured FROM Vehicles WHERE vin = ? AND insured = FALSE",
ionVin);
if (!result.isEmpty()) {
txn.execute("UPDATE Vehicles SET insured = TRUE WHERE vin = ?", ionVin);
return true;
}
return false;
});
}
```
### Logica di ripetizione dei tentativi
Il `execute` metodo del driver dispone di un meccanismo di riprova integrato che riprova la transazione se si verifica un'eccezione riprovabile (ad esempio in caso di timeout o conflitti OCC).
------
#### [ 2.x ]
Il numero massimo di tentativi di nuovo tentativo e la strategia di backoff sono configurabili.
Il limite di tentativi predefinito è`4`, e la strategia di backoff predefinita è. [DefaultQldbTransactionBackoffStrategy](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/DefaultQldbTransactionBackoffStrategy.html) È possibile impostare la configurazione dei nuovi tentativi per istanza del driver e anche per transazione utilizzando un'istanza di. [RetryPolicy](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/RetryPolicy.html)
Il seguente esempio di codice specifica la logica di ripetizione con un limite di tentativi personalizzato e una strategia di backoff personalizzata per un'istanza del driver.
```
public void retry() {
QldbDriver qldbDriver = QldbDriver.builder()
.ledger("vehicle-registration")
.transactionRetryPolicy(RetryPolicy.builder()
.maxRetries(2)
.backoffStrategy(new CustomBackOffStrategy()).build())
.sessionClientBuilder(QldbSessionClient.builder())
.build();
}
private class CustomBackOffStrategy implements BackoffStrategy {
@Override
public Duration calculateDelay(RetryPolicyContext retryPolicyContext) {
return Duration.ofMillis(1000 * retryPolicyContext.retriesAttempted());
}
}
```
Il seguente esempio di codice specifica la logica dei tentativi con un limite di tentativi personalizzato e una strategia di backoff personalizzata per una particolare transazione. Questa configurazione `execute` sostituisce la logica di riprova impostata per l'istanza del driver.
```
public void retry() {
Result result = qldbDriver.execute(txn -> { txn.execute("SELECT * FROM Person WHERE GovId = ?",
SYSTEM.newString("TOYENC486FH")); },
RetryPolicy.builder()
.maxRetries(2)
.backoffStrategy(new CustomBackOffStrategy())
.build());
}
private class CustomBackOffStrategy implements BackoffStrategy {
// Configuring a custom backoff which increases delay by 1s for each attempt.
@Override
public Duration calculateDelay(RetryPolicyContext retryPolicyContext) {
return Duration.ofMillis(1000 * retryPolicyContext.retriesAttempted());
}
}
```
------
#### [ 1.x ]
Il numero massimo di tentativi di nuovo tentativo è configurabile. È possibile configurare il limite di tentativi impostando la `retryLimit` proprietà al momento dell'inizializzazione. `PooledQldbDriver`
Il limite di tentativi predefinito è. `4`
------
### Implementazione di vincoli di unicità
QLDB non supporta indici univoci, ma puoi implementare questo comportamento nella tua applicazione.
Supponiamo di voler implementare un vincolo di unicità sul campo della tabella. `GovId` `Person` A tale scopo, è possibile scrivere una transazione che esegua le seguenti operazioni:
1. Asserisce che la tabella non ha documenti esistenti con un valore specificato`GovId`.
1. Inserisci il documento se l'asserzione ha esito positivo.
Se una transazione concorrente supera contemporaneamente l'asserzione, solo una delle transazioni verrà salvata correttamente. L'altra transazione avrà esito negativo con un'eccezione relativa al conflitto OCC.
Il seguente esempio di codice mostra come implementare questa logica di vincolo di unicità.
```
qldbDriver.execute(txn -> {
Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?",
SYSTEM.newString("TOYENC486FH"));
// Check if there is a result
if (!result.iterator().hasNext()) {
IonStruct person = SYSTEM.newEmptyStruct();
person.put("GovId").newString("TOYENC486FH");
person.put("FirstName").newString("Brent");
// Insert the document
txn.execute("INSERT INTO Person ?", person);
}
});
```
**Nota**
In questo esempio, si consiglia di disporre di un indice sul `GovId` campo per ottimizzare le prestazioni. Senza un indice attivo`GovId`, le istruzioni possono avere una maggiore latenza e possono anche portare a eccezioni nei conflitti OCC o a timeout delle transazioni.
## Lavorare con Amazon Ion
Esistono diversi modi per elaborare i dati di Amazon Ion in QLDB. Puoi utilizzare i metodi integrati della [libreria Ion](https://github.com/amzn/ion-java) per creare e modificare i documenti in modo flessibile secondo necessità. In alternativa, puoi utilizzare il [modulo di formato dati Jackson di FasterXML per Ion per mappare i documenti Ion](https://github.com/FasterXML/jackson-dataformats-binary/tree/master/ion) su *semplici vecchi modelli di oggetti Java* (POJO).
Le sezioni seguenti forniscono esempi di codice di elaborazione dei dati Ion utilizzando entrambe le tecniche.
**Contents**
+ [Importazione dei pacchetti Ion](#cookbook-java.ion.importing)
+ [Inizializzazione di Ion](#cookbook-java.ion.initializing)
+ [Creazione di oggetti Ion](#cookbook-java.ion.creating)
+ [Leggere oggetti Ion](#cookbook-java.ion.reading)
### Importazione dei pacchetti Ion
Aggiungi l'artefatto [ion-java](https://search.maven.org/artifact/com.amazon.ion/ion-java/1.6.1/bundle) come dipendenza nel tuo progetto Java.
------
#### [ Gradle ]
```
dependencies {
compile group: 'com.amazon.ion', name: 'ion-java', version: '1.6.1'
}
```
------
#### [ Maven ]
```
com.amazon.ion
ion-java
1.6.1
```
------
Importa i seguenti pacchetti Ion.
```
import com.amazon.ion.IonStruct;
import com.amazon.ion.IonSystem;
import com.amazon.ion.system.IonSystemBuilder;
```
#### Usando il mappatore Jackson
Aggiungi l'artefatto [jackson-dataformat-ion](https://search.maven.org/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-ion/2.10.0/bundle)come dipendenza nel tuo progetto Java. QLDB richiede `2.10.0` una versione o successiva.
------
#### [ Gradle ]
```
dependencies {
compile group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-ion', version: '2.10.0'
}
```
------
#### [ Maven ]
```
com.fasterxml.jackson.dataformat
jackson-dataformat-ion
2.10.0
```
------
Importa i seguenti pacchetti Ion.
```
import com.amazon.ion.IonReader;
import com.amazon.ion.IonStruct;
import com.amazon.ion.system.IonReaderBuilder;
import com.amazon.ion.system.IonSystemBuilder;
import com.fasterxml.jackson.dataformat.ion.IonObjectMapper;
import com.fasterxml.jackson.dataformat.ion.ionvalue.IonValueMapper;
```
### Inizializzazione di Ion
```
IonSystem SYSTEM = IonSystemBuilder.standard().build();
```
#### Usando il mappatore Jackson
```
IonObjectMapper MAPPER = new IonValueMapper(IonSystemBuilder.standard().build());
```
### Creazione di oggetti Ion
Il seguente esempio di codice crea un oggetto Ion utilizzando l'`IonStruct`interfaccia e i relativi metodi incorporati.
```
IonStruct ionStruct = SYSTEM.newEmptyStruct();
ionStruct.put("GovId").newString("TOYENC486FH");
ionStruct.put("FirstName").newString("Brent");
System.out.println(ionStruct.toPrettyString()); // prints a nicely formatted copy of ionStruct
```
#### Utilizzo del mappatore Jackson
Supponiamo di avere una classe modello mappata in JSON denominata come segue. `Person`
```
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
public static class Person {
private final String firstName;
private final String govId;
@JsonCreator
public Person(@JsonProperty("FirstName") final String firstName,
@JsonProperty("GovId") final String govId) {
this.firstName = firstName;
this.govId = govId;
}
@JsonProperty("FirstName")
public String getFirstName() {
return firstName;
}
@JsonProperty("GovId")
public String getGovId() {
return govId;
}
}
```
Il seguente esempio di codice crea un `IonStruct` oggetto da un'istanza di. `Person`
```
IonStruct ionStruct = (IonStruct) MAPPER.writeValueAsIonValue(new Person("Brent", "TOYENC486FH"));
```
### Leggere oggetti Ion
Il seguente esempio di codice stampa ogni campo dell'`ionStruct`istanza.
```
// ionStruct is an instance of IonStruct
System.out.println(ionStruct.get("GovId")); // prints TOYENC486FH
System.out.println(ionStruct.get("FirstName")); // prints Brent
```
#### Utilizzo del mappatore Jackson
Il seguente esempio di codice legge un `IonStruct` oggetto e lo mappa su un'istanza di. `Person`
```
// ionStruct is an instance of IonStruct
IonReader reader = IonReaderBuilder.standard().build(ionStruct);
Person person = MAPPER.readValue(reader, Person.class);
System.out.println(person.getFirstName()); // prints Brent
System.out.println(person.getGovId()); // prints TOYENC486FH
```
Per ulteriori informazioni sull'utilizzo di Ion, consulta la [documentazione di Amazon Ion](http://amzn.github.io/ion-docs/) su GitHub. Per altri esempi di codice sull'utilizzo di Ion in QLDB, vedere. [Utilizzo dei tipi di dati Amazon Ion in Amazon QLDB](driver-working-with-ion.md)