As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Diferenças de serialização entre 1.x e 2.x do AWS SDK para Java
<a name="migration-serialization-changes"></a>

## Diferença entre listar objetos e os parâmetros da solicitação
<a name="serialization-diffs-list-obj-to-req-param"></a>

O SDK para Java v1.x e v2.x diferem na forma como serializam objetos List para solicitar parâmetros.

O SDK para Java 1.x não serializa uma lista vazia, enquanto o SDK para Java 2.x serializa uma lista vazia como um parâmetro vazio.

Por exemplo, pense em um serviço com uma `SampleOperation` que exija uma `SampleRequest`. A `SampleRequest` aceita dois parâmetros: um tipo de string `str1` e um tipo de lista `listParam`: conforme mostrado nos exemplos a seguir.

**Example de `SampleOperation` na 1.x**  

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

sampleServiceV1Client.sampleOperation(v1Request);
```
O registro em log em nível de transferência mostra que o parâmetro `listParam` não está serializado.  

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

**Example de `SampleOperation` na 2.x**  

```
sampleServiceV2Client.sampleOperation(b -> b
    .str1("TestName"));
```
O registro em log em nível de transferência mostra que o parâmetro `listParam` está serializado sem valor.  

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

## POJOs na V1 em comparação com os construtores na V2
<a name="serialization-json-objects"></a>

Como o SDK V1 para Java usa classes POJO mutáveis, as bibliotecas de serialização e desserialização, como [Jackson](https://github.com/FasterXML/jackson-docs), podem usar objetos de modelo diretamente. 

Por outro lado, o SDK V2 para Java usa objetos de modelo imutáveis. Você deve usar um compilador intermediário para realizar a (des)serialização.

O exemplo a seguir mostra as diferenças entre de/serializing uma chamada de `headBucket` API com V1 e V2 usando um 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();
    }
```