J'ai essayé le type d'entrée / sortie de Java Lambda ~ Map edition ~

Différents modèles peuvent être utilisés pour les types d'entrée / sortie de Java Lambda.

• Méthode de la carte
• Méthode POJO
• Méthode InputStream / OutputStream

Dans le document officiel, il est écrit en ici.

Tout d'abord, à partir de la méthode Map.

Il s'agit du JSON d'entrée à transmettre à la fonction Lambda.

{
    "name": "orange juice",
    "price": 1000,
    "releaseDate": 1601606387939,
    "rate": 4.5,
    "rawMaterial": ["orange", "fragrance"],
    "size": {
        "height": 10,
        "width": 20,
        "depth": 30
    }
}

Le code ci-dessous traite cette entrée JSON comme une carte, l'écrit dans la sortie standard et utilise également Map pour générer un autre JSON.

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

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MapFunction implements RequestHandler<Map<String, Object>, Map<String, Object>> {
    @Override
    public Map<String, Object> handleRequest(Map<String, Object> event, Context context) {
        String name = (String) event.get("name");
        System.out.println(name); // orange juice

        Integer price = (Integer) event.get("price");
        System.out.println(price); // 1000

        Long releaseDate = (Long) event.get("releaseDate");
        System.out.println(releaseDate); // 1601606387939

        Double rate = (Double) event.get("rate");
        System.out.println(rate); // 4.5

        List<String> rawMaterial = (List<String>) event.get("rawMaterial");
        System.out.println(rawMaterial); // [orange, fragrance]

        Map<String, Integer> size = (Map<String, Integer>) event.get("size");
        Integer height = size.get("height");
        System.out.println(height); // 10

        Integer width = size.get("width");
        System.out.println(width); // 20

        Integer depth = size.get("depth");
        System.out.println(depth); // 30

        Map<String, Object> response = new HashMap<>();
        response.put("name", "coffee");
        response.put("price", Integer.valueOf(500));
        response.put("releaseDate", System.currentTimeMillis());
        response.put("rate", Double.valueOf(4.2));
        response.put("rawMaterial", Arrays.asList("coffee", "sugar"));

        Map<String, Integer> responseSize = new HashMap<>();
        responseSize.put("height", Integer.valueOf(100));
        responseSize.put("width", Integer.valueOf(200));
        responseSize.put("depth", Integer.valueOf(300));
        response.put("size", responseSize);

        return response;
    }
}

Chaque valeur est convertie en String, Integer, Long, Double selon le type JSON. Un tableau est converti en liste et un tableau associatif est converti en carte.

Lorsque j'exécute cette fonction Lambda, ce JSON est généré.

{
  "size": {
    "depth": 300,
    "width": 200,
    "height": 100
  },
  "releaseDate": 1601615397265,
  "rate": 4.2,
  "price": 500,
  "rawMaterial": [
    "coffee",
    "sugar"
  ],
  "name": "coffee"
}

Puisque j'utilise HashMap, la commande n'est pas en ordre. Si vous utilisez TreeMap au lieu de HashMap, par exemple, l'ordre sera conservé. Cependant, il est souhaitable que le destinataire de ce JSON l'implémente d'une manière indépendante de l'ordre.

Comme vous pouvez le voir, Java Lambda vous permet de travailler avec JSON en utilisant le type Map. Vous pouvez écrire du code sans ajouter plus de classes, mais vous vous retrouverez avec une tempête de cast et ce n'est pas de type sécurisé. Dans le prochain article, je présenterai une méthode POJO capable de résoudre ce problème.

J'ai essayé le type d'entrée / sortie de Java Lambda ~ édition POJO ~ https://qiita.com/kazfuku/items/095b4fb9c37638f57457