home / skills / mduongvandinh / skills-java-spring / spring-maven-modular

spring-maven-modular skill

safe

/java-spring-skills/skills/core/spring-maven-modular

This skill enables modular Maven builds for Spring projects by toggling components like Redis, Kafka, and RabbitMQ via profiles and properties.

npx playbooks add skill mduongvandinh/skills-java-spring --skill spring-maven-modular

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.6 KB

---
name: spring-maven-modular
version: 1.0.0
description: |
  Maven Modular Architecture with profiles for optional components.
  Enable/disable modules like Redis, Kafka, RabbitMQ dynamically.

triggers:
  - "maven"
  - "module"
  - "profile"
  - "dependency"
  - "optional"
---

# Maven Modular Architecture

## Module Flags

| Module | Default | Property |
|--------|---------|----------|
| PostgreSQL | ON | `module.postgresql.enabled` |
| Redis | OFF | `module.redis.enabled` |
| Kafka | OFF | `module.kafka.enabled` |
| RabbitMQ | OFF | `module.rabbitmq.enabled` |
| OAuth2 | OFF | `module.oauth2.enabled` |

## Usage

```bash
# Minimal (PostgreSQL only)
mvn clean install -Pminimal

# With Redis
mvn clean install -Dmodule.redis.enabled=true

# With Kafka
mvn clean install -Dmodule.kafka.enabled=true

# Full stack
mvn clean install -Pfull-stack

# Custom combination
mvn clean install -Dmodule.redis.enabled=true -Dmodule.kafka.enabled=true
```

## Profiles

### Minimal Profile
- PostgreSQL (always)
- JWT Authentication

### Full Stack Profile
- PostgreSQL
- Redis
- Kafka
- OAuth2

## Spring Configuration

Use `@ConditionalOnModuleEnabled` to conditionally load beans:

```java
@Configuration
@ConditionalOnModuleEnabled("redis")
public class RedisConfig {
    // Only loaded when modules.redis.enabled=true
}
```

## application.yml

```yaml
modules:
  postgresql:
    enabled: true
  redis:
    enabled: ${MODULE_REDIS_ENABLED:false}
  kafka:
    enabled: ${MODULE_KAFKA_ENABLED:false}
  rabbitmq:
    enabled: ${MODULE_RABBITMQ_ENABLED:false}
  oauth2:
    enabled: ${MODULE_OAUTH2_ENABLED:false}
```

Overview

This skill implements a Maven-based modular architecture for Spring Boot projects, letting you enable or disable optional components at build time. It provides profile presets (minimal, full-stack) and per-module flags for Redis, Kafka, RabbitMQ, OAuth2, and PostgreSQL. The goal is predictable builds and conditional bean loading to keep the runtime surface minimal and focused.

How this skill works

Modules are toggled via Maven profiles or system properties (e.g., -Dmodule.redis.enabled=true). The build includes or excludes module artifacts and resource wiring based on those flags. At runtime Spring beans use a @ConditionalOnModuleEnabled annotation to register only when the corresponding module flag is active. application.yml maps module flags to environment variables for containerized deployments.

When to use it

You need a single codebase that can produce lightweight and full-featured artifacts.
Building images for different environments (dev, staging, prod) with different service dependencies.
Testing integrations (Redis/Kafka/RabbitMQ) selectively without running all services.
Reducing attack surface and startup time by compiling out unused modules.
Creating CI pipelines that build multiple configurations from the same source.

Best practices

Keep PostgreSQL as the core data module and mark other services optional by default.
Use Maven profiles (minimal, full-stack) for common combinations and properties for one-off builds.
Document which beans are conditional so maintainers know where modules affect wiring.
Prefer environment-variable overrides in application.yml for container and cloud deployments.
Run integration tests with module flags enabled to validate conditional wiring and contracts.

Example use cases

Produce a minimal artifact for local development with only PostgreSQL and JWT auth using -Pminimal.
Build a full-stack image for staging with Redis, Kafka, and OAuth2 via -Pfull-stack.
Enable Redis and Kafka for a feature branch using -Dmodule.redis.enabled=true -Dmodule.kafka.enabled=true.
CI matrix that compiles artifacts for several combinations to detect integration regressions early.

FAQ

How do I conditionally load Spring beans for a module?

Annotate configuration classes with @ConditionalOnModuleEnabled("moduleName") so they only register when the corresponding module flag is true.

Can I control modules with environment variables?

Yes. application.yml reads module flags from environment variables (e.g., MODULE_REDIS_ENABLED) so you can control modules in containers and CI.