Serverless Functions with AWS Lambda in Java

AWS Lambda is a serverless compute service that runs your code in response to events and automatically manages the underlying compute resources. Java is a fully supported runtime for Lambda functions, offering strong typing, rich ecosystem, and excellent performance.

Lambda Handler Types

Basic Handler Implementations

// Simple request/response handler public class SimpleHandler implements RequestHandler<Map<String, String>, String> { private static final Logger logger = LoggerFactory.getLogger(SimpleHandler.class); @Override public String handleRequest(Map<String, String> input, Context context) { logger.info("Processing request with input: {}", input); String name = input.getOrDefault("name", "World"); return String.format("Hello, %s!", name); } } // Using custom POJO for input/output public class UserHandler implements RequestHandler<UserRequest, UserResponse> { @Override public UserResponse handleRequest(UserRequest request, Context context) { LambdaLogger logger = context.getLogger(); logger.log("Processing user: " + request.getUserId()); // Business logic User user = userService.findUser(request.getUserId()); return UserResponse.builder() .userId(user.getId()) .name(user.getName()) .email(user.getEmail()) .status("SUCCESS") .build(); } } // POJO classes public class UserRequest { private String userId; // getters and setters public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } } public class UserResponse { private String userId; private String name; private String email; private String status; // builder pattern public static Builder builder() { return new Builder(); } public static class Builder { private UserResponse response = new UserResponse(); public Builder userId(String userId) { response.userId = userId; return this; } public Builder name(String name) { response.name = name; return this; } public Builder email(String email) { response.email = email; return this; } public Builder status(String status) { response.status = status; return this; } public UserResponse build() { return response; } } // getters public String getUserId() { return userId; } public String getName() { return name; } public String getEmail() { return email; } public String getStatus() { return status; } }

Stream Handler for Raw Input

public class StreamHandler implements RequestStreamHandler { private static final ObjectMapper objectMapper = new ObjectMapper(); private final UserService userService; public StreamHandler() { this.userService = new UserService(); } @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { LambdaLogger logger = context.getLogger(); try { // Parse input directly from stream UserRequest request = objectMapper.readValue(input, UserRequest.class); logger.log("Processing request for user: " + request.getUserId()); // Process request User user = userService.findUser(request.getUserId()); UserResponse response = UserResponse.builder() .userId(user.getId()) .name(user.getName()) .email(user.getEmail()) .status("SUCCESS") .build(); // Write response to output stream objectMapper.writeValue(output, response); } catch (Exception e) { logger.log("Error processing request: " + e.getMessage()); ErrorResponse error = ErrorResponse.builder() .errorCode("PROCESSING_ERROR") .message(e.getMessage()) .build(); objectMapper.writeValue(output, error); } } }

Dependency Injection with Spring Cloud Function

// Spring Cloud Function setup @SpringBootApplication public class LambdaApplication { @Bean public Function<UserRequest, UserResponse> getUser() { return request -> { UserService userService = new UserService(); User user = userService.findUser(request.getUserId()); return UserResponse.builder() .userId(user.getId()) .name(user.getName()) .email(user.getEmail()) .status("SUCCESS") .build(); }; } @Bean public Consumer<Event> processEvent() { return event -> { // Process event without return value eventProcessor.process(event); }; } @Bean public Supplier<List<User>> getUsers() { return () -> userService.getAllUsers(); } } // With dependency injection @Service public class UserService { private final UserRepository userRepository; private final AuditService auditService; public UserService(UserRepository userRepository, AuditService auditService) { this.userRepository = userRepository; this.auditService = auditService; } public User findUser(String userId) { return userRepository.findById(userId) .orElseThrow(() -> new UserNotFoundException("User not found: " + userId)); } } @Configuration public class AppConfig { @Bean public UserRepository userRepository() { return new DynamoDBUserRepository(); } @Bean public AuditService auditService() { return new CloudWatchAuditService(); } }

Advanced Lambda Patterns

Pattern 1: S3 Event Processing

public class S3ImageProcessor implements RequestHandler<S3Event, String> { private static final Logger logger = LoggerFactory.getLogger(S3ImageProcessor.class); private final AmazonS3 s3Client; private final ImageProcessingService imageService; public S3ImageProcessor() { this.s3Client = AmazonS3ClientBuilder.defaultClient(); this.imageService = new ImageProcessingService(); } @Override public String handleRequest(S3Event s3Event, Context context) { logger.info("Processing S3 event with {} records", s3Event.getRecords().size()); for (S3EventNotificationRecord record : s3Event.getRecords()) { String bucketName = record.getS3().getBucket().getName(); String key = record.getS3().getObject().getKey(); logger.info("Processing image: {}/{}", bucketName, key); try { // Download image from S3 S3Object s3Object = s3Client.getObject(bucketName, key); InputStream imageStream = s3Object.getObjectContent(); // Process image ProcessedImage processed = imageService.resizeImage(imageStream, 800, 600); // Upload processed image String processedKey = "processed/" + key; s3Client.putObject(bucketName, processedKey, new ByteArrayInputStream(processed.getData()), new ObjectMetadata()); logger.info("Successfully processed image: {}", processedKey); } catch (Exception e) { logger.error("Failed to process image: {}/{}", bucketName, key, e); // Consider DLQ for failed processing } } return String.format("Processed %d images", s3Event.getRecords().size()); } }

Pattern 2: API Gateway Proxy Integration

public class ApiGatewayHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> { private final ObjectMapper objectMapper = new ObjectMapper(); private final UserService userService; public ApiGatewayHandler() { this.userService = new UserService(); } @Override public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) { LambdaLogger logger = context.getLogger(); try { String httpMethod = request.getHttpMethod(); String path = request.getPath(); logger.log("Processing " + httpMethod + " " + path); switch (httpMethod) { case "GET": return handleGetRequest(request); case "POST": return handlePostRequest(request); case "PUT": return handlePutRequest(request); case "DELETE": return handleDeleteRequest(request); default: return createErrorResponse(405, "Method not allowed"); } } catch (Exception e) { logger.log("Error processing request: " + e.getMessage()); return createErrorResponse(500, "Internal server error"); } } private APIGatewayProxyResponseEvent handleGetRequest(APIGatewayProxyRequestEvent request) { String path = request.getPath(); if (path.matches("/users/.+")) { // Extract user ID from path String userId = path.substring(path.lastIndexOf("/") + 1); User user = userService.findUser(userId); return createSuccessResponse(user); } else if (path.equals("/users")) { // Get all users with query parameters Map<String, String> queryParams = request.getQueryStringParameters(); String role = queryParams != null ? queryParams.get("role") : null; List<User> users = userService.getUsersByRole(role); return createSuccessResponse(users); } return createErrorResponse(404, "Not found"); } private APIGatewayProxyResponseEvent handlePostRequest(APIGatewayProxyRequestEvent request) { if (request.getPath().equals("/users")) { try { UserCreateRequest createRequest = objectMapper.readValue( request.getBody(), UserCreateRequest.class); User user = userService.createUser(createRequest); return createSuccessResponse(201, user); } catch (Exception e) { return createErrorResponse(400, "Invalid request body"); } } return createErrorResponse(404, "Not found"); } private APIGatewayProxyResponseEvent createSuccessResponse(Object body) { return createSuccessResponse(200, body); } private APIGatewayProxyResponseEvent createSuccessResponse(int statusCode, Object body) { try { String responseBody = objectMapper.writeValueAsString(body); return new APIGatewayProxyResponseEvent() .withStatusCode(statusCode) .withBody(responseBody) .withHeaders(Map.of( "Content-Type", "application/json", "Access-Control-Allow-Origin", "*" )); } catch (Exception e) { return createErrorResponse(500, "Error serializing response"); } } private APIGatewayProxyResponseEvent createErrorResponse(int statusCode, String message) { Map<String, String> errorResponse = Map.of( "error", message, "statusCode", String.valueOf(statusCode) ); try { String responseBody = objectMapper.writeValueAsString(errorResponse); return new APIGatewayProxyResponseEvent() .withStatusCode(statusCode) .withBody(responseBody) .withHeaders(Map.of( "Content-Type", "application/json", "Access-Control-Allow-Origin", "*" )); } catch (Exception e) { // Fallback if JSON serialization fails return new APIGatewayProxyResponseEvent() .withStatusCode(500) .withBody("{\"error\":\"Internal server error\"}") .withHeaders(Map.of("Content-Type", "application/json")); } } }

Pattern 3: DynamoDB Stream Processing

public class DynamoDBStreamProcessor implements RequestHandler<DynamodbEvent, String> { private static final Logger logger = LoggerFactory.getLogger(DynamoDBStreamProcessor.class); private final AuditService auditService; private final NotificationService notificationService; public DynamoDBStreamProcessor() { this.auditService = new AuditService(); this.notificationService = new NotificationService(); } @Override public String handleRequest(DynamodbEvent dynamodbEvent, Context context) { logger.info("Processing DynamoDB stream with {} records", dynamodbEvent.getRecords().size()); int processedCount = 0; int failedCount = 0; for (DynamodbStreamRecord record : dynamodbEvent.getRecords()) { try { processRecord(record); processedCount++; } catch (Exception e) { logger.error("Failed to process record: {}", record.getEventID(), e); failedCount++; } } logger.info("Processed {} records, {} failed", processedCount, failedCount); return String.format("Processed: %d, Failed: %d", processedCount, failedCount); } private void processRecord(DynamodbStreamRecord record) { String eventName = record.getEventName(); Map<String, AttributeValue> newImage = record.getDynamodb().getNewImage(); Map<String, AttributeValue> oldImage = record.getDynamodb().getOldImage(); switch (eventName) { case "INSERT": handleInsert(newImage); break; case "MODIFY": handleModify(oldImage, newImage); break; case "REMOVE": handleRemove(oldImage); break; default: logger.warn("Unknown event type: {}", eventName); } } private void handleInsert(Map<String, AttributeValue> newImage) { String userId = newImage.get("userId").getS(); String userName = newImage.get("name").getS(); // Log audit trail auditService.logEvent("USER_CREATED", userId, Map.of("userName", userName)); // Send welcome notification notificationService.sendWelcomeEmail(userId, userName); logger.info("Processed new user: {} - {}", userId, userName); } private void handleModify(Map<String, AttributeValue> oldImage, Map<String, AttributeValue> newImage) { String userId = newImage.get("userId").getS(); String oldName = oldImage.get("name").getS(); String newName = newImage.get("name").getS(); if (!oldName.equals(newName)) { // Log name change auditService.logEvent("USER_UPDATED", userId, Map.of("oldName", oldName, "newName", newName)); logger.info("User {} changed name from {} to {}", userId, oldName, newName); } } private void handleRemove(Map<String, AttributeValue> oldImage) { String userId = oldImage.get("userId").getS(); String userName = oldImage.get("name").getS(); // Log deletion auditService.logEvent("USER_DELETED", userId, Map.of("userName", userName)); logger.info("User deleted: {} - {}", userId, userName); } }

Performance Optimization

Cold Start Optimization

// Initialization outside handler public class OptimizedHandler implements RequestHandler<UserRequest, UserResponse> { // Static initialization for cold start optimization private static final UserService userService; private static final ObjectMapper objectMapper; private static final DynamoDBMapper dynamoDBMapper; static { // Initialize expensive resources once userService = new UserService(); objectMapper = new ObjectMapper() .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) .registerModule(new JavaTimeModule()); // Initialize AWS clients AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard() .withRegion(Regions.US_EAST_1) .build(); dynamoDBMapper = new DynamoDBMapper(client); // Warm up dependencies userService.initialize(); } @Override public UserResponse handleRequest(UserRequest request, Context context) { // Handler logic uses pre-initialized components return userService.processUser(request); } } // Connection pooling for databases @Component public class DatabaseManager { private static HikariDataSource dataSource; static { HikariConfig config = new HikariConfig(); config.setJdbcUrl(System.getenv("DB_URL")); config.setUsername(System.getenv("DB_USERNAME")); config.setPassword(System.getenv("DB_PASSWORD")); config.setMaximumPoolSize(5); // Conservative for Lambda config.setMinimumIdle(2); config.setConnectionTimeout(30000); config.setIdleTimeout(300000); config.setMaxLifetime(900000); dataSource = new HikariDataSource(config); } public static Connection getConnection() throws SQLException { return dataSource.getConnection(); } }

Environment Configuration

public class ConfigManager { private static final Map<String, String> config = new HashMap<>(); static { // Load environment variables config.put("database_url", System.getenv("DATABASE_URL")); config.put("s3_bucket", System.getenv("S3_BUCKET")); config.put("stage", System.getenv("STAGE")); // Load from AWS Systems Manager Parameter Store loadParametersFromSSM(); } private static void loadParametersFromSSM() { AWSSimpleSystemsManagement ssm = AWSSimpleSystemsManagementClientBuilder.defaultClient(); String path = "/app/" + config.get("stage") + "/"; GetParametersByPathRequest request = new GetParametersByPathRequest() .withPath(path) .withRecursive(true) .withWithDecryption(true); GetParametersByPathResult result = ssm.getParametersByPath(request); for (Parameter param : result.getParameters()) { String key = param.getName().replace(path, ""); config.put(key, param.getValue()); } } public static String get(String key) { return config.get(key); } public static String get(String key, String defaultValue) { return config.getOrDefault(key, defaultValue); } }

Testing Lambda Functions

Unit Testing

class LambdaHandlerTest { private TestContext context; private UserHandler handler; @BeforeEach void setUp() { handler = new UserHandler(); context = new TestContext(); } @Test void testHandleRequest_Success() { // Given UserRequest request = new UserRequest(); request.setUserId("123"); // When UserResponse response = handler.handleRequest(request, context); // Then assertThat(response.getUserId()).isEqualTo("123"); assertThat(response.getStatus()).isEqualTo("SUCCESS"); } @Test void testHandleRequest_UserNotFound() { // Given UserRequest request = new UserRequest(); request.setUserId("nonexistent"); // When/Then assertThatThrownBy(() -> handler.handleRequest(request, context)) .isInstanceOf(UserNotFoundException.class); } } // Test context implementation class TestContext implements Context { @Override public String getAwsRequestId() { return "test-request-id"; } @Override public String getLogGroupName() { return "test-log-group"; } @Override public String getLogStreamName() { return "test-log-stream"; } @Override public String getFunctionName() { return "test-function"; } @Override public String getFunctionVersion() { return "1.0"; } @Override public String getInvokedFunctionArn() { return "test-arn"; } @Override public CognitoIdentity getIdentity() { return null; } @Override public ClientContext getClientContext() { return null; } @Override public int getRemainingTimeInMillis() { return 30000; } @Override public int getMemoryLimitInMB() { return 512; } @Override public LambdaLogger getLogger() { return message -> System.out.println("LOG: " + message); } }

Integration Testing

@SpringBootTest @TestPropertySource(properties = { "AWS_ACCESS_KEY_ID=test", "AWS_SECRET_ACCESS_KEY=test", "AWS_REGION=us-east-1" }) class LambdaIntegrationTest { @Localstack private LocalStackContainer localstack; @Autowired private Function<UserRequest, UserResponse> getUserFunction; @BeforeEach void setup() { // Setup test data in local DynamoDB setupTestData(); } @Test void testGetUserFunction() { // Given UserRequest request = new UserRequest(); request.setUserId("test-user-1"); // When UserResponse response = getUserFunction.apply(request); // Then assertThat(response.getUserId()).isEqualTo("test-user-1"); assertThat(response.getName()).isEqualTo("Test User"); } private void setupTestData() { // Use localstack to setup test data // ... } }

Deployment Configuration

SAM Template (template.yaml)

AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Parameters: Stage: Type: String Default: dev AllowedValues: - dev - staging - prod Globals: Function: Timeout: 30 MemorySize: 512 Runtime: java11 Environment: Variables: STAGE: !Ref Stage Resources: UserFunction: Type: AWS::Serverless::Function Properties: FunctionName: !Sub user-service-${Stage} Handler: com.example.UserHandler::handleRequest CodeUri: target/user-service-1.0.0.jar Policies: - DynamoDBCrudPolicy: TableName: !Ref UsersTable - S3ReadPolicy: BucketName: !Ref DocumentsBucket Events: Api: Type: Api Properties: Path: /users/{userId} Method: get S3Event: Type: S3 Properties: Bucket: !Ref DocumentsBucket Events: s3:ObjectCreated:* UsersTable: Type: AWS::DynamoDB::Table Properties: TableName: !Sub users-${Stage} BillingMode: PAY_PER_REQUEST AttributeDefinitions: - AttributeName: userId AttributeType: S KeySchema: - AttributeName: userId KeyType: HASH DocumentsBucket: Type: AWS::S3::Bucket Properties: BucketName: !Sub documents-${Stage}-${AWS::AccountId} Outputs: UserFunctionArn: Description: "User Function ARN" Value: !GetAtt UserFunction.Arn ApiUrl: Description: "API Gateway URL" Value: !Sub https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/${Stage}/users

Build Configuration (Maven)

<!-- pom.xml --> <project> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>user-service</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.1</aws.lambda.java.version> <aws.java.sdk.version>2.20.0</aws.java.sdk.version> </properties> <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-core</artifactId> <version>${aws.lambda.java.version}</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-events</artifactId> <version>3.11.0</version> </dependency> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>dynamodb</artifactId> <version>${aws.java.sdk.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.0</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.3.0</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> </xml>

Monitoring and Logging

public class MonitoringHandler implements RequestHandler<UserRequest, UserResponse> { private static final MeterRegistry meterRegistry = CloudWatchMeterRegistry.builder() .namespace("MyApp") .build(); @Override public UserResponse handleRequest(UserRequest request, Context context) { Timer.Sample timer = Timer.start(meterRegistry); Counter requests = meterRegistry.counter("requests.total"); try { requests.increment(); // Business logic UserResponse response = processRequest(request); // Record success metric meterRegistry.counter("requests.success").increment(); return response; } catch (Exception e) { // Record error metric meterRegistry.counter("requests.error").increment(); throw e; } finally { // Record execution time timer.stop(Timer.builder("requests.duration") .register(meterRegistry)); } } // Custom metrics utility public static void recordBusinessMetric(String metricName, double value) { meterRegistry.gauge(metricName, value); } }

Best Practices

1. Performance

Initialize expensive resources outside handler
Use connection pooling for databases
Keep deployment package size minimal
Use provisioned concurrency for critical functions

2. Security

Use IAM roles with least privilege
Encrypt environment variables
Validate input thoroughly
Use VPC for sensitive operations

3. Reliability

Implement proper error handling
Use dead letter queues (DLQ) for async invocations
Set appropriate timeouts and memory
Implement retry logic with exponential backoff

4. Observability

Use structured logging
Include correlation IDs
Monitor cold start times
Track business metrics

Conclusion

AWS Lambda with Java provides a powerful platform for serverless applications:

Cost-effective: Pay only for compute time used
Scalable: Automatic scaling based on demand
Managed infrastructure: No server management required
Rich ecosystem: Integration with AWS services

Key success factors:

Proper initialization for cold start optimization
Efficient resource usage within Lambda constraints
Comprehensive monitoring and logging
Security best practices for IAM and data protection

Java Lambda functions are ideal for:

API backends with API Gateway
Event processing from S3, DynamoDB, Kinesis
Data transformation pipelines
Scheduled tasks with EventBridge
Microservices in serverless architectures