Ich habe den Eingabe- / Ausgabetyp von Java Lambda ~ POJO 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).

In Map habe ich den Umgang mit JSON mithilfe des Map-Typs vorgestellt.

Wenn Sie sich den Code der Map-Methode ansehen, werden Sie viele Umwandlungen vom Objekttyp in den Typ String / Integer / Long usw. sehen.

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
...

Der Code ist nicht nur verschmutzt, sondern wenn sich der Typ ändert, wird er zur Kompilierungszeit nicht abgefangen und Sie erhalten möglicherweise zur Laufzeit eine ClassCastException.

Daher ist es die POJO-Methode.

Erstellen Sie zunächst eine POJO-Klasse, die Map ersetzt. Die Größenklasse ist eine innere Klasse, kann aber eine normale Klasse sein.

import java.util.List;

public class Product {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private Integer price;

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    private Long releaseDate;

    public Long getReleaseDate() {
        return releaseDate;
    }

    public void setReleaseDate(Long releaseDate) {
        this.releaseDate = releaseDate;
    }

    private Double rate;

    public Double getRate() {
        return rate;
    }

    public void setRate(Double rate) {
        this.rate = rate;
    }

    private List<String> rawMaterial;

    public List<String> getRawMaterial() {
        return rawMaterial;
    }

    public void setRawMaterial(List<String> rawMaterial) {
        this.rawMaterial = rawMaterial;
    }

    private Size size;

    public Size getSize() {
        return size;
    }

    public void setSize(Size size) {
        this.size = size;
    }

    public static class Size {
        private Integer height;

        public Integer getHeight() {
            return height;
        }

        public void setHeight(Integer height) {
            this.height = height;
        }

        private Integer width;

        public Integer getWidth() {
            return width;
        }

        public void setWidth(Integer width) {
            this.width = width;
        }

        private Integer depth;

        public Integer getDepth() {
            return depth;
        }

        public void setDepth(Integer depth) {
            this.depth = depth;
        }
    }
}

Der Handler für die Lambda-Funktion verwendet diese Klasse als Eingabe- / Ausgabetyp.

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

import java.util.Arrays;
import java.util.List;

public class PojoFunction implements RequestHandler<Product, Product> {
    @Override
    public Product handleRequest(Product product, Context context) {
        String name = product.getName();
        System.out.println(name); // orange juice

        Integer price = product.getPrice();
        System.out.println(price); // 1000

        Long releaseDate = product.getReleaseDate();
        System.out.println(releaseDate); // 1601606387939

        Double rate = product.getRate();
        System.out.println(rate); // 4.5

        List<String> rawMaterial = product.getRawMaterial();
        System.out.println(rawMaterial); // [orange, fragrance]

        Product.Size size = product.getSize();
        Integer height = size.getHeight();
        System.out.println(height); // 10

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

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

        Product response = new Product();
        response.setName("coffee");
        response.setPrice(Integer.valueOf(500));
        response.setReleaseDate(System.currentTimeMillis());
        response.setRate(Double.valueOf(4.2));
        response.setRawMaterial(Arrays.asList("coffee", "sugar"));

        Product.Size responseSize = new Product.Size();
        responseSize.setHeight(Integer.valueOf(100));
        responseSize.setWidth(Integer.valueOf(200));
        responseSize.setDepth(Integer.valueOf(300));
        response.setSize(responseSize);

        return response;
    }
}

Die Besetzung ist sauber verschwunden. Jetzt können Sie einen Kompilierungsfehler erhalten, auch wenn Sie den Typ ändern.

Wenn Sie dies mit dem folgenden JSON tun,

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

Die Ausgabe wird so sein.

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

Die POJO-Methode scheint die Reihenfolge beizubehalten, im Gegensatz zur Map-Methode HashMap.

Bequeme Bibliothek

Der AWS-Mitarbeiter bietet eine praktische Bibliothek, aws-lambda-java-libs, die die Möglichkeit nutzt, JSON POJO-Klassen zuzuordnen. https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events

Bei der Lambda-Proxy-Integration von API Gateway können Sie beispielsweise die so bereitgestellte POJO-Klasse für die Eingabe und Ausgabe verwenden.

public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
    APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
    response.setStatusCode(Integer.valueOf(200));
    response.setBody("ok");
    return response;
}

schließlich

Als nächstes möchte ich die InputStream / OutputStream-Methode vorstellen.

Ich habe den Eingabe- / Ausgabetyp von Java Lambda ~ Stream Version ~ ausprobiert https://qiita.com/kazfuku/items/6f0f55ffa3a88d76cfaa