New advertisers: 50% off your first month with code FIRSTMONTHSee slots

Java toolkit that adds Spring Boot, JUnit, LangChain4J, and AWS SDK guidance to Claude Code.

version
4.0.1
GitHub stars
372
View on GitHub

What it does

  • Adds 11 commands such as devkit.java.code-review, devkit.java.generate-crud, and devkit.java.write-unit-tests, plus 9 specialist agents for Spring Boot, security, and refactoring
  • Covers Spring Boot patterns including JWT security, Resilience4j, saga flows, and OpenAPI docs, along with JUnit unit test patterns for each layer
  • Provides AWS skills for SDK v2 clients covering Bedrock, DynamoDB, KMS, S3, RDS, and Lambda, plus GraalVM native image builds
  • Requires developer-kit and pairs with developer-kit-ai for the LangChain4J and vector store skills

Comprehensive Java development toolkit with Spring Boot, testing, and AWS integration

Add marketplace

/plugin marketplace add giuseppe-trisciuoglio/developer-kit

Run it inside Claude Code once, then install the plugin below.

Install

/plugin install developer-kit-java@developer-kit

Run it inside Claude Code after adding the marketplace.

Files

Discovered from source
qdrantspring-ai-mcp-server-patternsspring-boot-actuatorspring-boot-cachespring-boot-crud-patternsspring-boot-dependency-injectionspring-boot-event-driven-patternsspring-boot-openapi-documentationspring-boot-project-creatorspring-boot-resilience4jspring-boot-rest-api-standardsspring-boot-saga-patternspring-boot-security-jwtspring-boot-test-patternsspring-data-jpaspring-data-neo4junit-test-application-eventsunit-test-bean-validationunit-test-boundary-conditionsunit-test-cachingunit-test-config-propertiesunit-test-controller-layerunit-test-exception-handlerunit-test-json-serializationunit-test-mapper-converterunit-test-parameterizedunit-test-scheduled-asyncunit-test-security-authorizationunit-test-service-layerunit-test-utility-methodsunit-test-wiremock-rest-apiwiremock-standalone-docker

AWS Lambda Java Integration

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

Overview

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

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

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

When to Use

  • Deploying Java functions to AWS Lambda
  • Optimizing cold starts below 1 second
  • Choosing between Micronaut and Raw Java approaches
  • Configuring API Gateway or ALB integration
  • Setting up CI/CD pipelines for Java Lambda

Instructions

1. Choose Your Approach

ApproachCold StartBest ForComplexity
Micronaut< 1sComplex apps, DI needed, enterpriseMedium
Raw Java< 500msSimple handlers, minimal overheadLow

Validate: Confirm the approach fits your use case before proceeding.

2. Project Structure

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

Validate: Verify project structure matches the template.

3. Implementation Examples

Micronaut Handler
@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\"}");
    }
}
Raw Java Handler
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\"}");
    }
}

Validate: Run sam local invoke to verify handler works before deployment.

Core Patterns

Connection Management

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

// Avoid: Creating clients in handler (slow on every invocation)

Error Handling

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

Best Practices

Configuration

  • Memory: Start with 512MB, adjust based on profiling
  • Timeout: Micronaut 10-30s, Raw Java 5-10s
  • Runtime: Java 17 or 21 for best performance

Packaging

  • Use Gradle Shadow Plugin or Maven Shade Plugin
  • Exclude unnecessary dependencies

Monitoring

  • Enable X-Ray tracing for performance analysis
  • Use CloudWatch Insights to track cold vs warm starts

Deployment Options

Serverless Framework

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

Validate: Run serverless deploy with --stage dev first.

AWS SAM

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

Validate: Run sam validate before deploying.

Constraints and Warnings

Java-Specific Constraints

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

Common Pitfalls

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

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

Examples

Example 1: Create a Micronaut Lambda Function

Input:

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

Process:

  1. Configure Gradle project with Micronaut plugin
  2. Create Handler class extending MicronautRequestHandler
  3. Implement methods for GET/POST/PUT/DELETE
  4. Configure application.yml with AOT optimizations
  5. Set up packaging with Shadow plugin
  6. Validate: Test locally with SAM CLI before deploying

Output:

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

Example 2: Optimize Cold Start for Raw Java

Input:

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

Process:

  1. Analyze initialization code
  2. Move AWS client creation to static fields
  3. Reduce dependencies in build.gradle
  4. Configure optimized JVM options
  5. Consider provisioned concurrency
  6. Validate: Measure cold start with CloudWatch metrics after changes

Output:

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

Example 3: Deploy with GitHub Actions

Input:

Configure CI/CD for Java Lambda with SAM

Process:

  1. Create GitHub Actions workflow
  2. Configure Gradle build with Shadow
  3. Set up SAM build and deploy
  4. Add test stage before deployment
  5. Configure environment protection for prod

Output:

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

Version

Version: 1.0.0

Readme

Developer Kit Java

Comprehensive Java development toolkit with Spring Boot, testing, LangChain4J, and AWS integration.

Overview

The developer-kit-java plugin provides extensive support for Java development, including Spring Boot applications, unit/integration testing with JUnit, LangChain4J for AI applications, and AWS SDK integration.

Agents

  • spring-boot-backend-development-expert - Spring Boot development
  • spring-boot-code-review-expert - Spring Boot code review
  • spring-boot-unit-testing-expert - Spring Boot testing
  • java-refactor-expert - Java-specific refactoring
  • java-security-expert - Java security best practices
  • java-software-architect-review - Java architecture review
  • java-documentation-specialist - Java documentation
  • java-tutorial-engineer - Java learning resources
  • langchain4j-ai-development-expert - LangChain4J integration

Commands

  • devkit.java.code-review - Comprehensive Java code review
  • devkit.java.generate-crud - Generate CRUD operations
  • devkit.java.refactor-class - Refactor Java classes
  • devkit.java.architect-review - Architecture review
  • devkit.java.dependency-audit - Dependency analysis
  • devkit.java.generate-docs - Generate documentation
  • devkit.java.security-review - Security review
  • devkit.java.upgrade-dependencies - Upgrade dependencies
  • devkit.java.write-unit-tests - Generate unit tests
  • devkit.java.write-integration-tests - Generate integration tests
  • devkit.java.generate-refactoring-tasks.md - Generate refactoring tasks from bounded context

Skills

Spring Boot

  • Spring Boot Actuator, Cache, CRUD Patterns, Dependency Injection
  • Event-Driven Patterns, OpenAPI Documentation, REST API Standards
  • Saga Pattern, Security JWT, Test Patterns, Resilience4j
  • spring-boot-project-creator - Project generation from specification

Architecture

  • clean-architecture - Clean Architecture, Hexagonal Architecture, and DDD patterns for Java 21+ Spring Boot 3.5+

Spring Data

  • Spring Data JPA, Spring Data Neo4j

Spring AI

  • spring-ai-mcp-server-patterns - Model Context Protocol server implementation

JUnit Testing

  • Unit test patterns for all layers and scenarios

LangChain4J

  • AI Services, MCP Server, RAG Implementation, Spring Boot Integration
  • Testing Strategies, Tool Function Calling, Vector Stores Configuration
  • qdrant - Qdrant vector database integration

AWS Java SDK

  • RDS, Bedrock, DynamoDB, KMS, Lambda, Messaging, S3, Secrets Manager

AWS Lambda Integration

  • aws-lambda-java-integration - AWS Lambda integration patterns for Java with Micronaut Framework and Raw Java handlers

GraalVM Native Image

  • graalvm-native-image - Build native executables from Java applications, optimize cold start times, configure Maven/Gradle native build tools, resolve reflection and resource issues

Dependencies

  • developer-kit (required)
  • developer-kit-ai (for LangChain4J skills)

Details

Marketplace
giuseppe-trisciuoglio/developer-kit
Source
plugins/developer-kit-java
Category
Community

More from giuseppe-trisciuoglio/developer-kit

All 11

Similar to developer-kit-java

More Testing & Code Quality