aws-lambda-java-integration

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

AWS Lambda Java Integration

AWS Lambda Java 集成方案

Patterns for creating high-performance AWS Lambda functions in Java with optimized cold starts.

本文提供创建高性能Java版AWS Lambda函数的模式，包含冷启动优化方案。

Overview

概述

This skill provides complete patterns for AWS Lambda Java development, covering two main approaches:

Micronaut Framework - Full-featured framework with AOT compilation, dependency injection, and cold start < 1s
Raw Java - Minimal overhead approach with cold start < 500ms

Both approaches support API Gateway and ALB integration with production-ready configurations.

本技能提供AWS Lambda Java开发的完整模式，涵盖两种主要方案：

Micronaut框架 - 全功能框架，支持AOT编译、依赖注入，冷启动时间<1秒
原生Java - 低开销方案，冷启动时间<500毫秒

两种方案均支持API Gateway和ALB集成，且配置可直接用于生产环境。

When to Use

适用场景

Use this skill when:

Creating new Lambda functions in Java
Migrating existing Java applications to Lambda
Optimizing cold start performance for Java Lambda
Choosing between framework-based and minimal Java approaches
Configuring API Gateway or ALB integration
Setting up deployment pipelines for Java Lambda

在以下场景中使用本技能：

创建新的Java版Lambda函数
将现有Java应用迁移至Lambda
优化Java Lambda的冷启动性能
在基于框架与轻量Java方案间做选择
配置API Gateway或ALB集成
搭建Java Lambda的部署流水线

Instructions

操作步骤

1. Choose Your Approach

1. 选择方案

Approach	Cold Start	Best For	Complexity
Micronaut	< 1s	Complex apps, DI needed, enterprise	Medium
Raw Java	< 500ms	Simple handlers, minimal overhead	Low

方案	冷启动时间	最佳适用场景	复杂度
Micronaut	<1秒	复杂应用、需要依赖注入的企业级场景	中等
原生Java	<500毫秒	简单处理器、追求最低开销	低

2. Project Structure

2. 项目结构

my-lambda-function/
├── build.gradle (or pom.xml)
├── src/
│   └── main/
│       ├── java/
│       │   └── com/example/
│       │       └── Handler.java
│       └── resources/
│           └── application.yml (Micronaut only)
└── serverless.yml (or template.yaml)

my-lambda-function/
├── build.gradle (或pom.xml)
├── src/
│   └── main/
│       ├── java/
│       │   └── com/example/
│       │       └── Handler.java
│       └── resources/
│           └── application.yml (仅Micronaut项目需要)
└── serverless.yml (或template.yaml)

3. Implementation Examples

3. 实现示例

Micronaut Handler

Micronaut处理器

java

@FunctionBean("my-function")
public class MyFunction implements Function<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    private final MyService service;

    public MyFunction(MyService service) {
        this.service = service;
    }

    @Override
    public APIGatewayProxyResponseEvent apply(APIGatewayProxyRequestEvent request) {
        // Process request
        return new APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withBody("{\"message\": \"Success\"}");
    }
}

java

@FunctionBean("my-function")
public class MyFunction implements Function<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    private final MyService service;

    public MyFunction(MyService service) {
        this.service = service;
    }

    @Override
    public APIGatewayProxyResponseEvent apply(APIGatewayProxyRequestEvent request) {
        // 处理请求
        return new APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withBody("{\"message\": \"Success\"}");
    }
}

Raw Java Handler

原生Java处理器

java

public class MyHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    // Singleton pattern for warm invocations
    private static final MyService service = new MyService();

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) {
        return new APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withBody("{\"message\": \"Success\"}");
    }
}

java

public class MyHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    // 单例模式，用于热调用复用
    private static final MyService service = new MyService();

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) {
        return new APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withBody("{\"message\": \"Success\"}");
    }
}

Core Concepts

核心概念

Cold Start Optimization

冷启动优化

Cold start time depends on initialization code. Key strategies:

Lazy Initialization - Defer heavy setup from constructor
Singleton Pattern - Cache initialized services as static fields
Minimal Dependencies - Reduce JAR size by excluding unused libraries
AOT Compilation - Micronaut's ahead-of-time compilation eliminates reflection

冷启动时间取决于初始化代码，关键策略如下：

延迟初始化 - 将重量级初始化逻辑从构造函数中延迟执行
单例模式 - 将初始化后的服务缓存为静态字段
最小化依赖 - 通过排除未使用的库来减小JAR包体积
AOT编译 - Micronaut的提前编译可消除反射带来的开销

Connection Management

连接管理

java

// GOOD: Initialize once, reuse across invocations
private static final DynamoDbClient dynamoDb = DynamoDbClient.builder()
    .region(Region.US_EAST_1)
    .build();

// AVOID: Creating clients in handler method
public APIGatewayProxyResponseEvent handleRequest(...) {
    DynamoDbClient client = DynamoDbClient.create(); // Slow on every invocation
}

java

// 推荐：仅初始化一次，在多个调用间复用
private static final DynamoDbClient dynamoDb = DynamoDbClient.builder()
    .region(Region.US_EAST_1)
    .build();

// 避免：在处理器方法中创建客户端
public APIGatewayProxyResponseEvent handleRequest(...) {
    DynamoDbClient client = DynamoDbClient.create(); // 每次调用都会变慢
}

Error Handling

错误处理

java

@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) {
    try {
        // Business logic
        return successResponse(result);
    } catch (ValidationException e) {
        return errorResponse(400, e.getMessage());
    } catch (Exception e) {
        context.getLogger().log("Error: " + e.getMessage());
        return errorResponse(500, "Internal error");
    }
}

java

@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) {
    try {
        // 业务逻辑
        return successResponse(result);
    } catch (ValidationException e) {
        return errorResponse(400, e.getMessage());
    } catch (Exception e) {
        context.getLogger().log("Error: " + e.getMessage());
        return errorResponse(500, "内部错误");
    }
}

Best Practices

最佳实践

Memory and Timeout Configuration

内存与超时配置

Memory: Start with 512MB, adjust based on profiling
Timeout: Set based on cold start + expected processing time
- Micronaut: 10-30 seconds for cold start buffer
- Raw Java: 5-10 seconds typically sufficient

内存：从512MB开始，根据性能分析结果调整
超时：根据冷启动时间+预期处理时间设置
- Micronaut：预留10-30秒的冷启动缓冲时间
- 原生Java：通常5-10秒足够

Packaging

打包

Use Gradle Shadow Plugin or Maven Shade Plugin
Exclude unnecessary dependencies
Target Java 17 or 21 for best performance

使用Gradle Shadow插件或Maven Shade插件
排除不必要的依赖
选择Java 17或21以获得最佳性能

Monitoring

监控

Enable X-Ray tracing for performance analysis
Log initialization time separately from processing time
Use CloudWatch Insights to track cold vs warm starts

启用X-Ray追踪以进行性能分析
将初始化时间与处理时间分开记录
使用CloudWatch Insights跟踪冷启动与热启动

Deployment Options

部署选项

Serverless Framework

yaml

service: my-java-lambda

provider:
  name: aws
  runtime: java21
  memorySize: 512
  timeout: 10

package:
  artifact: build/libs/function.jar

functions:
  api:
    handler: com.example.Handler
    events:
      - http:
          path: /{proxy+}
          method: ANY

yaml

service: my-java-lambda

provider:
  name: aws
  runtime: java21
  memorySize: 512
  timeout: 10

package:
  artifact: build/libs/function.jar

functions:
  api:
    handler: com.example.Handler
    events:
      - http:
          path: /{proxy+}
          method: ANY

AWS SAM

yaml

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: build/libs/function.jar
      Handler: com.example.Handler
      Runtime: java21
      MemorySize: 512
      Timeout: 10
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /{proxy+}
            Method: ANY

yaml

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: build/libs/function.jar
      Handler: com.example.Handler
      Runtime: java21
      MemorySize: 512
      Timeout: 10
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /{proxy+}
            Method: ANY

Constraints and Warnings

约束与注意事项

Lambda Limits

Lambda限制

Deployment package: 250MB unzipped maximum
Memory: 128MB to 10GB
Timeout: 15 minutes maximum
Concurrent executions: 1000 default (adjustable)

部署包：最大250MB（未压缩）
内存：128MB至10GB
超时：最大15分钟
并发执行数：默认1000（可调整）

Java-Specific Considerations

Java专属注意事项

Reflection: Minimize use; prefer AOT compilation (Micronaut)
Classpath scanning: Slows cold start; use explicit configuration
Large frameworks: Spring Boot adds significant cold start overhead

反射：尽量减少使用；优先选择AOT编译（Micronaut）
类路径扫描：会延长冷启动时间；使用显式配置
大型框架：Spring Boot会显著增加冷启动开销

Common Pitfalls

常见陷阱

Initialization in handler - Causes repeated work on warm invocations
Oversized JARs - Include only required dependencies
Insufficient memory - Java needs more memory than Node.js/Python
No timeout handling - Always set appropriate timeouts

在处理器中初始化 - 会导致热调用时重复执行初始化工作
过大的JAR包 - 仅包含必要的依赖
内存不足 - Java所需内存比Node.js/Python更多
未设置超时 - 始终配置合适的超时时间

References

参考资料

For detailed guidance on specific topics:

Micronaut Lambda - Complete Micronaut setup, AOT configuration, DI optimization
Raw Java Lambda - Minimal handler patterns, singleton caching, JAR packaging
Serverless Deployment - Serverless Framework, SAM, CI/CD pipelines, provisioned concurrency
Testing Lambda - JUnit 5, SAM Local, integration testing, performance measurement

如需特定主题的详细指南：

Micronaut Lambda - 完整的Micronaut设置、AOT配置、依赖注入优化
原生Java Lambda - 轻量处理器模式、单例缓存、JAR打包
无服务器部署 - Serverless Framework、SAM、CI/CD流水线、预置并发
Lambda测试 - JUnit 5、SAM Local、集成测试、性能测量

Examples

示例

Example 1: Create a Micronaut Lambda Function

示例1：创建Micronaut Lambda函数

Input:

Create a Java Lambda function using Micronaut to handle user REST API

Process:

Configure Gradle project with Micronaut plugin
Create Handler class extending MicronautRequestHandler
Implement methods for GET/POST/PUT/DELETE
Configure application.yml with AOT optimizations
Set up packaging with Shadow plugin

Output:

Complete project structure
Handler with dependency injection
serverless.yml deployment configuration

输入：

Create a Java Lambda function using Micronaut to handle user REST API

流程：

配置带Micronaut插件的Gradle项目
创建继承MicronautRequestHandler的处理器类
实现GET/POST/PUT/DELETE方法
在application.yml中配置AOT优化
使用Shadow插件设置打包规则

输出：

完整的项目结构
带依赖注入的处理器
serverless.yml部署配置

Example 2: Optimize Cold Start for Raw Java

示例2：优化原生Java的冷启动时间

Input:

My Java Lambda has 3 second cold start, how do I optimize it?

Process:

Analyze initialization code
Move AWS client creation to static fields
Reduce dependencies in build.gradle
Configure optimized JVM options
Consider provisioned concurrency

Output:

Refactored code with singleton pattern
Minimized JAR
Cold start < 500ms

输入：

My Java Lambda has 3 second cold start, how do I optimize it?

流程：

分析初始化代码
将AWS客户端创建移至静态字段
减少build.gradle中的依赖
配置优化后的JVM选项
考虑使用预置并发

输出：

采用单例模式的重构代码
最小化的JAR包
冷启动时间<500毫秒

Example 3: Deploy with GitHub Actions

示例3：使用GitHub Actions部署

Input:

Configure CI/CD for Java Lambda with SAM

Process:

Create GitHub Actions workflow
Configure Gradle build with Shadow
Set up SAM build and deploy
Add test stage before deployment
Configure environment protection for prod

Output:

Complete .github/workflows/deploy.yml
Multi-stage pipeline (dev/staging/prod)
Integrated test automation

输入：

Configure CI/CD for Java Lambda with SAM

流程：

创建GitHub Actions工作流
配置带Shadow插件的Gradle构建
设置SAM构建与部署
在部署前添加测试阶段
为生产环境配置环境保护

输出：

完整的.github/workflows/deploy.yml
多阶段流水线（开发/预发布/生产）
集成测试自动化

Version

版本

Version: 1.0.0

版本：1.0.0