scottgerring
commented
6 months ago Morning @dnnrly ! Thanks heaps for this - it is clear you have spent time thinking about this. There is prior art here too - powertools for python supports something similar .
Full disclosure - we are focusing at the moment on getting V2 #1522 into a good state, targeting H1 this year. This is certainly something we'd be interested in in the future, though, and would have a natural home in V2, as we're reluctant to add net new features to V1.
dnnrly
jeromevdl
Key information
Summary
This RFC proposes a new module that will allow developers to easily implement lightweight, multi-endpoint ALB and API Gateway lambdas in Java with minimal (or no) additional dependencies outside of the Powertools and the JRE. This approach provides an alternative to using more heavy weight frameworks based around Spring or JaxRS, reducing GC and classloader burden to allow maximum cold start performance.
Motivation
Here's the value statement I think we should work towards:
We have been using a lightweight framework to achieve this goal rather successfully for the past couple of years. We have gone all-in on AWS lambda and have been able to solve many of the problems associated with implementing Java lambdas as we gained experience. We would like to contribute some of the technology that has enabled to do this so successfully.
To be more specific about what problem this solves, this RFC proposes a solution for lambdas that:
Many of the techniques and approaches used in this proposal come from this article: https://medium.com/capital-one-tech/aws-lambda-java-tutorial-best-practices-to-lower-cold-starts-capital-one-dc1d8806118
This proposal does not make Java more performant than using other runtimes for your lambda, but it does prevent the framework being a performance burden.
Proposal
The design of this proposal is significantly different from the approach taken in Spring and JaxRS. It borrows concepts and idioms from other languages, Go in particular. Despite this it is still possible to use patterns familiar to Java developers such as 3-tier or Domain Driven Design. Examples of this will be shown
API examples
Basic route binding
A simple example of how URL path and HTTP method can be used to bind to a specific handler
```java public class ExampleRestfulController { private final Router router; { /* This router demonstrates some of the features you would expect to use when creating a RESTful resource. They are all using the same root but differentiated by looking at the HTTP method and the `id` path parameter. These individual routes are also named so that you can filter log events based on that rather than having to use a regular expression on the path in combination with method. */ final Router resourcesRouter = new Router( Route.bind("/", methodOf("POST")).to(this::createResource), Route.bind("/(?Filters
In this section, we will describe how we can add filters that allow us to perform operations on the request object before it is passed to the handler. I've called them
filtershere but we can decide if there's a more appropriate name for this.A simple example of how we can add filters to a binding.
```java Filter aSingleFilter = new YourFilter(); ListHere is an example of a filter you might want perform some common logging.
```java public class RequestLogger implements Filter { private final YourStructuredLogger log; public RequestLogger(Logger log) { this.log = log; log.info("isColdStart", "true"); } @Override public AlbResponse apply(RouteHandler handler, Request request) { log.info("path", request.getPath()); String method = request.getHttpMethod(); if (!Objects.equals(method, "")) { log.info("http_method", method); } logHeaderIfPresent(request, "content-type"); logHeaderIfPresent(request, "accept"); try { AlbResponse response = handler.apply(request); log.info("status_code", String.valueOf(response.getStatusCode())); return response; } catch (Exception ex) { log.error("Unhandled exception", ex); throw ex; } } ```Here is an example of how you could do request validation inside of a filter.
```java Filter validator = (next, request) -> { if (request.getBody() != "") { return next.apply(request); } else { return AlbResponse.builder().withStatusCode(400).withBody("you must have a request body").build(); } }; ```Here is how you might implement a simple (or complex) exception mapper using filters.
```java public class ExceptionMapping { private final Router router = new Router( Route.HEALTH, Route.bind("/resources/123", methodOf("GET")) .to(this::mapException) .then(this::accessSubResource), Route.bind("/resources/(?Dependency Injection
Dependency injection is outside of the scope of this RFC - but this approach is compatible with compile-time DI solutions like Dagger2. Our experience has shown that you retain a high degree of control over what code is executed and the number classes being managed by the class loader, allowing you to manage your cold start phase very well.
Drawbacks
The style of API used here will not be familiar to a lot of Java developers. This may add some cognitive burden to those that would like to adopt this module in their solution.
Rationale and alternatives
Unresolved questions