DDD4j Project Creator

When to use this skill

CRITICAL: This skill should ONLY be triggered when the user explicitly mentions creating a ddd4j project, initializing ddd4j project, or setting up ddd4j-boot project.

ALWAYS use this skill when the user mentions:

Creating a ddd4j project (explicitly mentions "ddd4j")
Initializing ddd4j-boot project
Setting up ddd4j project structure
Creating ddd4j project scaffolding
创建 ddd4j 项目 (explicitly mentions "ddd4j")
初始化 ddd4j 项目 (initialize ddd4j project)
ddd4j-boot 项目创建 (create ddd4j-boot project)

Trigger phrases include:

"创建 ddd4j 项目" (create ddd4j project) - must include "ddd4j"
"初始化 ddd4j 项目" (initialize ddd4j project) - must include "ddd4j"
"创建 ddd4j-boot 项目" (create ddd4j-boot project) - must include "ddd4j"
"使用 ddd4j 创建项目" (create project using ddd4j)
"ddd4j 项目脚手架" (ddd4j project scaffolding)

DO NOT trigger this skill for:

Generic DDD projects without mentioning ddd4j
JPA/Hibernate projects
Other ORM frameworks
Generic project initialization without ddd4j context
"创建 DDD 项目" without "ddd4j" (too generic)
"初始化项目" without "ddd4j" (too generic)

About DDD4j Boot

DDD4j Boot is a Java microservice development scaffold based on Domain-Driven Design (DDD) principles. It is built with Spring Boot 3.5.x and uses lightweight ddd-4-java and cqrs-4-java libraries to implement Domain-Driven Design, Command Query Responsibility Segregation (CQRS), and Event Sourcing.

Core Design Principles

Domain-Driven Design (DDD): Strategic design through bounded contexts, tactical design with entities, value objects, aggregates, domain services, repositories, and domain events
Command Query Responsibility Segregation (CQRS): Separation of read and write models, independent optimization
Event Sourcing: State changes recorded as event sequences, supporting complete history and state reconstruction
Diamond Architecture (COLA): Adapter → Application → Domain ← Infrastructure four-layer architecture

Key Features

Complete DDD layered architecture supporting COLA V5 pattern
Lightweight DDD implementation based on ddd-4-java and cqrs-4-java
Technology stack integration: Spring Boot 3.5.x, MyBatis Plus, Jackson, Guava, Swagger, SaToken
Dual stack support: WebMVC (traditional Servlet) and WebFlux (reactive)
Domain model base capabilities: BaseEntity, BaseRepository, BaseService
Domain event support with built-in event publishing mechanism
Anti-Corruption Layer (ACL) for external service integration
Unified exception handling mechanism

Project Types Supported

1. Single-Module Monolith (单体单模块)

适用场景: 中小型应用，单个业务领域，团队规模 5-15 人

特点:

单一 Maven 模块
所有层（interfaces, application, domain, infrastructure）在同一模块内
适合快速开发和部署

2. Multi-Module Monolith (单体多模块)

适用场景: 中大型应用，多个业务域，团队规模 15-50 人

特点:

多个 Maven 模块，按业务域划分
每个业务域包含完整的 DDD 四层架构
共享 common 模块
统一 BOM 和依赖管理

3. Microservices (单体微服务)

适用场景: 大型电商平台，多个业务域，团队规模 50+ 人

特点:

每个服务独立部署
服务间通过 RPC 和消息队列通信
每个服务内部按 DDD 四层架构组织
独立的数据库和配置

How to use this skill

CRITICAL: This skill should ONLY be triggered when the user explicitly mentions creating a ddd4j project. Do NOT trigger for generic DDD project creation requests without ddd4j context.

For New DDD4j Project Creation

Identify the project type from user requirements:
- Single-module monolith → single-module
- Multi-module monolith → multi-module
- Microservices → microservices
Load the appropriate example from the examples/ directory:
- examples/single-module.md - Single-module monolith structure
- examples/multi-module.md - Multi-module monolith structure
- examples/microservices.md - Microservices structure
- examples/architecture-patterns.md - DDD, Hexagonal, Clean, COLA V5 patterns
Collect project information:
- groupId: Maven group ID (e.g., com.github.hiwepy or io.ddd4j.base)
- artifactId: Maven artifact ID (e.g., ddd4j-douyin or my-ddd4j-service)
- version: Project version (e.g., 1.0.0-SNAPSHOT)
- parentVersion: Parent POM version (e.g., 2023.0.x.20251205-SNAPSHOT or reference to ddd4j-boot-parent)
- packageBase: Base package name (e.g., io.ddd4j.douyin or com.example.service)
- modules: List of business modules (for multi-module/microservices)
- architecture: Architecture pattern (DDD Classic, Hexagonal, Clean, COLA V5)
- ddd4jBootVersion: DDD4j Boot version (if using ddd4j-boot-bom)
Generate project structure:
- Create directory structure based on selected type
- Generate pom.xml files (parent and modules)
- Create package-info.java files for each module
- Generate .gitignore, LICENSE, mvnw, mvnw.cmd
- Create basic directory structure with src/main/java and src/test/java
Save to project directory:
- Default location: Save directly to the command execution directory (same level as the command)
- Directory creation: Automatically create the project directory structure if it doesn't exist
- File naming: Use descriptive names based on project type and module names

For Existing Project Validation

Analyze project structure:
- Scan project directory for Maven modules
- Identify layer structure (interfaces, application, domain, infrastructure)
- Check package naming conventions
- Verify directory organization
Identify project type:
- Single-module: Single pom.xml at root, all layers in one module
- Multi-module: Parent pom.xml with multiple modules, each module has complete layers
- Microservices: Multiple services, each with independent structure
Validate against standards:
- Check DDD layer compliance
- Verify dependency direction (interfaces → application → domain ← infrastructure)
- Validate package naming ({basePackage}.{module}.{layer})
- Check for required directories (src/main/java, src/test/java)
- Verify package-info.java files exist
Generate validation report:
- List identified issues
- Provide recommendations
- Suggest fixes for non-compliant structures

Output Format and File Saving

When generating a project structure, follow this response structure:

Save the files first: Create the project structure directly in the command execution directory
- The project will be created at the same level as where the command is executed
- Generate all required files and directories (pom.xml, src/, etc.)
- Use the artifactId as the project root directory name
Inform the user: Tell them where the files were saved
Display the structure: Show the generated directory structure in a code block

Example Response Structure:

First line: "I've created the DDD project structure and saved it to ./{artifactId}/ in the current directory."
Then show the structure wrapped in a code block:
- Start with: three backticks + text + newline
- Then the directory structure
- End with: three backticks + newline

Critical Requirements:

Always save project files directly to the command execution directory (same level)
Use artifactId as the project root directory name
Create the directory structure automatically if it doesn't exist
Generate complete project structure with all required files
Follow Maven and DDD conventions strictly

Project Structure Standards

Package Naming Convention

For multi-module projects:

{basePackage}.{moduleName}.{layerName}

Examples:

io.ddd4j.douyin.api.domain - API module, domain layer
io.ddd4j.douyin.api.application - API module, application layer
io.ddd4j.douyin.api.interfaces - API module, interfaces layer
io.ddd4j.douyin.api.infrastructure - API module, infrastructure layer

Required Files

Every module must have:

pom.xml - Maven configuration
src/main/java/{package}/package-info.java - Package documentation
src/test/java/ - Test directory structure
.gitignore - Git ignore rules (at root)
LICENSE - License file (at root)
mvnw, mvnw.cmd - Maven wrapper (at root)

Layer Dependencies

Correct dependency direction:

interfaces → application → domain ← infrastructure

Rules:

Domain layer must not depend on any other layer
Infrastructure layer implements domain layer interfaces
Application layer depends on domain layer
Interfaces layer depends on application layer

Architecture Patterns

The skill supports four architecture patterns:

DDD Classic Layered Architecture (DDD 经典分层架构)
- Layers: interfaces, application, domain, infrastructure
- Reference: docs/1、DDD 经典分层架构目录结构.md and examples/architecture-patterns.md#ddd-classic
Hexagonal Architecture (六边形架构)
- Ports and Adapters pattern
- Reference: docs/2、六边形架构详细目录结构参考.md and examples/architecture-patterns.md#hexagonal
Clean Architecture (整洁架构)
- Entities, Use Cases, Interface Adapters
- Reference: docs/3、整洁架构详细目录结构参考.md and examples/architecture-patterns.md#clean
COLA V5 (菱形架构)
- Adapter → App → Domain ← Infrastructure
- Reference: docs/4、COLA V5 架构详细目录结构参考.md and examples/architecture-patterns.md#cola-v5

Validation Rules

When checking existing projects, validate:

Structure Compliance:
- ✓ Correct layer organization
- ✓ Proper module separation
- ✓ Package naming conventions
Dependency Rules:
- ✓ Domain layer has no external dependencies
- ✓ Infrastructure implements domain interfaces
- ✓ Correct dependency direction
File Organization:
- ✓ Required directories exist
- ✓ package-info.java files present
- ✓ Maven configuration correct
Naming Conventions:
- ✓ Package names follow convention
- ✓ Module names are descriptive
- ✓ Layer names are standard

Examples

See the examples/ directory for:

single-module.md - Complete single-module monolith example
multi-module.md - Complete multi-module monolith example (based on ddd4j-douyin structure)
microservices.md - Complete microservices example
architecture-patterns.md - All four architecture patterns with detailed structures

Keywords

English keywords: ddd4j, ddd4j-boot, ddd4j project, create ddd4j project, initialize ddd4j project, ddd4j project creator, ddd4j project scaffolding, ddd4j-boot project, ddd4j project structure, ddd4j-boot initialization, ddd4j microservice, ddd4j monolith

Chinese keywords (中文关键词): ddd4j, ddd4j-boot, ddd4j 项目, 创建 ddd4j 项目, 初始化 ddd4j 项目, ddd4j 项目创建, ddd4j 项目脚手架, ddd4j-boot 项目, ddd4j 项目结构, ddd4j-boot 初始化, ddd4j 微服务, ddd4j 单体应用

IMPORTANT: All keywords must include "ddd4j" to avoid false triggers. Generic terms like "DDD 项目" (DDD project) or "创建项目" (create project) without "ddd4j" should NOT trigger this skill.

ddd4j-project-creator