Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Différences de sérialisation entre 1.x et 2.x du AWS SDK pour Java
<a name="migration-serialization-changes"></a>

## Lister les objets pour demander une différence de paramètres
<a name="serialization-diffs-list-obj-to-req-param"></a>

Les SDK pour Java v1.x et v2.x diffèrent dans la manière dont ils sérialisent les objets List pour demander des paramètres.

Le SDK pour Java 1.x ne sérialise pas une liste vide, alors que le SDK pour Java 2.x sérialise une liste vide en tant que paramètre vide.

Par exemple, considérez un service avec un `SampleOperation` qui prend un`SampleRequest`. `SampleRequest`Accepte deux paramètres : le type String `str1` et le type List`listParam`, comme indiqué dans les exemples suivants.

**Example ou `SampleOperation` en 1.x**  

```
SampleRequest v1Request = new SampleRequest()
    .withStr1("TestName");

sampleServiceV1Client.sampleOperation(v1Request);
```
La journalisation au niveau du fil indique que le `listParam` paramètre n'est pas sérialisé.  

```
Action=SampleOperation&Version=2011-01-01&str1=TestName
```

**Example ou `SampleOperation` en 2.x**  

```
sampleServiceV2Client.sampleOperation(b -> b
    .str1("TestName"));
```
La journalisation au niveau du fil indique que le `listParam` paramètre est sérialisé sans aucune valeur.  

```
Action=SampleOperation&Version=2011-01-01&str1=TestName&listParam=
```

## POJOs en V1 par rapport aux constructeurs en V2
<a name="serialization-json-objects"></a>

[Étant donné que le SDK V1 pour Java utilise des classes POJO mutables, les bibliothèques de sérialisation et de désérialisation, telles que Jackson, peuvent utiliser directement des objets modèles.](https://github.com/FasterXML/jackson-docs) 

Le SDK V2 pour Java, en revanche, utilise des objets modèles immuables. Vous devez utiliser un générateur intermédiaire pour effectuer la dé/sérialisation.

L'exemple suivant montre les différences entre de/serializing un appel d'`headBucket`API avec V1 et un appel V2 utilisant un Jackson`ObjectMapper`.

```
    public void sendRequest() throws IOException {
        final String bucketName = "amzn-s3-demo-bucket";
        final ObjectMapper mapper = new ObjectMapper();

        // V1 uses POJOs to serialize and deserialize.
        final AmazonS3 v1S3Client = AmazonS3ClientBuilder.defaultClient();
        HeadBucketResult resultV1 = v1S3Client.headBucket(
            new HeadBucketRequest(bucketName));

        String v1Serialized = mapper.writeValueAsString(resultV1);

        HeadBucketResult deserializedV1 = mapper.readValue(v1Serialized, HeadBucketResult.class);
        
        // V2 uses builders to serialize and deserialize.
        S3Client v2S3Client = S3Client.create();
        HeadBucketResponse v2Response = v2S3Client.headBucket(
            b -> b.bucket(bucketName));

        String v2Serialized = mapper.writeValueAsString(
            v2Response.toBuilder());

        HeadBucketResponse v2Deserialized = mapper.readValue(
            v2Serialized, HeadBucketResponse.serializableBuilderClass())
            .build();
    }
```