Java

• Enterprise teams
• Strong typing + Maven/Gradle
• Same language as backend
• Best IDE support (IntelliJ)

L3 — Patterns

• Multi-resource architectures in one construct
• E.g., LambdaRestApi = Lambda + API GW + IAM
• Entire application patterns
• AWS Solutions Constructs library
• Highest abstraction, least flexibility

Java — Custom Construct

public class SecureApi extends Construct {

    private final LambdaRestApi api;

    public SecureApi(Construct scope, String id,
                     String handlerPath, String stage) {
        super(scope, id);

        Function fn = Function.Builder.create(this, "Handler")
            .runtime(Runtime.PYTHON_3_12)
            .code(Code.fromAsset(handlerPath))
            .handler("index.handler")
            .build();

        this.api = LambdaRestApi.Builder
            .create(this, "Endpoint")
            .handler(fn)
            .deployOptions(StageOptions.builder()
                .stageName(stage).build())
            .build();
    }

    public LambdaRestApi getApi() { return api; }
}

Java

// Lambda needs to read from S3 bucket
Bucket bucket = Bucket.Builder.create(this, "DataBucket")
    .build();
Function fn = Function.Builder.create(this, "Processor")
    ...
    .build();

// ONE LINE — creates IAM policy automatically
bucket.grantRead(fn);

// Other grant methods:
// bucket.grantReadWrite(fn);
// table.grantReadData(fn);
// queue.grantSendMessages(fn);
// topic.grantPublish(fn);

When to Run

• Once per account + region combination
• Before the first cdk deploy
• Re-run when CDK updates the bootstrap template
• Cross-account deploys need bootstrap in target account

Java Project

my-cdk-app/
├── cdk.json            # CDK config
├── pom.xml             # Maven deps
├── src/main/tech/com/myapp/
│   ├── CdkApp.java    # Entry point
│   ├── NetworkStack.java
│   └── AppStack.java
└── src/test/tech/com/myapp/
    └── AppStackTest.java

Java

import software.amazon.awscdk.*;
import software.amazon.awscdk.services.lambda.*;
import software.amazon.awscdk.services.apigateway.*;
import software.amazon.awscdk.services.dynamodb.*;
import software.constructs.Construct;
import java.util.Map;

public class ServerlessApiStack extends Stack {

    public ServerlessApiStack(Construct scope, String id,
                              StackProps props) {
        super(scope, id, props);

        // DynamoDB table
        Table table = Table.Builder.create(this, "Orders")
            .partitionKey(Attribute.builder()
                .name("orderId")
                .type(AttributeType.STRING).build())
            .billingMode(BillingMode.PAY_PER_REQUEST)
            .removalPolicy(RemovalPolicy.DESTROY)
            .build();

        // Lambda function
        Function handler = Function.Builder.create(this, "OrderHandler")
            .runtime(Runtime.PYTHON_3_12)
            .code(Code.fromAsset("lambda"))
            .handler("orders.handler")
            .environment(Map.of(
                "TABLE_NAME", table.getTableName()
            ))
            .build();

        // Grant Lambda read/write to DynamoDB
        table.grantReadWriteData(handler);

        // API Gateway
        RestApi api = RestApi.Builder.create(this, "OrdersApi")
            .restApiName("Orders Service")
            .build();
        Resource orders = api.getRoot().addResource("orders");
        orders.addMethod("GET", new LambdaIntegration(handler));
        orders.addMethod("POST", new LambdaIntegration(handler));
    }
}

Java — ECS Fargate Service

import software.amazon.awscdk.*;
import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
import software.constructs.Construct;

public class WebAppStack extends Stack {

    public WebAppStack(Construct scope, String id, StackProps props) {
        super(scope, id, props);

        Vpc vpc = Vpc.Builder.create(this, "AppVpc")
            .maxAzs(2).build();

        Cluster cluster = Cluster.Builder.create(this, "Cluster")
            .vpc(vpc).build();

        // L3 Pattern: ALB + Fargate in ONE construct
        ApplicationLoadBalancedFargateService service =
            ApplicationLoadBalancedFargateService.Builder
                .create(this, "WebService")
                .cluster(cluster)
                .cpu(256)
                .memoryLimitMiB(512)
                .desiredCount(2)
                .taskImageOptions(
                    ApplicationLoadBalancedTaskImageOptions.builder()
                        .image(ContainerImage.fromAsset("./docker"))
                        .containerPort(8080)
                        .build())
                .publicLoadBalancer(true)
                .build();

        // Auto-scaling
        ScalableTaskCount scaling = service.getService()
            .autoScaleTaskCount(EnableScalingProps.builder()
                .minCapacity(2).maxCapacity(10).build());
        scaling.scaleOnCpuUtilization("CpuScale",
            CpuUtilizationScalingProps.builder()
                .targetUtilizationPercent(70).build());
    }
}

Java — Environment Config

// CdkApp.java
App app = new App();
String envName = (String) app.getNode()
    .tryGetContext("env");
if (envName == null) envName = "dev";

Map<String, Map<String, Object>> config = Map.of(
    "dev", Map.of(
        "instanceType", "t3.micro",
        "minCapacity", 1,
        "maxCapacity", 2
    ),
    "prod", Map.of(
        "instanceType", "t3.large",
        "minCapacity", 2,
        "maxCapacity", 20
    )
);

new AppStack(app, "AppStack-" + envName,
    StackProps.builder()
        .env(Environment.builder()
            .account("123456789012")
            .region("us-east-1").build())
        .build(),
    config.get(envName)
);
// Deploy: cdk deploy -c env=prod

Java — JUnit 5

// src/test/tech/com/myapp/ServerlessApiStackTest.java
import org.junit.jupiter.api.Test;
import software.amazon.awscdk.App;
import software.amazon.awscdk.assertions.Template;
import software.amazon.awscdk.assertions.Match;
import java.util.Map;

class ServerlessApiStackTest {

    @Test
    void dynamoDbTableCreated() {
        App app = new App();
        ServerlessApiStack stack = new ServerlessApiStack(
            app, "TestStack", null);
        Template template = Template.fromStack(stack);

        template.hasResourceProperties(
            "AWS::DynamoDB::Table",
            Map.of(
                "KeySchema", java.util.List.of(
                    Map.of("AttributeName", "orderId",
                           "KeyType", "HASH")),
                "BillingMode", "PAY_PER_REQUEST"
            )
        );
    }

    @Test
    void lambdaHasEnvironmentVars() {
        App app = new App();
        ServerlessApiStack stack = new ServerlessApiStack(
            app, "TestStack", null);
        Template template = Template.fromStack(stack);

        template.hasResourceProperties(
            "AWS::Lambda::Function",
            Map.of(
                "Runtime", "python3.12",
                "Environment", Match.objectLike(
                    Map.of("Variables",
                        Match.objectLike(Map.of(
                            "TABLE_NAME", Match.anyValue()
                        ))
                    )
                )
            )
        );
    }

    @Test
    void apiGatewayExists() {
        App app = new App();
        ServerlessApiStack stack = new ServerlessApiStack(
            app, "TestStack", null);
        Template template = Template.fromStack(stack);

        template.resourceCountIs(
            "AWS::ApiGateway::RestApi", 1);
    }
}
// Run: mvn test

Java — CDK Pipeline

import software.amazon.awscdk.*;
import software.amazon.awscdk.pipelines.*;
import software.constructs.Construct;
import java.util.List;

public class PipelineStack extends Stack {
    public PipelineStack(Construct scope, String id,
                         StackProps props) {
        super(scope, id, props);

        CodePipeline pipeline = CodePipeline.Builder
            .create(this, "Pipeline")
            .synth(CodeBuildStep.Builder.create("Synth")
                .input(CodePipelineSource.gitHub(
                    "my-org/my-repo", "main"))
                .commands(List.of(
                    "mvn package",
                    "npx cdk synth"
                ))
                .build())
            .build();

        // Add stages
        pipeline.addStage(new StagingStage(this, "Staging"));
        pipeline.addStage(new ProdStage(this, "Prod"),
            AddStageOpts.builder()
                .pre(List.of(
                    new ManualApprovalStep("Approve")))
                .build());
    }
}

Java

// Access the underlying CFN resource
Bucket bucket = Bucket.Builder.create(this, "MyBucket")
    .build();

// Escape hatch: get the L1 CfnBucket
CfnBucket cfnBucket = (CfnBucket) bucket.getNode()
    .getDefaultChild();

// Modify a property not exposed by L2
cfnBucket.addPropertyOverride(
    "AnalyticsConfigurations",
    List.of(Map.of(
        "Id", "FullAnalytics",
        "StorageClassAnalysis", Map.of(...)
    ))
);

Approach 2: Green-Field Rewrite

• Write new CDK stacks alongside existing CFN
• Migrate resources between stacks using import/export
• Delete old CFN stack once migration complete
• Best for major architecture refactoring