Building Serverless Java Applications with the Serverless Framework

Article

The Serverless Framework is a powerful, open-source tool that simplifies deploying and managing serverless applications across multiple cloud providers. While often associated with Node.js and Python, it provides excellent support for Java through plugins and custom configurations, enabling Java teams to build and deploy serverless applications efficiently.

What is the Serverless Framework?

The Serverless Framework is a CLI tool that automates the deployment of serverless applications to various cloud platforms (AWS Lambda, Azure Functions, Google Cloud Functions). It provides structure, best practices, and deployment automation for serverless architectures.

Key Benefits for Java Teams:

Multi-Cloud Support: Deploy to AWS, Azure, Google Cloud, and more
Infrastructure as Code: Define resources in simple YAML configuration
Plugin Ecosystem: Extend functionality with Java-specific plugins
Local Development: Test functions locally before deployment
CI/CD Integration: Easy integration with existing pipelines

Installation and Setup

1. Install Serverless Framework

# Install via npm
npm install -g serverless
# Or using yarn
yarn global add serverless
# Verify installation
serverless --version

2. Install Java Development Kit

# Check if Java is installed
java -version
javac -version
# Install if missing (Ubuntu/Debian)
sudo apt update && sudo apt install openjdk-11-jdk
# Or on Mac with Homebrew
brew install openjdk@11

3. Create a New Java Service

# Create new serverless Java service
serverless create --template aws-java-maven --path my-java-service
cd my-java-service
# Alternative templates
serverless create --template aws-java-gradle --path my-java-gradle-service

Project Structure

A typical Serverless Java project structure:

my-java-service/
├── serverless.yml          # Serverless configuration
├── pom.xml                 # Maven configuration
├── build.gradle           # Gradle configuration (if using Gradle)
├── src/
│   └── main/
│       └── java/
│           └── com/
│               └── example/
│                   ├── ApiHandler.java
│                   ├── DataProcessor.java
│                   └── StreamHandler.java
├── target/                # Build output (Maven)
└── build/                # Build output (Gradle)

Core Configuration (serverless.yml)

Basic serverless.yml for Java

service: my-java-serverless-app
frameworkVersion: '3'
provider:
name: aws
runtime: java11
region: us-east-1
memorySize: 512
timeout: 30
environment:
JAVA_TOOL_OPTIONS: '-Xmx384m -XX:+UseG1GC'
DB_TABLE: ${env:DB_TABLE, 'users-table'}
# IAM role statements
iamRoleStatements:
- Effect: Allow
Action:
- dynamodb:GetItem
- dynamodb:PutItem
- dynamodb:UpdateItem
- dynamodb:DeleteItem
Resource: 
- arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:provider.environment.DB_TABLE}
plugins:
- serverless-offline
package:
individually: true
exclude:
- '**/*'
include:
- 'target/classes/**'
- 'target/dependency/**'
functions:
apiHandler:
handler: com.example.ApiHandler
description: 'HTTP API handler'
events:
- http:
path: /api/{proxy+}
method: ANY
cors: true
dataProcessor:
handler: com.example.DataProcessor
description: 'Process data from S3'
events:
- s3:
bucket: my-data-bucket
event: s3:ObjectCreated:*
rules:
- prefix: uploads/
- suffix: .json
scheduledTask:
handler: com.example.ScheduledTask
description: 'Run every 5 minutes'
events:
- schedule: rate(5 minutes)

Advanced Multi-Stage Configuration

service: my-java-app
custom:
stages:
- dev
- staging
- prod
database:
dev: dev-users-table
staging: staging-users-table
prod: prod-users-table
memorySize:
dev: 512
staging: 1024
prod: 2048
provider:
name: aws
runtime: java11
region: us-east-1
stage: ${opt:stage, 'dev'}
memorySize: ${self:custom.memorySize.${self:provider.stage}}
environment:
STAGE: ${self:provider.stage}
DB_TABLE: ${self:custom.database.${self:provider.stage}}
LOG_LEVEL: ${self:custom.logLevel.${self:provider.stage}}
functions:
userApi:
handler: com.example.UserApiHandler
events:
- http:
path: /users
method: POST
- http:
path: /users/{id}
method: GET

Java Handler Implementations

1. Basic HTTP API Handler

package com.example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;
public class ApiHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
private final ObjectMapper objectMapper = new ObjectMapper();
@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
try {
String httpMethod = input.getHttpMethod();
String path = input.getPath();
Map<String, String> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("X-Custom-Header", "Java Serverless");
switch (httpMethod) {
case "GET":
return handleGetRequest(input, response, headers);
case "POST":
return handlePostRequest(input, response, headers);
case "PUT":
return handlePutRequest(input, response, headers);
case "DELETE":
return handleDeleteRequest(input, response, headers);
default:
return createErrorResponse(response, "Method not allowed", 405);
}
} catch (Exception e) {
return createErrorResponse(response, "Internal server error: " + e.getMessage(), 500);
}
}
private APIGatewayProxyResponseEvent handleGetRequest(APIGatewayProxyRequestEvent input, 
APIGatewayProxyResponseEvent response,
Map<String, String> headers) {
Map<String, Object> result = new HashMap<>();
result.put("message", "GET request processed");
result.put("path", input.getPath());
result.put("queryParameters", input.getQueryStringParameters());
result.put("timestamp", System.currentTimeMillis());
try {
String body = objectMapper.writeValueAsString(result);
return response
.withStatusCode(200)
.withHeaders(headers)
.withBody(body);
} catch (Exception e) {
return createErrorResponse(response, "Error serializing response", 500);
}
}
private APIGatewayProxyResponseEvent handlePostRequest(APIGatewayProxyRequestEvent input,
APIGatewayProxyResponseEvent response,
Map<String, String> headers) {
try {
String requestBody = input.getBody();
Map<String, Object> requestData = objectMapper.readValue(requestBody, Map.class);
// Process the data
requestData.put("processed", true);
requestData.put("processedAt", System.currentTimeMillis());
String responseBody = objectMapper.writeValueAsString(requestData);
return response
.withStatusCode(200)
.withHeaders(headers)
.withBody(responseBody);
} catch (Exception e) {
return createErrorResponse(response, "Error processing request: " + e.getMessage(), 400);
}
}
private APIGatewayProxyResponseEvent handlePutRequest(APIGatewayProxyRequestEvent input,
APIGatewayProxyResponseEvent response,
Map<String, String> headers) {
// Implement PUT logic
return createSuccessResponse(response, headers, "PUT operation completed");
}
private APIGatewayProxyResponseEvent handleDeleteRequest(APIGatewayProxyRequestEvent input,
APIGatewayProxyResponseEvent response,
Map<String, String> headers) {
// Implement DELETE logic
return createSuccessResponse(response, headers, "DELETE operation completed");
}
private APIGatewayProxyResponseEvent createSuccessResponse(APIGatewayProxyResponseEvent response,
Map<String, String> headers,
String message) {
try {
Map<String, Object> result = new HashMap<>();
result.put("status", "success");
result.put("message", message);
result.put("timestamp", System.currentTimeMillis());
String body = objectMapper.writeValueAsString(result);
return response
.withStatusCode(200)
.withHeaders(headers)
.withBody(body);
} catch (Exception e) {
return createErrorResponse(response, "Error creating response", 500);
}
}
private APIGatewayProxyResponseEvent createErrorResponse(APIGatewayProxyResponseEvent response,
String errorMessage,
int statusCode) {
try {
Map<String, Object> error = new HashMap<>();
error.put("error", errorMessage);
error.put("statusCode", statusCode);
String body = objectMapper.writeValueAsString(error);
return response
.withStatusCode(statusCode)
.withHeaders(Map.of("Content-Type", "application/json"))
.withBody(body);
} catch (Exception e) {
// Fallback error response
return response
.withStatusCode(500)
.withBody("{\"error\": \"Failed to create error response\"}");
}
}
}

2. S3 Event Processor

package com.example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.S3Object;
import java.io.InputStream;
public class DataProcessor implements RequestHandler<S3Event, String> {
private final AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
@Override
public String handleRequest(S3Event s3Event, Context context) {
try {
for (S3EventNotification.S3EventNotificationRecord record : s3Event.getRecords()) {
String bucketName = record.getS3().getBucket().getName();
String key = record.getS3().getObject().getKey();
context.getLogger().log("Processing file: s3://" + bucketName + "/" + key);
// Get the S3 object
S3Object s3Object = s3Client.getObject(bucketName, key);
// Process the file
try (InputStream inputStream = s3Object.getObjectContent()) {
processFile(inputStream, key, context);
}
context.getLogger().log("Successfully processed: " + key);
}
return "Processed " + s3Event.getRecords().size() + " files";
} catch (Exception e) {
context.getLogger().log("Error processing S3 event: " + e.getMessage());
throw new RuntimeException("Processing failed", e);
}
}
private void processFile(InputStream inputStream, String key, Context context) {
// Implement your file processing logic here
// This could be parsing CSV, JSON, images, etc.
context.getLogger().log("Processing content from: " + key);
// Example: Read and process file content
try {
// Add your business logic here
Thread.sleep(100); // Simulate processing
context.getLogger().log("Completed processing: " + key);
} catch (Exception e) {
context.getLogger().log("Error in processFile: " + e.getMessage());
throw new RuntimeException("File processing failed", e);
}
}
}

3. DynamoDB Stream Processor

package com.example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent.DynamodbStreamRecord;
public class StreamHandler implements RequestHandler<DynamodbEvent, String> {
@Override
public String handleRequest(DynamodbEvent dynamodbEvent, Context context) {
int processedRecords = 0;
for (DynamodbStreamRecord record : dynamodbEvent.getRecords()) {
try {
processRecord(record, context);
processedRecords++;
} catch (Exception e) {
context.getLogger().log("Error processing record: " + e.getMessage());
// Continue processing other records
}
}
return "Processed " + processedRecords + " DynamoDB stream records";
}
private void processRecord(DynamodbStreamRecord record, Context context) {
String eventName = record.getEventName();
context.getLogger().log("Processing " + eventName + " event");
switch (eventName) {
case "INSERT":
handleInsert(record, context);
break;
case "MODIFY":
handleModify(record, context);
break;
case "REMOVE":
handleRemove(record, context);
break;
default:
context.getLogger().log("Unknown event type: " + eventName);
}
}
private void handleInsert(DynamodbStreamRecord record, Context context) {
// Handle new item creation
context.getLogger().log("New item created: " + record.getDynamodb().getKeys());
// Example: Send welcome email, update search index, etc.
}
private void handleModify(DynamodbStreamRecord record, Context context) {
// Handle item modification
context.getLogger().log("Item modified: " + record.getDynamodb().getKeys());
// Example: Update cache, send notifications, etc.
}
private void handleRemove(DynamodbStreamRecord record, Context context) {
// Handle item deletion
context.getLogger().log("Item deleted: " + record.getDynamodb().getKeys());
// Example: Clean up related resources, archive data, etc.
}
}

Build Configuration

Maven Configuration (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>serverless-java-app</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<aws.lambda.java.version>1.2.2</aws.lambda.java.version>
<jackson.version>2.15.2</jackson.version>
</properties>
<dependencies>
<!-- AWS Lambda Java Core -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-core</artifactId>
<version>${aws.lambda.java.version}</version>
</dependency>
<!-- AWS Lambda Java Events -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-events</artifactId>
<version>3.11.1</version>
</dependency>
<!-- Jackson for JSON processing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>2.0.7</version>
</dependency>
<!-- AWS SDK -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk-s3</artifactId>
<version>1.12.470</version>
</dependency>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk-dynamodb</artifactId>
<version>1.12.470</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>11</source>
<target>11</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.4.1</version>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Gradle Configuration (build.gradle)

plugins {
id 'java'
id 'com.github.johnrengelman.shadow' version '7.1.2'
}
group = 'com.example'
version = '1.0.0'
sourceCompatibility = '11'
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:aws-lambda-java-core:1.2.2'
implementation 'com.amazonaws:aws-lambda-java-events:3.11.1'
implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'
implementation 'com.amazonaws:aws-java-sdk-s3:1.12.470'
implementation 'com.amazonaws:aws-java-sdk-dynamodb:1.12.470'
implementation 'org.slf4j:slf4j-simple:2.0.7'
}
shadowJar {
archiveClassifier.set('')
}
assemble.dependsOn shadowJar

Java-Specific Serverless Plugins

1. serverless-java-plugin

# serverless.yml
plugins:
- serverless-java-plugin
custom:
java:
maven:
goals:
- clean
- package
gradle:
tasks:
- shadowJar

2. serverless-aws-java

plugins:
- serverless-aws-java
custom:
awsJava:
memorySize: 512
timeout: 30
# Java-specific configurations

Deployment and Development Workflow

1. Local Development

# Install serverless-offline for local testing
npm install --save-dev serverless-offline
# Add to serverless.yml
plugins:
- serverless-offline
# Start local development server
serverless offline start
# Test locally
curl http://localhost:3000/dev/api/users

2. Deployment Commands

# Deploy to AWS
serverless deploy
# Deploy to specific stage
serverless deploy --stage production
# Deploy single function
serverless deploy function --function apiHandler
# View deployment info
serverless info
# Check logs
serverless logs --function apiHandler --tail
# Remove everything
serverless remove

3. CI/CD Pipeline Example (GitHub Actions)

name: Deploy Serverless Java App
on:
push:
branches: [ main ]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Java
uses: actions/setup-java@v3
with:
java-version: '11'
distribution: 'temurin'
- name: Set up Node.js
uses: actions/setup-node@v3
with:
node-version: '18'
- name: Install Serverless Framework
run: npm install -g serverless
- name: Build with Maven
run: mvn clean package
- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v1
with:
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
aws-region: us-east-1
- name: Deploy to AWS
run: serverless deploy --stage production

Best Practices for Java Serverless

1. Optimize Cold Starts

// Use static initializers for expensive operations
public class OptimizedHandler implements RequestHandler<Map<String, String>, String> {
private static final ObjectMapper mapper;
private static final AmazonDynamoDB dynamoDB;
static {
// Initialize expensive resources once
mapper = new ObjectMapper();
dynamoDB = AmazonDynamoDBClientBuilder.defaultClient();
// Pre-warm connections
mapper.readValue("{}", Map.class);
}
@Override
public String handleRequest(Map<String, String> input, Context context) {
// Fast execution path
return "Processed in " + System.currentTimeMillis();
}
}

2. Environment-Specific Configuration

provider:
environment:
JAVA_OPTS: '-Xmx${self:custom.memory.${self:provider.stage}}'
custom:
memory:
dev: '384m'
staging: '512m'
prod: '1024m'

3. Proper Error Handling

public class RobustHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
try {
return processRequest(input, context);
} catch (ValidationException e) {
return createErrorResponse(400, "Validation error: " + e.getMessage());
} catch (ResourceNotFoundException e) {
return createErrorResponse(404, "Resource not found");
} catch (Exception e) {
context.getLogger().log("Unhandled error: " + e.getMessage());
return createErrorResponse(500, "Internal server error");
}
}
private APIGatewayProxyResponseEvent createErrorResponse(int statusCode, String message) {
// Implementation
}
}

Conclusion

The Serverless Framework provides Java developers with a robust platform for building and deploying serverless applications. Key advantages include:

Standardized Workflow: Consistent deployment process across projects
Java Ecosystem: Full access to Java libraries and tooling
Multi-Cloud Support: Deploy to AWS, Azure, Google Cloud with minimal changes
Infrastructure as Code: Reproducible deployments with version control
Local Development: Test functions locally before deployment

For Java teams adopting serverless architectures, the Serverless Framework offers the perfect balance of developer productivity, operational efficiency, and cloud provider flexibility, enabling rapid development of scalable, cost-effective applications.