Exemple de gestionnaire : exécutions Java 17 Exemple de gestionnaire : exécutions Java 11 et antérieures Code d’initialisation Choix des types d’entrée et de sortie Interfaces du gestionnaire Exemple de code de gestionnaire

Gestionnaire de fonctions AWS Lambda dans Java

Le gestionnaire de fonction Lambda est la méthode dans votre code de fonction qui traite les événements. Lorsque votre fonction est invoquée, Lambda exécute la méthode du gestionnaire. Votre fonction s’exécute jusqu’à ce que le gestionnaire renvoie une réponse, se ferme ou expire.

Le GitHub référentiel de ce guide fournit des easy-to-deploy exemples d'applications illustrant différents types de gestionnaires. Pour de plus amples informations, veuillez consulter la fin de cette rubrique.

Sections

Exemple de gestionnaire : exécutions Java 17
Exemple de gestionnaire : exécutions Java 11 et antérieures
Code d’initialisation
Choix des types d’entrée et de sortie
Interfaces du gestionnaire
Exemple de code de gestionnaire

Exemple de gestionnaire : exécutions Java 17

Dans l’exemple Java 17 suivant, une classe nommée HandlerIntegerJava17 définit une méthode de gestionnaire nommée handleRequest. La méthode du gestionnaire prend en compte les entrées suivantes :

Un IntegerRecord, qui est un enregistrement Java personnalisé qui représente les données d’un événement. Dans cet exemple, nous définissons IntegerRecord comme suit :
```
record IntegerRecord(int x, int y, String message) {
}
```
Un objet de contexte, qui fournit des méthodes et des propriétés fournissant des informations sur l’invocation, la fonction et l’environnement d’exécution.

Supposons que nous voulions écrire une fonction qui enregistre le message de l’entrée IntegerRecord et renvoie la somme de x et y. Le code de la fonction est le suivant :

Exemple HandlerIntegerJava17.java


package example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;

// Handler value: example.HandlerInteger
public class HandlerIntegerJava17 implements RequestHandler<IntegerRecord, Integer>{

  @Override
  /*
   * Takes in an InputRecord, which contains two integers and a String.
   * Logs the String, then returns the sum of the two Integers.
   */
  public Integer handleRequest(IntegerRecord event, Context context)
  {
    LambdaLogger logger = context.getLogger();
    logger.log("String found: " + event.message());
    return event.x() + event.y();
  }
}

record IntegerRecord(int x, int y, String message) {
}

Vous spécifiez quelle méthode vous voulez que Lambda invoque en définissant le paramètre de gestionnaire sur la configuration de votre fonction. Vous pouvez exprimer le gestionnaire dans les formats suivants :

package.Class::method – Format complet. Par exemple: example.Handler::handleRequest.
package.Class – Format abrégé pour les catégories qui implémentent une interface de gestionnaire. Par exemple : example.Handler.

Lorsque Lambda invoque votre gestionnaire, l’exécution Lambda reçoit un événement sous la forme d’une chaîne au format JSON qu’il convertit en objet. Dans l’exemple précédent, un exemple d’événement peut s’apparenter à ce qui suit :

Exemple event.json


{
  "x": 1,
  "y": 20,
  "message": "Hello World!"
}

Vous pouvez enregistrer ce fichier et tester votre fonction localement à l’aide de la commande AWS Command Line Interface (CLI) suivante :


aws lambda invoke --function-name function_name --payload file://event.json out.json

Exemple de gestionnaire : exécutions Java 11 et antérieures

Lambda prend en charge les enregistrements dans les exécutions Java 17 et ultérieures. Dans toutes les exécutions Java, vous pouvez utiliser une classe pour représenter les données des événements. L’exemple suivant prend une liste d’entiers et un objet contextuel en entrée, et renvoie la somme de tous les entiers de la liste.

Exemple handler.java

Dans l’exemple suivant, une classe nommée Handler définit une méthode de gestionnaire nommée handleRequest. La méthode de gestionnaire prend un événement et un objet de contexte en entrée et renvoie une chaîne.

Exemple HandlerList.java


package example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;

import java.util.List;

// Handler value: example.HandlerList
public class HandlerList implements RequestHandler<List<Integer>, Integer>{

  @Override
  /*
   * Takes a list of Integers and returns its sum.
   */
  public Integer handleRequest(List<Integer> event, Context context)
  {
    LambdaLogger logger = context.getLogger();
    logger.log("EVENT TYPE: " + event.getClass().toString());
    return event.stream().mapToInt(Integer::intValue).sum();
  }
}

Pour plus d’exemples, voir Exemple de code de gestionnaire.

Code d’initialisation

Lambda exécute votre code statique et le constructeur de classe pendant la phase d’initialisation avant d’invoquer votre fonction pour la première fois. Les ressources créées pendant l’initialisation restent en mémoire entre les invocations et peuvent être réutilisées par le gestionnaire des milliers de fois. Vous pouvez ajouter du code d’initialisation en dehors de votre méthode de gestionnaire principale pour économiser du temps de calcul et réutiliser les ressources sur plusieurs invocations.

Dans l’exemple suivant, le code d’initialisation du client se trouve en dehors de la méthode du gestionnaire principal. L’exécution initialise le client avant que la fonction n’exécute son premier événement. Les événements suivants sont beaucoup plus rapides, car Lambda n’a pas besoin d’initialiser à nouveau le client.

Exemple handler.java


package example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;

import java.util.Map;

import software.amazon.awssdk.services.lambda.LambdaClient;
import software.amazon.awssdk.services.lambda.model.GetAccountSettingsResponse;
import software.amazon.awssdk.services.lambda.model.LambdaException;

// Handler value: example.Handler
public class Handler implements RequestHandler<Map<String,String>, String> {

    private static final LambdaClient lambdaClient = LambdaClient.builder().build();

    @Override
    public String handleRequest(Map<String,String> event, Context context) {

        LambdaLogger logger = context.getLogger();
        logger.log("Handler invoked");

        GetAccountSettingsResponse response = null;
        try {
            response = lambdaClient.getAccountSettings();
        } catch(LambdaException e) {
            logger.log(e.getMessage());
        }
        return response != null ? "Total code size for your account is " + response.accountLimit().totalCodeSize() + " bytes" : "Error";
    }
}

Choix des types d’entrée et de sortie

Vous spécifiez le type d’objet auquel l’événement est mappé dans la signature de la méthode de gestion. Dans l’exemple précédent, le moteur d’exécution Java désérialise l’événement en un type qui implémente l’interface Map<String,String>. tring-to-string Les cartes S fonctionnent pour les événements plats tels que les suivants :

Exemple Event.json – Données météorologiques.


{
  "temperatureK": 281,
  "windKmh": -3,
  "humidityPct": 0.55,
  "pressureHPa": 1020
}

Cependant, la valeur de chaque champ doit être une chaîne ou un nombre. Si l’événement inclut un champ qui a un objet comme valeur, le moteur d’exécution ne peut pas le désérialiser et renvoie une erreur.

Choisissez un type d’entrée qui fonctionne avec les données d’événement traitées par votre fonction. Vous pouvez utiliser un type de base, un type générique ou un type bien défini.

Types d’entrée

Integer, Long, Double, etc. – L’événement est un nombre sans mise en forme supplémentaire, par exemple, 3.5. Le moteur d’exécution convertit la valeur en un objet du type spécifié.
String – L’événement est une chaîne JSON incluant des guillemets, par exemple, "My string.". Le moteur d’exécution convertit la valeur (sans guillemets) en objet String.
Type, Map<String,Type> etc. – L’événement est un objet JSON. Le moteur d’exécution le désérialise en un objet du type ou de l’interface spécifié.
List<Integer>, List<String>, List<Object>, etc. – L’événement est un tableau JSON. Le moteur d’exécution le désérialise en un objet du type ou de l’interface spécifié.
InputStream – L’événement a un type JSON quelconque. Le moteur d’exécution transmet un flux d’octets du document au gestionnaire sans modification. Vous désérialisez l’entrée et écrivez la sortie dans un flux de sortie.
Type de bibliothèque : pour les événements envoyés par AWS les services, utilisez les types de la aws-lambda-java-eventsbibliothèque.

Si vous définissez votre propre type d’entrée, il doit s’agir d’un ancien objet Java (POJO) désérialisable, mutable, avec un constructeur par défaut et des propriétés pour chaque champ de l’événement. Les clés de l’événement qui ne correspondent pas à une propriété, ainsi que les propriétés qui ne sont pas incluses dans l’événement sont supprimées sans erreur.

Le type de sortie peut être un objet ou void. Le moteur d’exécution sérialise les valeurs de retour dans le texte. Si la sortie est un objet avec des champs, le mot d’exécution le sérialise dans un document JSON. S’il s’agit d’un type qui enveloppe une valeur primitive, le moteur d’exécution renvoie une représentation textuelle de cette valeur.

Interfaces du gestionnaire

La bibliothèque aws-lambda-java-core définit deux interfaces pour les méthodes de gestion. Utilisez les interfaces fournies pour simplifier la configuration du gestionnaire et valider la signature de la méthode du gestionnaire au moment de la compilation.

L’interface RequestHandler est un type générique qui prend deux paramètres : le type d’entrée et le type de sortie. Les deux types doivent être des objets. Lorsque vous utilisez cette interface, le moteur d’exécution Java désérialise l’événement dans un objet avec le type d’entrée et sérialise la sortie en texte. Utilisez cette interface lorsque la sérialisation intégrée fonctionne avec vos types d’entrée et de sortie.

Exemple Handler.java – Interface du gestionnaire.


// Handler value: example.Handler
public class Handler implements RequestHandler<Map<String,String>, String>{
  @Override
  public String handleRequest(Map<String,String> event, Context context)

Pour utiliser votre propre sérialisation, implémentez l’interface RequestStreamHandler. Avec cette interface, Lambda transmet à votre gestionnaire un flux d’entrée et un flux de sortie. Le gestionnaire lit les octets du flux d’entrée, écrit dans le flux de sortie et renvoie une valeur vide.

L’exemple suivant utilise les types de lecteur et de rédacteur en mémoire tampon pour travailler avec les flux d’entrée et de sortie.

Exemple HandlerStream.java


import com.amazonaws.services.lambda.runtime.Context
import com.amazonaws.services.lambda.runtime.LambdaLogger
import com.amazonaws.services.lambda.runtime.RequestStreamHandler
...
// Handler value: example.HandlerStream
public class HandlerStream implements RequestStreamHandler {
  @Override
  /*
   * Takes an InputStream and an OutputStream. Reads from the InputStream,
   * and copies all characters to the OutputStream.
   */
  public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException
  {
    LambdaLogger logger = context.getLogger();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("US-ASCII")));
    PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream, Charset.forName("US-ASCII"))));
    int nextChar;
    try {
      while ((nextChar = reader.read()) != -1) {
        outputStream.write(nextChar);
      }
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      reader.close();
      String finalString = writer.toString();
      logger.log("Final string result: " + finalString);
      writer.close();
    }
  }
}

Exemple de code de gestionnaire

Le GitHub référentiel de ce guide inclut des exemples d'applications illustrant l'utilisation de différents types de gestionnaires et d'interfaces. Chaque exemple d’application inclut des scripts facilitant le déploiement et le nettoyage, un modèle AWS SAM et des ressources de support.

Exemples d’applications Lambda en Java

java17-examples : fonction Java qui montre comment utiliser un enregistrement Java pour représenter un objet de données d’événement en entrée.
java-basic – Ensemble de fonctions Java minimales avec des tests unitaires et une configuration de journalisation variable.
java events – Ensemble de fonctions Java contenant du code squelette permettant de gérer les événements de divers services tels qu’Amazon API Gateway, Amazon SQS et Amazon Kinesis. Ces fonctions utilisent la dernière version de la aws-lambda-java-eventsbibliothèque (3.0.0 et versions ultérieures). Ces exemples ne nécessitent pas le kit SDK AWS comme dépendance.
s3-java – Fonction Java qui traite les événements de notification d’Amazon S3 et utilise la bibliothèque de classes Java (JCL) pour créer des miniatures à partir de fichiers d’image chargés.
Utiliser API Gateway pour invoquer une fonction Lambda : Fonction Java qui analyse une table Amazon DynamoDB contenant les informations relatives aux employés. Il utilise ensuite Amazon Simple Notification Service pour envoyer un message texte aux employés qui fêtent leur anniversaire professionnel. Cet exemple utilise API Gateway pour invoquer la fonction.

Les applications java-events et s3-java prennent un événement de service AWS comme entrée et retournent une chaîne. L’application java-basic comprend plusieurs types de gestionnaires :

Handler.java – Prend une Map<String,String> comme entrée.
HandlerInteger.java — Prend un Integer comme entrée.
HandlerList.java — Prend un List<Integer> comme entrée.
HandlerStream.java — Prend un InputStream et OutputStream comme entrée.
HandlerString.java — Prend un String comme entrée.
HandlerWeatherData.java — Prend un type personnalisé en entrée.

Pour tester différents types de gestionnaire, modifiez simplement la valeur du gestionnaire dans le modèle AWS SAM. Pour obtenir des instructions détaillées, consultez le fichier readme de l’exemple d’application.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création avec Java

Déploiement d’archives de fichiers .zip