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à.

# Esempi di Java
<a name="ddb-java-examples"></a>


****  

|  | 
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). | 

Gli esempi seguenti mostrano come utilizzare la libreria di crittografia lato client Java per DynamoDB per proteggere gli elementi della tabella nell'applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) negli [esempi Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) nel repository -dynamodb su. aws-database-encryption-sdk GitHub

Gli esempi seguenti mostrano come configurare la libreria di crittografia lato client Java per DynamoDB in una nuova tabella Amazon DynamoDB non popolata. Se desideri configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client, consulta. [Aggiungi la versione 3.x a una tabella esistente](ddb-java-config-existing-table.md)

**Topics**
+ [Utilizzo del client avanzato DynamoDB](#ddb-java-enhanced-client-example)
+ [Utilizzo dell'API DynamoDB di basso livello](#ddb-java-lowlevel-API-example)
+ [Utilizzo del livello inferiore DynamoDbItemEncryptor](#ddb-java-itemencryptor)

## Utilizzo del client avanzato DynamoDB
<a name="ddb-java-enhanced-client-example"></a>

L'esempio seguente mostra come utilizzare il DynamoDB Enhanced Client `DynamoDbEncryptionInterceptor` e [AWS KMS un](use-kms-keyring.md) portachiavi per crittografare gli elementi della tabella DynamoDB come parte delle chiamate API DynamoDB.

Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.

**Nota**  
[Il DynamoDB Enhanced Client non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'`DynamoDbEncryptionInterceptor`API DynamoDB di basso livello per utilizzare la crittografia ricercabile.

**Guarda l'esempio di codice completo**[: .java EnhancedPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)

**Fase 1: Creare il portachiavi AWS KMS **  
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.  

```
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
        .generator(kmsKeyId)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```

**Passaggio 2: creare uno schema tabellare dalla classe di dati annotata**  
L'esempio seguente utilizza la classe di dati annotati per creare il. `TableSchema`  
[Questo esempio presuppone che la classe di dati annotata e le azioni degli attributi siano state definite utilizzando .java. SimpleClass](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) Per ulteriori informazioni sull'annotazione delle azioni relative agli attributi, consulta. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)  
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)

```
final TableSchema<SimpleClass> schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```

**Fase 3: Definire quali attributi sono esclusi dalle firme**  
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).  

```
final String unsignedAttrPrefix = ":";
```

**Fase 4: Creare la configurazione di crittografia**  
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per la tabella DynamoDB.   
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).  
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)

```
final Map<String, DynamoDbEnhancedTableEncryptionConfig> tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
    DynamoDbEnhancedTableEncryptionConfig.builder()
        .logicalTableName(ddbTableName)
        .keyring(kmsKeyring)
        .allowedUnsignedAttributePrefix(unsignedAttrPrefix)
        .schemaOnEncrypt(tableSchema)
        .build());
```

**Fase 5: Crea il `DynamoDbEncryptionInterceptor`**  
L'esempio seguente ne crea uno nuovo `DynamoDbEncryptionInterceptor` con il `tableConfigs` **passo 4**.  

```
final DynamoDbEncryptionInterceptor interceptor =
    DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
        CreateDynamoDbEncryptionInterceptorInput.builder()
            .tableEncryptionConfigs(tableConfigs)
            .build()
    );
```

**Fase 6: Creare un nuovo client AWS SDK DynamoDB**  
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `interceptor` lo Step 5.**  

```
final DynamoDbClient ddb = DynamoDbClient.builder()
        .overrideConfiguration(
                ClientOverrideConfiguration.builder()
                       .addExecutionInterceptor(interceptor)
                       .build())
        .build();
```

**Fase 7: Creare il DynamoDB Enhanced Client e creare una tabella**  
L'esempio seguente crea il DynamoDB Enhanced Client utilizzando il client DynamoDB AWS SDK creato **nel passaggio** 6 e crea una tabella utilizzando la classe di dati annotati.  

```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
        .dynamoDbClient(ddb)
        .build();
final DynamoDbTable<SimpleClass> table = enhancedClient.table(ddbTableName, tableSchema);
```

**Fase 8: Crittografare e firmare un elemento della tabella**  
L'esempio seguente inserisce un elemento nella tabella DynamoDB utilizzando il DynamoDB Enhanced Client. L'elemento viene crittografato e firmato lato client prima di essere inviato a DynamoDB.  

```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");

table.putItem(item);
```

## Utilizzo dell'API DynamoDB di basso livello
<a name="ddb-java-lowlevel-API-example"></a>

L'esempio seguente mostra come utilizzare l'API DynamoDB di basso livello con [AWS KMS un](use-kms-keyring.md) portachiavi per crittografare e firmare automaticamente gli elementi lato client con le richieste DynamoDB. `PutItem`

Puoi utilizzare qualsiasi [portachiavi supportato, ma ti consigliamo di utilizzare uno dei portachiavi](keyrings.md) quando possibile. AWS KMS 

**[Guarda l'esempio di codice completo: .java BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)**

**Fase 1: Creare il portachiavi AWS KMS **  
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.  

```
final MaterialProviders matProv = MaterialProviders.builder()
         .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
         .build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
        .generator(kmsKeyId)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```

**Passaggio 2: configura le azioni relative agli attributi**  
L'esempio seguente definisce una `attributeActionsOnEncrypt` mappa che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.  
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.

```
final Map<String, CryptoAction> attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY); 
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY); 
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```

**Fase 3: Definire quali attributi sono esclusi dalle firme**  
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).  

```
final String unsignedAttrPrefix = ":";
```

**Fase 4: Definire la configurazione di crittografia delle tabelle DynamoDB**  
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.  
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).  
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)

```
final Map<String, DynamoDbTableEncryptionConfig> tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
        .logicalTableName(ddbTableName)
        .partitionKeyName("partition_key")
        .sortKeyName("sort_key")
        .attributeActionsOnEncrypt(attributeActionsOnEncrypt)
        .keyring(kmsKeyring)
        .allowedUnsignedAttributePrefix(unsignedAttrPrefix)
        .build();
tableConfigs.put(ddbTableName, config);
```

**Fase 5: Creare il `DynamoDbEncryptionInterceptor`**  
L'esempio seguente crea l'`DynamoDbEncryptionInterceptor`utilizzo del `tableConfigs` dal **passaggio 4**.  

```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
        .config(DynamoDbTablesEncryptionConfig.builder()
                .tableEncryptionConfigs(tableConfigs)
                .build())
        .build();
```

**Fase 6: Creare un nuovo client AWS SDK DynamoDB**  
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `interceptor` lo Step 5.**  

```
final DynamoDbClient ddb = DynamoDbClient.builder()
        .overrideConfiguration(
                ClientOverrideConfiguration.builder()
                       .addExecutionInterceptor(interceptor)
                       .build())
        .build();
```

**Fase 7: Crittografare e firmare un elemento della tabella DynamoDB**  
L'esempio seguente definisce una `item` mappa che rappresenta un elemento della tabella di esempio e inserisce l'elemento nella tabella DynamoDB. L'elemento viene crittografato e firmato lato client prima di essere inviato a DynamoDB.  

```
final HashMap<String, AttributeValue> item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());

final PutItemRequest putRequest = PutItemRequest.builder()
        .tableName(ddbTableName)
        .item(item)
        .build();

final PutItemResponse putResponse = ddb.putItem(putRequest);
```

## Utilizzo del livello inferiore DynamoDbItemEncryptor
<a name="ddb-java-itemencryptor"></a>

L'esempio seguente mostra come utilizzare il livello inferiore `DynamoDbItemEncryptor` con un [AWS KMS portachiavi](use-kms-keyring.md) per crittografare e firmare direttamente gli elementi della tabella. Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella DynamoDB.

Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.

**Nota**  
[Il livello inferiore `DynamoDbItemEncryptor` non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'`DynamoDbEncryptionInterceptor`API DynamoDB di basso livello per utilizzare la crittografia ricercabile.

**Guarda l'esempio di codice completo**[: .java ItemEncryptDecryptExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)

**Fase 1: Creare il portachiavi AWS KMS **  
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.  

```
final MaterialProviders matProv = MaterialProviders.builder()
         .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
         .build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
        .generator(kmsKeyId)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```

**Passaggio 2: configura le azioni relative agli attributi**  
L'esempio seguente definisce una `attributeActionsOnEncrypt` mappa che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.  
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.

```
final Map<String, CryptoAction> attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY); 
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY); 
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```

**Fase 3: Definire quali attributi sono esclusi dalle firme**  
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).  

```
final String unsignedAttrPrefix = ":";
```

**Fase 4: Definire la configurazione `DynamoDbItemEncryptor`**  
L'esempio seguente definisce la configurazione per`DynamoDbItemEncryptor`.  
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).  

```
final DynamoDbItemEncryptorConfig config = DynamoDbItemEncryptorConfig.builder()
        .logicalTableName(ddbTableName)
        .partitionKeyName("partition_key")
        .sortKeyName("sort_key")
        .attributeActionsOnEncrypt(attributeActionsOnEncrypt)
        .keyring(kmsKeyring)
        .allowedUnsignedAttributePrefix(unsignedAttrPrefix)
        .build();
```

**Fase 5: Creare il `DynamoDbItemEncryptor`**  
L'esempio seguente ne crea uno nuovo `DynamoDbItemEncryptor` utilizzando il `config` tratto dal **passaggio 4**.  

```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
        .DynamoDbItemEncryptorConfig(config)
        .build();
```

**Fase 6: Crittografare e firmare direttamente un elemento della tabella**  
L'esempio seguente crittografa e firma direttamente un elemento utilizzando il. `DynamoDbItemEncryptor` Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella DynamoDB.  

```
final Map<String, AttributeValue> originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());

final Map<String, AttributeValue> encryptedItem = itemEncryptor.EncryptItem(
        EncryptItemInput.builder()
                .plaintextItem(originalItem)
                .build()
).encryptedItem();
```