Aws lambda 调用lambda函数处理程序

我有一个lambda函数，它有一个处理器，inturn有多个路由器。每个路由器对应一个API

---

我已经用java创建了一个lambda客户端，需要调用这些API。要调用这些API，我需要调用处理程序，并将负载连同它一起传递给客户机。你们能帮助我调用处理程序和传递有效负载的语法吗。

如果我正确理解了你们的问题，我首先创建了一个Lambda，看起来像：

public class SampleHandler implements RequestStreamHandler {
    private static final Logger logger = LogManager.getLogger(SampleHandler.class);

    public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException {
        logger.info("handlingRequest");
        LambdaLogger lambdaLogger = context.getLogger();

        ObjectMapper objectMapper = new ObjectMapper();
        String inputString = new BufferedReader(new InputStreamReader(inputStream)).lines().collect(Collectors.joining("\n"));
        JsonNode jsonNode = objectMapper.readTree(inputString);

        String route = jsonNode.get("route").asText();

        RouterResult routerResult = new RouterResult();

        switch( route ) {
            case "requestTypeA":
                RequestTypeA requestTypeA = objectMapper.readValue(inputString, RequestTypeA.class);
                routerResult.setResult(handleRequestTypeA(requestTypeA));
                break;

            case "requestTypeB":
                RequestTypeB requestTypeB = objectMapper.readValue(inputString, RequestTypeB.class);
                routerResult.setResult(handleRequestTypeB(requestTypeB));
                break;

            default:
                logger.error( "don't know how to handle route of type \"" + route + "\n" );
                routerResult.setResult("error");
        }

        outputStream.write(objectMapper.writeValueAsString(routerResult).getBytes(StandardCharsets.UTF_8));

       logger.info("done with run, remaining time in ms is " + context.getRemainingTimeInMillis() );
    }


    private String handleRequestTypeA(RequestTypeA requestTypeA) {
        logger.info("handling requestTypeA, requestTypeA.requestA is " + requestTypeA.getRequestA() );

        return "handled requestTypeA";
    }

    private String handleRequestTypeB(RequestTypeB requestTypeB) {
        logger.info("handling requestTypeB, requestTypeB.requestB is " + requestTypeB.getRequestB() );

         return "handled requestTypeB";
    }
}

使用

RouterRequest.java

：

public class RouterRequest {
    protected String route;

    public String getRoute() {
        return route;
    }
}

public class RequestTypeA extends RouterRequest {
    private String requestA;

    public RequestTypeA() {
        route = "requestTypeA";
    }

    public String getRequestA() {
        return requestA;
    }

    public void setRequestA(String requestA) {
        this.requestA = requestA;
    }
}

public class RouterResult {
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    @Override
    public String toString() {
        return "RouterResult{" +
                "result='" + result + '\'' +
                '}';
    }
}

和

RequestTypeA.java

：

public class RouterRequest {
    protected String route;

    public String getRoute() {
        return route;
    }
}

public class RequestTypeA extends RouterRequest {
    private String requestA;

    public RequestTypeA() {
        route = "requestTypeA";
    }

    public String getRequestA() {
        return requestA;
    }

    public void setRequestA(String requestA) {
        this.requestA = requestA;
    }
}

public class RouterResult {
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    @Override
    public String toString() {
        return "RouterResult{" +
                "result='" + result + '\'' +
                '}';
    }
}

和

RequestTypeB.java

public class RequestTypeB extends RouterRequest {
    private String requestB;

    public RequestTypeB() {
        route = "requestTypeB";
    }

    public String getRequestB() {
        return requestB;
    }

    public void setRequestB(String requestB) {
        this.requestB = requestB;
    }
}

还有一个结果类，

RouterResult.java

：

public class RouterRequest {
    protected String route;

    public String getRoute() {
        return route;
    }
}

public class RequestTypeA extends RouterRequest {
    private String requestA;

    public RequestTypeA() {
        route = "requestTypeA";
    }

    public String getRequestA() {
        return requestA;
    }

    public void setRequestA(String requestA) {
        this.requestA = requestA;
    }
}

public class RouterResult {
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    @Override
    public String toString() {
        return "RouterResult{" +
                "result='" + result + '\'' +
                '}';
    }
}

然后，要调用这个Lambda，您需要一个具有

Lambda:InvokeFunction

权限的角色。要调用的代码如下所示：

public class RouterRunner {
    private static final String AWS_ACCESS_KEY_ID = "<access key>";
    private static final String AWS_SECRET_ACCESS_KEY = "<access secret>";

    public static void main( String[] argv ) throws IOException {
        AWSCredentials credentials = new BasicAWSCredentials( AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY );
        AWSLambda lambda = AWSLambdaClientBuilder.standard()
                .withRegion(Regions.US_WEST_2)
                .withCredentials(new AWSStaticCredentialsProvider(credentials)).build();

        RequestTypeA requestTypeA = new RequestTypeA();
        requestTypeA.setRequestA("set from the runner, request type A");

        ObjectMapper objectMapper = new ObjectMapper();

        InvokeRequest invokeRequest = new InvokeRequest()
                .withFunctionName("lambda-router")
                .withPayload(objectMapper.writeValueAsString(requestTypeA));

        invokeRequest.setInvocationType(InvocationType.RequestResponse);

        InvokeResult invokeResult = lambda.invoke(invokeRequest);

        String resultJSON = new String(invokeResult.getPayload().array(), StandardCharsets.UTF_8);

        System.out.println( "result from lambda is " + resultJSON );

        RouterResult routerResult = objectMapper.readValue(resultJSON, RouterResult.class);

        System.out.println( "result.toString is " + routerResult.toString() );


        RequestTypeB requestTypeB = new RequestTypeB();
        requestTypeB.setRequestB("set from the runner, request type B");

        invokeRequest = new InvokeRequest()
                .withFunctionName("lambda-router")
                .withPayload(objectMapper.writeValueAsString(requestTypeB));

        invokeRequest.setInvocationType(InvocationType.RequestResponse);

        invokeResult = lambda.invoke(invokeRequest);

        resultJSON = new String(invokeResult.getPayload().array(), StandardCharsets.UTF_8);

        System.out.println( "result from lambda is " + resultJSON );

        routerResult = objectMapper.readValue(resultJSON, RouterResult.class);

        System.out.println( "result.toString is " + routerResult.toString() );
    }
}

公共类路由运行程序{
私有静态最终字符串AWS_ACCESS_KEY_ID=“”；
私有静态最终字符串AWS_SECRET_ACCESS_KEY=“”；
公共静态void main（字符串[]argv）引发IOException{
AWSCredentials credentials=新的基本凭证（AWS_ACCESS_KEY_ID、AWS_SECRET_ACCESS_KEY）；
AWSLambda lambda=awslambdadaclientbuilder.standard（）
.withRegion（Regions.US_WEST_2）
.withCredentials（新AWSStaticCredentialsProvider（credentials））.build（）；
RequestTypeA RequestTypeA=新的RequestTypeA（）；
setRequestA（“从运行程序设置，请求类型A”）；
ObjectMapper ObjectMapper=新的ObjectMapper（）；
InvokeRequest InvokeRequest=新建InvokeRequest（）
.withFunctionName（“lambda路由器”）
.withPayload（objectMapper.writeValueAsString（requestTypeA））；
setInvocationType（InvocationType.RequestResponse）；
InvokeResult InvokeResult=lambda.invoke（invokeRequest）；
String resultJSON=新字符串（invokeResult.getPayload（）.array（），StandardCharsets.UTF_8）；
System.out.println（“来自lambda的结果是”+resultJSON）；
RouterResult RouterResult=objectMapper.readValue（resultJSON，RouterResult.class）；
System.out.println（“result.toString为”+routerResult.toString（））；
RequestTypeB RequestTypeB=新的RequestTypeB（）；
setRequestB（“从运行程序设置，请求类型B”）；
invokeRequest=newinvokeRequest（）
.withFunctionName（“lambda路由器”）
.withPayload（objectMapper.writeValueAsString（requestTypeB））；
setInvocationType（InvocationType.RequestResponse）；
invokeResult=lambda.invoke（invokeRequest）；
resultJSON=新字符串（invokeResult.getPayload（）.array（），StandardCharsets.UTF_8）；
System.out.println（“来自lambda的结果是”+resultJSON）；
routerResult=objectMapper.readValue（resultJSON，routerResult.class）；
System.out.println（“result.toString为”+routerResult.toString（））；
}
}

---

可能需要对错误处理进行一些改进，我相信您可以使其更有效。但这是总体思路。最后，在Lambda端，我将

InputStream

转换为字符串，并根据请求类型中的公共字段将该字符串转换为某种类型的对象。在客户端，我将对象转换为JSON，发送它们，然后将结果从JSON字符串转换回结果对象。

搜索有什么问题？我发现它在S/O中使用了一个简单的注释来提供帮助。在发布问题之前，我已经跟踪了您共享的S/O链接。我需要帮助的是如何传递有效载荷。如果我想调用一个以字符串作为输入的get API，我如何将其构造为有效负载并将其传递给处理程序。该链接指示您只需将JSON转换为字符串并发送它。