ddd4j-project-creator: Скилл для создания проектов

--- name: ddd4j-project-creator description: "A comprehensive skill for creating new ddd4j (Domain-Driven Design for Java) projects based on ddd4j-boot framework. Use ONLY when the user explicitly mentions creating a ddd4j project, initializing ddd4j project, or setting up ddd4j-boot project. Supports three project types: single-module monolith, multi-module monolith, and microservices." license: Complete terms in LICENSE.txt --- # 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](https://github.com/fuinorg/ddd-4-java) and [cqrs-4-java](https://github.com/fuinorg/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 1. **Identify the project type** from user requirements: - Single-module monolith → `single-module` - Multi-module monolith → `multi-module` - Microservices → `microservices` 2. **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 3. **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) 4. **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` 5. **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 1. **Analyze project structure**: - Scan project directory for Maven modules - Identify layer structure (interfaces, application, domain, infrastructure) - Check package naming conventions - Verify directory organization 2. **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 3. **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 4. **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: 1. **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 2. **Inform the user**: Tell them where the files were saved 3. **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: 1. **DDD Classic Layered Architecture** (DDD 经典分层架构) - Layers: interfaces, application, domain, infrastructure - Reference: `docs/1、DDD 经典分层架构目录结构.md` and `examples/architecture-patterns.md#ddd-classic` 2. **Hexagonal Architecture** (六边形架构) - Ports and Adapters pattern - Reference: `docs/2、六边形架构详细目录结构参考.md` and `examples/architecture-patterns.md#hexagonal` 3. **Clean Architecture** (整洁架构) - Entities, Use Cases, Interface Adapters - Reference: `docs/3、整洁架构详细目录结构参考.md` and `examples/architecture-patterns.md#clean` 4. **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: 1. **Structure Compliance**: - ✓ Correct layer organization - ✓ Proper module separation - ✓ Package naming conventions 2. **Dependency Rules**: - ✓ Domain layer has no external dependencies - ✓ Infrastructure implements domain interfaces - ✓ Correct dependency direction 3. **File Organization**: - ✓ Required directories exist - ✓ `package-info.java` files present - ✓ Maven configuration correct 4. **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.