# Personalização da serialização para funções do Lambda em Java
<a name="java-custom-serialization"></a>

Os [runtimes gerenciados para Java](lambda-java.md#java-runtimes) do Lambda oferecem suporte para a serialização personalizada para eventos JSON. A serialização personalizada pode simplificar o código e, potencialmente, aumentar a performance.

**Topics**
+ [Quando usar serialização personalizada](#custom-serialization-use-cases)
+ [Implementação de serialização personalizada](#implement-custom-serialization)
+ [Teste da serialização personalizada](#test-custom-serialization)

## Quando usar serialização personalizada
<a name="custom-serialization-use-cases"></a>

Quando a função do Lambda é invocada, os dados do evento de entrada precisam passar pela desserialização em um objeto em Java, e a saída da função precisa ser serializada novamente em um formato que possa ser retornado como resposta da função. Os runtimes gerenciados do Lambda para Java fornecem funcionalidades de serialização e desserialização padrão que funcionam bem para lidar com cargas úteis de eventos de vários serviços da AWS, como o Amazon API Gateway e o Amazon Simple Queue Service (Amazon SQS). Para trabalhar com esses eventos de integração de serviços em sua função, adicione a dependência [aws-java-lambda-events](https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-events) ao seu projeto. Esta biblioteca da AWS contém objetos em Java que representam esses eventos de integração de serviços.

Você também pode usar seus próprios objetos para representar o JSON do evento que você fornece para a função do Lambda. O runtime gerenciado tenta serializar o JSON para uma nova instância do objeto com o comportamento padrão. Se o serializador padrão não apresentar o comportamento desejado para o seu caso de uso, utilize a serialização personalizada.

Por exemplo, suponha que o manipulador da sua função espera uma classe `Vehicle` como entrada, com a seguinte estrutura:

```
public class Vehicle {
    private String vehicleType;
    private long vehicleId;
}
```

No entanto, a carga útil do evento JSON é semelhante a:

```
{
    "vehicle-type": "car",
    "vehicleID": 123
}
```

Neste caso, a serialização padrão no runtime gerenciado requer que os nomes das propriedades em JSON coincidam com os nomes das propriedades da classe Java em camel case (`vehicleType` e `vehicleId`). Como os nomes das propriedades no evento JSON não estão em camel case (`vehicle-type` e `vehicleID`), é necessário usar a serialização personalizada.

## Implementação de serialização personalizada
<a name="implement-custom-serialization"></a>

Faça uso de uma [interface de provedor de serviços](https://docs.oracle.com/javase/tutorial/sound/SPI-intro.html) para carregar um serializador de sua preferência, em vez de usar a lógica de serialização padrão do runtime gerenciado. É possível serializar as cargas úteis dos eventos JSON diretamente em objetos em Java ao usar a interface `RequestHandler` padrão.

**Para usar a serialização personalizada em sua função do Lambda em Java**

1. Adicione a biblioteca [aws-lambda-java-core](https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-core) como uma dependência. Esta biblioteca inclui a interface [CustomPojoSerializer](https://github.com/aws/aws-lambda-java-libs/blob/main/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/CustomPojoSerializer.java), juntamente com outras definições de interface para o uso com o Java no Lambda.

1. Crie um arquivo chamado `com.amazonaws.services.lambda.runtime.CustomPojoSerializer` no diretório `src/main/resources/META-INF/services/` do seu projeto.

1. Neste arquivo, especifique o nome totalmente qualificado da implementação de serializador personalizada, que deve implementar a interface `CustomPojoSerializer`. Exemplo:

   ```
   com.mycompany.vehicles.CustomLambdaSerialzer
   ```

1. Implemente a interface `CustomPojoSerializer` para fornecer sua lógica de serialização personalizada.

1. Use a interface `RequestHandler` padrão em sua função do Lambda. O runtime gerenciado usará o serializador personalizado.

Para obter mais exemplos de como implementar a serialização personalizada usando bibliotecas populares como fastJson, Gson, Moshi e jackson-jr, consulte o exemplo [custom-serialization](https://github.com/aws/aws-lambda-java-libs/tree/main/samples/custom-serialization) no repositório GitHub da AWS.

## Teste da serialização personalizada
<a name="test-custom-serialization"></a>

Teste sua função para garantir que sua lógica de serialização e desserialização esteja funcionando conforme o esperado. É possível usar a AWS Serverless Application Model Command Line Interface (AWS SAM CLI) para emular a invocação da carga útil da função do Lambda. Isso ajuda a testar e iterar rapidamente em sua função à medida que você implementa um serializador personalizado.

1. Crie um arquivo com a carga útil do evento JSON que você deseja usar para invocar a função e, em seguida, chame a AWS SAM CLI.

1. Execute o comando [sam local invoke](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-invoke.html ) para invocar sua função localmente. Exemplo:

   ```
   sam local invoke -e src/test/resources/event.json
   ```

Para obter mais informações, consulte [Locally invoke Lambda functions with AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-invoke.html).