Spring Boot Multi-Module Assistant

This skill provides expert guidance for working with a multi-module Maven Spring Boot project that demonstrates different application implementations with performance testing capabilities.

What This Skill Does

This skill helps you navigate and work with a Spring Boot project that includes:

Project Structure

The project consists of:

Both main modules share the same API design and database schema but use different technology stacks.

Instructions

When working with this codebase, follow these guidelines:

1. Understanding the Architecture

- `controller/`: REST API endpoints

- `service/`: Business logic

- `repository/`: Data access (JPA vs R2DBC)

- `entity/`: Database entities

- `dto/`: API data transfer objects

- `config/`: Configuration classes

2. Building and Running

**Build commands:**

```bash

Build all modules

mvn clean package

Build specific module

mvn clean package -pl sample-web

mvn clean package -pl sample-webflux

```

**Start infrastructure:**

```bash

Start PostgreSQL (port 5432) and WireMock (port 8081)

docker-compose up -d

```

**Run applications:**

```bash

Run blocking implementation

mvn spring-boot:run -pl sample-web

Run reactive implementation

mvn spring-boot:run -pl sample-webflux

```

3. Testing

**Unit/Integration tests:**

```bash

Run all tests

mvn test

Run module-specific tests

mvn test -pl sample-web

mvn test -pl sample-webflux

```

**Performance testing:**

- `backend/`: PostgreSQL + WireMock

- `web-platform-thread/`: Platform thread configuration

- `web-virtual-thread/`: Virtual thread configuration (Java 21+)

- `webflux/`: Reactive configuration

4. Features Implementation

**TODO Feature** (both modules):

**EC Feature** (sample-web only):

5. Database and External Services

**PostgreSQL:**

**WireMock:**

6. Code Modifications

When adding or modifying features:

7. Java Version

Both modules use Java 24 as specified in POM files. Ensure compatibility when adding dependencies or language features.

Examples

**Adding a new feature:**

1. Create package under `com.example.sample.web.{feature}` and `com.example.sample.webflux.{feature}`

2. Implement controller, service, repository, entity, and DTOs in each module

3. Use JPA/RestClient in sample-web, R2DBC/WebClient in sample-webflux

4. Add corresponding tests

5. Update CLAUDE.md if introducing new patterns

**Running performance comparison:**

1. Start backend: `cd performance/backend && docker-compose up -d`

2. Start target implementation (e.g., `cd performance/web-platform-thread && docker-compose up -d`)

3. Run K6 tests from `performance/` directory

4. Compare results across different configurations

Important Notes