Différents modèles peuvent être utilisés pour les types d'entrée / sortie de Java Lambda.
Dans le document officiel, il est écrit en ici.
Dans Map, j'ai présenté comment gérer JSON en utilisant le type Map.
Si vous regardez le code de la méthode Map, vous verrez de nombreux casts du type Object au type String / Integer / Long et ainsi de suite.
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
...
Non seulement le code est sale, mais si le type change, il ne sera pas intercepté au moment de la compilation et vous pouvez obtenir une exception ClassCastException au moment de l'exécution.
C'est donc la méthode POJO.
Tout d'abord, créez une classe POJO qui remplace Map. La classe Size est une classe interne, mais il peut s'agir d'une classe normale.
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;
}
}
}
Le gestionnaire de la fonction Lambda utilise cette classe comme type d'entrée / sortie.
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;
}
}
Le casting a disparu proprement. Maintenant, même si vous changez le type, vous pouvez obtenir une erreur de compilation.
Si vous faites cela avec le JSON suivant,
{
"name": "orange juice",
"price": 1000,
"releaseDate": 1601606387939,
"rate": 4.5,
"rawMaterial": ["orange", "fragrance"],
"size": {
"height": 10,
"width": 20,
"depth": 30
}
}
La sortie sera comme ça.
{
"name": "coffee",
"price": 500,
"releaseDate": 1601623033115,
"rate": 4.2,
"rawMaterial": [
"coffee",
"sugar"
],
"size": {
"height": 100,
"width": 200,
"depth": 300
}
}
La méthode POJO semble maintenir l'ordre, contrairement à la méthode Map HashMap.
Le responsable AWS fournit une bibliothèque pratique, aws-lambda-java-libs, qui tire parti de la possibilité de mapper JSON aux classes POJO. https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events
Par exemple, dans le cas de l'intégration de proxy Lambda d'API Gateway, vous pouvez utiliser la classe POJO fournie comme ceci pour l'entrée et la sortie.
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
response.setStatusCode(Integer.valueOf(200));
response.setBody("ok");
return response;
}
Ensuite, je voudrais vous présenter la méthode InputStream / OutputStream.
J'ai essayé le type d'entrée / sortie de Java Lambda ~ Stream version ~ https://qiita.com/kazfuku/items/6f0f55ffa3a88d76cfaa
Recommended Posts