Ich habe den Eingabe- / Ausgabetyp von Java Lambda ~ Map Edition ~ ausprobiert

Für die Eingabe- / Ausgabetypen von Java Lambda können verschiedene Muster verwendet werden.

• Kartenmethode
• POJO-Methode
• InputStream / OutputStream-Methode

Im offiziellen Dokument ist es in [hier] geschrieben (https://docs.aws.amazon.com/ja_jp/lambda/latest/dg/java-handler.html#java-handler-types).

Zunächst von der Map-Methode.

Dies ist der Eingabe-JSON, der an die Lambda-Funktion übergeben werden soll.

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

Der folgende Code behandelt diesen Eingabe-JSON als Map, schreibt ihn in die Standardausgabe und verwendet Map auch zum Ausgeben eines anderen 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;
    }
}

Jeder Wert wird entsprechend dem JSON-Typ in String, Integer, Long, Double konvertiert. Ein Array wird in eine Liste und ein assoziatives Array in eine Map konvertiert.

Wenn ich diese Lambda-Funktion ausführe, wird dieser JSON ausgegeben.

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

Da ich HashMap verwende, ist die Reihenfolge nicht in Ordnung. Wenn Sie beispielsweise TreeMap anstelle von HashMap verwenden, wird die Reihenfolge beibehalten. Es ist jedoch wünschenswert, dass der Empfänger dieses JSON es auftragsunabhängig implementiert.

Wie Sie sehen können, können Sie mit Java Lambda mithilfe des Map-Typs mit JSON arbeiten. Sie können Code schreiben, ohne weitere Klassen hinzuzufügen, aber Sie werden mit einem Cast Storm enden und es ist nicht typsicher. Im nächsten Artikel werde ich eine POJO-Methode vorstellen, die dieses Problem lösen kann.

Ich habe den Eingabe- / Ausgabetyp von Java Lambda ~ POJO Edition ~ ausprobiert https://qiita.com/kazfuku/items/095b4fb9c37638f57457