Skip to content
Go to file

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time


JRestless allows you to create serverless applications using JAX-RS.

Build Status codecov GitHub issues GitHub closed issues License

SonarQube: SonarQube - Quality Gate SonarQube - Coverage SonarQube - Bugs SonarQube - Vulnerabilities SonarQube - Tests SonarQube - Duplicated Blocks SonarQube - Technical Debt SonarQube - Code Smells

Table of Contents


JRestless is a framework allowing you to build serverless JAX-RS applications or rather to run JAX-RS applications in FasS (Function as a Service) environments like AWS Lambda. This is achieved by providing a generic Jersey container that handles requests in the form of POJOs. For each FaaS environment there is a separate module acting as an integration layer between the actual environment and the generic Jersey container.

Since this framework is just a wrapper around or rather a container for Jersey, you can use almost all JAX-RS features plus Jersey's custom extensions like Spring integration - not Spring MVC, though since this functionality is provided by JAX-RS itself.

Supported Environments:


The motivation for this project is to avoid a cloud vendor lock-in and to allow developers to run and test their code locally.


  • Almost all JAX-RS features can be used (JSON/XML/text/... requests/responses, container request/response filters, etc.). Example: aws-gateway-showcase
  • Jersey extensions can be used. For example:
  • AWS Gateway Functions can also consume and produce binary data. Example: aws-gateway-binary
  • AWS Gateway Functions use the data added to the request by authorizers (Custom Authorizers or Cognito User Pool Authorizers) to create a Principal (CustomAuthorizerPrincipal or CognitoUserPoolAuthorizerPrincipal) within the SecurityContext containing all claims. Examples: aws-gateway-security-cognito-authorizer and aws-gateway-security-custom-authorizer
  • AWS Gateway Functions can use a CORS filter. Example: aws-gateway-cors
  • Injection of provider and/or function type specific values via into resources and endpoints:
    • All AWS functions can inject
    • AWS Gateway Functions can also inject the raw request GatewayRequest
    • AWS Service Functions can also inject the raw request ServiceRequest
    • AWS SNS Functions can also inject the raw request SNSRecord
  • It's worth mentioning that AWS Gateway Functions is designed to be used with API Gateway's proxy integration type for Lambda Functions. So there are no limitations on the status code, the headers and the body you return.

Function Types


  • Gateway Functions are AWS Lambda functions that get invoked by AWS API Gateway. Usage example: aws-gateway-usage-example. Read More....
  • Service Functions are AWS Lambda functions that can either be invoked by other AWS Lambda functions or can be invoked directly through the AWS SDK. The point is that you don't use AWS API Gateway. You can abstract the fact that you invoke an AWS Lambda function away by using a special feign client (jrestless-aws-service-feign-client). Usage example: aws-service-usage-example. Read More....
  • SNS functions are AWS Lambda function that get invoked by SNS. This allow asynchronous calls to other Lambda functions. So when one Lambda function publishes a message to one SNS topic, SNS can then invoke all (1-N) subscribed Lambda functions. Usage example: aws-sns-usage-example. Read More....

Fn Project

Note: the framework is split up into multiple modules, so you choose which functionality you actually want to use. See Modules

Usage Example

AWS Usage Example

All examples, including the following one, can be found in a separate repository:

JRestless does not depend on the serverless framework but it simplifies the necessary AWS configuration tremendously and will be used for this example.

Install serverless (>= 1.0.2) as described in the docs

Setup your AWS account as described in the docs

Create a new function using serverless

mkdir aws-gateway-usage-example
cd aws-gateway-usage-example
serverless create --template aws-java-gradle --name aws-gateway-usage-example
rm -rf src/main/java # remove the classes created by the template
mkdir -p src/main/java/com/jrestless/aws/examples # create the package structure

Replace serverless.yml with the following contents:

service: aws-gateway-usage-example-service

  name: aws
  runtime: java8
  stage: dev
  region: eu-central-1

  artifact: build/distributions/

      - http:
          path: sample/{proxy+}
          method: any

Replace build.gradle with the following contents:

apply plugin: 'java'

repositories {
dependencies {
task buildZip(type: Zip) {
  archiveName = "${}.zip"
  from compileJava
  from processResources
  into('lib') {
    from configurations.runtime
build.dependsOn buildZip

Create a new JAX-RS resource and a response object (src/main/java/com/jrestless/aws/examples/



public class SampleResource {
  @Produces({ MediaType.APPLICATION_JSON })
  public Response getHealthStatus() {
    return Response.ok(new HealthStatusResponse("up and running")).build();
  static class HealthStatusResponse {
    private final String statusMessage;
    HealthStatusResponse(String statusMessage) {
      this.statusMessage = statusMessage;
    public String getStatusMessage() {
      return statusMessage;

Create the request handler (src/main/java/com/jrestless/aws/examples/


import org.glassfish.jersey.server.ResourceConfig;


public class RequestHandler extends GatewayRequestObjectHandler {
  public RequestHandler() {
    // initialize the container with your resource configuration
    ResourceConfig config = new ResourceConfig()
    // start the container

Build your function from within the directory aws-gateway-usage-example:

gradle build

This, amongst other things, creates a deployable version of your function (build/distributions/ using the dependent task buildZip.

Now you can deploy the function using serverless:

serverless deploy

If serverless is configured correctly, it should show you an endpoint in its output.

  ANY - https://<SOMEID>{proxy+}

Hit the endpoint:

curl -H 'Accept: application/json' 'https://<SOMEID>'
# {"statusMessage":"up and running"}

Fn Project Usage Example

A very good example of how to use JRestless on Fn Project can be found here:


JRestless is split up into multiple modules whereas one has to depend on the *-handler modules, only. jrestless-aws-gateway-handler is probably the most interesting one.

All modules are available in jcenter.

Alternative Projects


  • Java
    • lambadaframework provides similar functionality like JRestless. It implements some features of the JAX-RS standard and includes deployment functionality within the framework itself.
    • ingenieux/lambada Non-JAX-RS Java framework
    • aws-lambda-servlet run JAX-RS applications - uses Jersey and pretends to run in a servlet container
    • aws-serverless-java-container run JAX-RS (using Jersey), Spring (MVC) and Spark - pretends to run in a servlet container
  • JavaScript
  • Python
    • Zappa - run and deploy Python applications
    • Chalice - run and deploy Python applications



  • for all function types
    • stateless only (you could utilize some cache like Redis, though)
    • AWS Lambda functions have a maximum execution time of 5 minutes
  • Gateway functions
    • AWS API Gateway has a timeout of 30 seconds
    • Multiple headers with same name are not supported

Fn Project

Release History




Distributed under Apache 2.0 license. See License for more information.


Run JAX-RS applications on AWS Lambda using Jersey. Supports Spring 4.x. The serverless framework can be used for deployment.





No packages published


You can’t perform that action at this time.