#  SpringIntegrationExample

**Repository Path**: yangshangwei/si

## Basic Information

- **Project Name**:  SpringIntegrationExample
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-09-29
- **Last Updated**: 2025-09-29

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 🚀 Spring Integration 企业级多业务通道实战平台

[![Spring Boot](https://img.shields.io/badge/Spring%20Boot-3.5.6-brightgreen.svg)](https://spring.io/projects/spring-boot)
[![Spring Integration](https://img.shields.io/badge/Spring%20Integration-6.5.2-blue.svg)](https://spring.io/projects/spring-integration)
[![Java](https://img.shields.io/badge/Java-17-orange.svg)](https://www.oracle.com/java/)
[![Maven](https://img.shields.io/badge/Maven-3.6%2B-red.svg)](https://maven.apache.org/)
[![H2 Database](https://img.shields.io/badge/H2%20Database-2.2.224-lightblue.svg)](https://www.h2database.com/)
[![Hibernate](https://img.shields.io/badge/Hibernate-6.6.29-yellow.svg)](https://hibernate.org/)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)

> **企业级消息集成平台示例** - 基于 Spring Integration 构建的多业务通道处理系统，展示现代企业应用中的消息驱动架构和集成模式实践。

## 🎯 项目定位

### 核心价值
本项目是一个**生产级的 Spring Integration 学习和实践平台**，专注于：

- **🏢 企业集成架构** - 演示真实企业环境中的系统集成需求
- **🔄 消息驱动设计** - 基于事件和消息的异步处理模式
- **🧩 模块化业务流程** - 可独立部署和扩展的业务通道设计
- **📈 可扩展性架构** - 支持水平扩展的微服务友好设计

### 业务场景模拟

本项目模拟了一个**电商平台的核心业务系统**，包含：

#### 🛒 订单管理业务流程
- **业务背景**: 电商平台的订单处理核心流程
- **处理流程**: 订单验证 → 数据标准化 → 业务处理 → 数据持久化
- **业务规则**: 
  - 订单数量必须大于 0
  - 产品名称自动清理（去除多余空格）
  - 支持订单数据的完整性验证
- **扩展场景**: 库存检查、价格计算、支付集成

#### 👥 用户注册业务流程  
- **业务背景**: 平台用户账户管理系统
- **处理流程**: 数据验证 → 格式标准化 → 重复性检查 → 账户创建
- **业务规则**:
  - 邮箱格式验证和唯一性检查
  - 用户名重复性验证
  - 数据自动标准化（邮箱转小写、去除空格）
- **扩展场景**: 邮箱验证、密码加密、权限分配

### 技术亮点

- **🎭 企业集成模式 (EIP) 实现** - Filter, Transformer, Router, ServiceActivator
- **🔗 多通道并行处理** - 独立的业务流程互不干扰
- **⚡ 响应式架构设计** - 支持高并发和异步处理
- **🛡️ 完善的错误处理** - 消息丢弃、异常处理、重试机制
- **📊 实时监控能力** - 集成日志、性能指标、健康检查

## 🏗️ 架构设计

### 系统架构图

```mermaid
graph TB
    subgraph "HTTP Layer 接口层"
        OC[OrderController<br>/orders]
        UC[UserController<br>/users]
    end
    
    subgraph "Order Processing Channel 订单处理通道"
        OIC[inputChannel]
        OF[orderFilter<br>数量验证]
        OT[orderTransformer<br>数据清理]
        OSA[orderServiceActivator<br>业务处理]
        OS[OrderService]
        ORDERS[(orders 表)]
    end
    
    subgraph "User Registration Channel 用户注册通道"
        UIC[userInputChannel]
        UF[userEmailValidationFilter<br>邮箱验证]
        UT[userDataTransformer<br>数据标准化]
        USA[userServiceActivator<br>注册处理]
        US[UserService]
        USERS[(users 表)]
    end
    
    subgraph "Database Layer 数据层"
        H2[(H2 Database)]
        ORDERS -.-> H2
        USERS -.-> H2
    end
    
    OC --> OIC
    UC --> UIC
    
    OIC --> OF
    OF -->|通过| OT
    OT --> OSA
    OSA --> OS
    OS --> ORDERS
    
    UIC --> UF
    UF -->|通过| UT
    UT --> USA
    USA --> US
    US --> USERS
```

### 🛠️ 技术架构栈

#### 核心框架层
| 技术组件 | 版本 | 作用描述 | 关键特性 |
|---------|------|---------|---------|
| **Spring Boot** | 3.5.6 | 应用框架和自动配置 | 零配置启动、内嵌服务器、生产就绪 |
| **Spring Integration** | 6.5.2 | 企业集成模式实现 | 消息驱动、通道管理、EIP 模式 |
| **Spring Web MVC** | 6.2.11 | RESTful API 框架 | 注解驱动、JSON 序列化、异常处理 |

#### 数据持久化层
| 技术组件 | 版本 | 作用描述 | 关键特性 |
|---------|------|---------|---------|
| **Spring Data JPA** | 3.5.4 | 数据访问抽象层 | Repository 模式、查询方法生成 |
| **Hibernate ORM** | 6.6.29 | 对象关系映射 | 实体管理、懒加载、缓存机制 |
| **H2 Database** | 2.2.224 | 内存关系数据库 | 零配置、内嵌模式、Web 控制台 |
| **HikariCP** | 5.1.0 | 数据库连接池 | 高性能、轻量级、快速连接 |

#### 消息处理层
| 技术组件 | 版本 | 作用描述 | 关键特性 |
|---------|------|---------|---------|
| **Jackson** | 2.18.2 | JSON 序列化/反序列化 | 高性能、注解支持、类型安全 |
| **SLF4J + Logback** | 2.0.16 | 日志管理框架 | 结构化日志、性能监控、异步日志 |

#### 开发工具链
| 技术组件 | 版本 | 作用描述 | 关键特性 |
|---------|------|---------|---------|
| **Maven** | 3.6+ | 项目构建和依赖管理 | 生命周期管理、插件生态 |
| **Java** | 17 LTS | 编程语言平台 | 模块化、性能优化、长期支持 |

#### 架构模式和设计原则

##### 🎭 企业集成模式 (EIP) 实现
```java
// 消息通道模式
DirectChannel → QueueChannel → PublishSubscribeChannel

// 消息端点模式  
ServiceActivator → MessageTransformer → MessageFilter

// 消息路由模式
ContentBasedRouter → RecipientListRouter
```

##### 🏗️ 分层架构设计
```
┌─────────────────────────────────────────┐
│           HTTP API Layer               │ ← REST Controllers
├─────────────────────────────────────────┤
│         Integration Layer              │ ← Spring Integration
├─────────────────────────────────────────┤
│          Service Layer                 │ ← Business Logic
├─────────────────────────────────────────┤
│         Repository Layer               │ ← Data Access
├─────────────────────────────────────────┤
│          Database Layer                │ ← H2 Database
└─────────────────────────────────────────┘
```

##### 🔄 消息驱动架构
```mermaid
graph LR
    A[HTTP Request] --> B[Message Channel]
    B --> C[Message Filter]
    C --> D[Message Transformer]
    D --> E[Service Activator]
    E --> F[Database]
    
    C -.-> G[Discard Channel]
    E -.-> H[Error Channel]
```

## 🚀 快速开始

### 环境要求

- **Java 17+** (推荐 OpenJDK 17 或 21)
- **Maven 3.6+**
- **端口 8080** 可用

### 1. 克隆和构建

```bash
# 克隆项目
git clone <repository-url>
cd spring-integration-demo

# 编译项目
mvn clean package
```

### 2. 运行应用

```bash
# 方式一：使用 Maven
mvn spring-boot:run

# 方式二：使用 JAR
java -jar target/si-0.0.1-SNAPSHOT.jar
```

### 3. 验证启动

访问健康检查端点确认应用正常启动：

```bash
curl http://localhost:8080/orders/health
curl http://localhost:8080/users/health
```

## 📡 API 接口文档

### 🛒 订单处理接口

#### 创建订单（Spring Integration 流程）
```bash
POST http://localhost:8080/orders
Content-Type: application/json

{
  "product": "iPhone 15 Pro",
  "quantity": 2
}
```

**响应示例：**
```json
{
  "success": true,
  "message": "订单已成功提交处理: iPhone 15 Pro",
  "order": {
    "id": null,
    "product": "iPhone 15 Pro",
    "quantity": 2
  }
}
```

#### 直接创建订单（绕过集成流程）
```bash
POST http://localhost:8080/orders/direct
Content-Type: application/json

{
  "product": "MacBook Pro",
  "quantity": 1
}
```

#### 获取订单服务状态
```bash
GET http://localhost:8080/orders/status
```

### 👤 用户注册接口

#### 用户注册（Spring Integration 流程）
```bash
POST http://localhost:8080/users
Content-Type: application/json

{
  "email": "john.doe@example.com",
  "username": "johndoe",
  "fullName": "John Doe",
  "phone": "13800138000"
}
```

**响应示例：**
```json
{
  "success": true,
  "message": "用户注册请求已成功提交处理: john.doe@example.com",
  "user": {
    "id": null,
    "email": "john.doe@example.com",
    "username": "johndoe",
    "fullName": "John Doe",
    "phone": "13800138000"
  }
}
```

#### 直接用户注册（绕过集成流程）
```bash
POST http://localhost:8080/users/direct
Content-Type: application/json

{
  "email": "jane.smith@example.com",
  "username": "janesmith",
  "fullName": "Jane Smith"
}
```

#### 获取用户服务状态
```bash
GET http://localhost:8080/users/status
```

### 🔍 系统监控接口

```bash
# 健康检查
GET http://localhost:8080/orders/health
GET http://localhost:8080/users/health

# H2 数据库控制台
GET http://localhost:8080/h2-console
```

## 🗄️ 数据库管理

### H2 控制台访问

1. 打开浏览器访问：http://localhost:8080/h2-console
2. 使用以下连接信息：
   - **JDBC URL**: `jdbc:h2:mem:testdb`
   - **用户名**: `sa`
   - **密码**: （留空）

### 数据库表结构

#### orders 表
```sql
CREATE TABLE orders (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    product VARCHAR(255) NOT NULL,
    quantity INTEGER NOT NULL
);
```

#### users 表
```sql
CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE,
    username VARCHAR(255) NOT NULL,
    full_name VARCHAR(255) NOT NULL,
    phone VARCHAR(255)
);
```

### 常用查询语句

```sql
-- 查看所有订单
SELECT * FROM orders ORDER BY id;

-- 查看所有用户
SELECT * FROM users ORDER BY id;

-- 统计订单数量
SELECT COUNT(*) as order_count FROM orders;

-- 统计用户数量
SELECT COUNT(*) as user_count FROM users;
```

## 🧪 测试指南

### 功能测试示例

#### 1. 测试订单处理流程

```bash
# 有效订单（应该成功）
curl -X POST http://localhost:8080/orders \
  -H "Content-Type: application/json" \
  -d '{"product":"测试产品","quantity":3}'

# 无效订单（应该被拒绝）
curl -X POST http://localhost:8080/orders \
  -H "Content-Type: application/json" \
  -d '{"product":"无效产品","quantity":0}'

# 测试产品名称清理
curl -X POST http://localhost:8080/orders \
  -H "Content-Type: application/json" \
  -d '{"product":"  MacBook Pro  ","quantity":1}'
```

#### 2. 测试用户注册流程

```bash
# 正常用户注册
curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test@example.com",
    "username": "testuser",
    "fullName": "Test User",
    "phone": "13800138000"
  }'

# 测试邮箱标准化
curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{
    "email": "  TEST.USER@EXAMPLE.COM  ",
    "username": "  testuser2  ",
    "fullName": "  Test User 2  "
  }'

# 无效邮箱格式（应该被拒绝）
curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{
    "email": "invalid-email",
    "username": "testuser3",
    "fullName": "Test User 3"
  }'
```

### 预期测试结果

| 测试场景 | 预期结果 |
|---------|---------|
| 有效订单提交 | ✅ 成功保存到数据库，返回成功响应 |
| 数量为0的订单 | ❌ 被过滤器拒绝，返回错误信息 |
| 产品名称包含空格 | ✅ Transformer 自动清理空格后保存 |
| 有效用户注册 | ✅ 成功保存到数据库，返回成功响应 |
| 邮箱大小写混合 | ✅ Transformer 转换为小写后保存 |
| 无效邮箱格式 | ❌ 被过滤器拒绝，返回错误信息 |

## 📁 项目结构和组件说明

### 🏗️ 整体项目结构
```
spring-integration-si/
├── 📄 pom.xml                                 # Maven 项目配置和依赖管理
├── 📄 README.md                               # 项目说明文档（本文件）
├── 📄 SPRING_INTEGRATION_GUIDE.md            # Spring Integration 技术实现指南
├── 📄 MULTI_BUSINESS_CHANNELS_GUIDE.md       # 多业务通道架构设计指南
├── 📄 PROJECT_SUCCESS_SUMMARY.md             # 项目实施成果总结报告
└── 📂 src/main/
   ├── 📂 java/com/artisan/si/                # Java 源代码目录
   │  ├── 🚀 SiApplication.java              # Spring Boot 主启动类
   │  ├── 📂 config/                          # 配置层
   │  │  └── ⚙️ IntegrationConfig.java        # Spring Integration 核心配置
   │  ├── 📂 controller/                      # Web 控制层 (REST API)
   │  │  ├── 🛒 OrderController.java          # 订单处理 REST API
   │  │  └── 👤 UserController.java           # 用户注册 REST API
   │  ├── 📂 service/                         # 业务逻辑层
   │  │  ├── 🔧 OrderService.java             # 订单业务逻辑处理
   │  │  └── 🔧 UserService.java              # 用户业务逻辑处理
   │  ├── 📂 repository/                      # 数据访问层
   │  │  ├── 💾 OrderRepository.java          # 订单数据访问接口
   │  │  └── 💾 UserRepository.java           # 用户数据访问接口
   │  └── 📂 model/                           # 数据模型层
   │     ├── 📦 Order.java                    # 订单实体类
   │     └── 👥 User.java                     # 用户实体类
   └── 📂 resources/
      └── ⚙️ application.yml                   # Spring Boot 应用配置
```

### 🎯 核心组件功能说明

#### 🔄 集成配置层 (`config/`)
- **IntegrationConfig.java** (232 行)
  - 定义两套完整的业务通道：订单处理通道 + 用户注册通道
  - 实现 Filter → Transformer → ServiceActivator 标准集成模式
  - 配置消息通道、错误处理通道、丢弃通道
  - 管理依赖注入和 Bean 生命周期

#### 🌐 API 控制层 (`controller/`)
- **OrderController.java** (134 行)
  - 提供订单处理的 RESTful API
  - 支持 Spring Integration 流程和直接处理两种模式
  - 实现健康检查、状态监控接口
  
- **UserController.java** (139 行)
  - 提供用户注册的 RESTful API
  - 支持集成流程和直接注册两种处理方式
  - 包含输入验证和错误处理机制

#### 🔧 业务逻辑层 (`service/`)
- **OrderService.java** (88 行)
  - 订单处理的核心业务逻辑
  - 实现订单验证、数据清理、持久化
  - 支持事务管理和异常处理
  
- **UserService.java**
  - 用户注册的核心业务逻辑
  - 实现邮箱验证、重复性检查、数据标准化
  - 支持用户数据的完整性验证

#### 💾 数据访问层 (`repository/`)
- **OrderRepository.java** (16 行)
  - 基于 Spring Data JPA 的订单数据访问
  - 自动生成 CRUD 操作方法
  
- **UserRepository.java**
  - 用户数据访问接口
  - 支持邮箱和用户名的唯一性查询

#### 📊 数据模型层 (`model/`)
- **Order.java** (71 行)
  - 订单实体类，映射 orders 表
  - 包含 id、product、quantity 字段
  - 支持 JPA 注解和数据验证
  
- **User.java**
  - 用户实体类，映射 users 表
  - 包含 id、email、username、fullName、phone 字段
  - 支持唯一性约束和数据验证

### 🏭 业务流程映射

#### 📦 订单处理业务流程
```
OrderController → inputChannel → orderFilter → orderTransformer → 
orderServiceActivator → OrderService → OrderRepository → Database
```

#### 👥 用户注册业务流程
```
UserController → userInputChannel → userEmailValidationFilter → 
userDataTransformer → userServiceActivator → UserService → UserRepository → Database
```

### 📈 项目规模统计

| 组件类型 | 文件数量 | 代码行数 | 主要功能 |
|---------|----------|----------|----------|
| 配置类 | 1 | 232 | Spring Integration 流程配置 |
| 控制器 | 2 | 273 | REST API 和 HTTP 处理 |
| 服务类 | 2 | ~150 | 核心业务逻辑 |
| 数据访问 | 2 | ~30 | 数据库操作接口 |
| 实体类 | 2 | ~120 | 数据模型定义 |
| 配置文件 | 1 | 28 | 应用参数配置 |
| **总计** | **10** | **~830** | **完整业务系统** |

## 🎯 核心技术特性

### 🏢 企业级架构特性

#### 🎭 企业集成模式 (EIP) 完整实现
```java
// 消息通道架构
┌─────────────┐    ┌──────────────┐    ┌─────────────────┐
│ HTTP Layer  │ -> │ Message      │ -> │ Processing      │
│ Controllers │    │ Channels     │    │ Components      │
└─────────────┘    └──────────────┘    └─────────────────┘
                            │
                   ┌─────────────────┐
                   │ Error Handling  │
                   │ & Monitoring    │
                   └─────────────────┘
```

| EIP 模式 | 实现组件 | 业务作用 | 技术优势 |
|---------|----------|---------|---------|
| **Message Channel** | `DirectChannel`, `QueueChannel` | 消息传输管道 | 解耦生产者和消费者 |
| **Message Filter** | `@Filter` 注解方法 | 业务规则验证 | 提前过滤无效数据 |
| **Message Transformer** | `@Transformer` 注解方法 | 数据格式转换 | 标准化数据处理 |
| **Service Activator** | `@ServiceActivator` 注解方法 | 业务逻辑调用 | 连接消息和业务服务 |
| **Error Channel** | `discardChannel`, `errorChannel` | 异常处理 | 容错和监控能力 |

#### 🏗️ 多业务通道并行架构

```mermaid
graph TB
    subgraph "业务隔离层"
        O1[订单通道] 
        U1[用户通道]
        P1[支付通道 - 可扩展]
        I1[库存通道 - 可扩展]
    end
    
    subgraph "共享基础设施层"
        DB[H2 Database]
        LOG[日志系统]
        MON[监控系统]
    end
    
    O1 --> DB
    U1 --> DB
    P1 -.-> DB
    I1 -.-> DB
    
    O1 --> LOG
    U1 --> LOG
    P1 -.-> LOG
    I1 -.-> LOG
```

**架构优势**:
- ✅ **业务隔离**: 订单处理故障不影响用户注册
- ✅ **独立扩展**: 每个通道可独立优化和扩容
- ✅ **资源复用**: 共享数据库连接池、日志系统
- ✅ **水平扩展**: 新增业务流程无需修改现有代码

### 💾 数据处理和持久化能力

#### 📊 多层数据验证体系
```java
HTTP Layer:    基础格式验证 (JSON 反序列化、必填字段)
Filter Layer:  业务规则验证 (数量 > 0、邮箱格式)
Service Layer: 业务逻辑验证 (重复性检查、数据完整性)
Database Layer: 约束验证 (唯一性、外键、数据类型)
```

#### 🔄 智能数据转换流程
```java
// 订单数据转换
"  iPhone 15 Pro  " -> 清理空格 -> "iPhone 15 Pro"

// 用户数据转换  
"  JOHN.DOE@EXAMPLE.COM  " -> 标准化 -> "john.doe@example.com"
```

#### 🗄️ 高性能数据持久化
- **连接池管理**: HikariCP 高性能连接池
- **事务管理**: Spring `@Transactional` 声明式事务
- **查询优化**: Spring Data JPA 智能查询生成
- **缓存机制**: Hibernate 二级缓存支持

### 🛡️ 生产级质量保证

#### 📈 监控和可观测性
```yaml
# 应用监控配置
logging:
  level:
    org.springframework.integration: DEBUG  # 集成流程日志
    org.hibernate.SQL: DEBUG              # SQL 执行日志
    root: INFO                            # 应用日志
```

**监控能力**:
- 🔍 **消息流跟踪**: 每个消息的完整处理路径
- 📊 **性能指标**: 处理时间、成功率、错误率
- 🚨 **异常监控**: 自动记录和分类异常
- 💾 **数据库监控**: SQL 执行时间和频率

#### 🔧 开发友好特性
- **零配置启动**: Spring Boot 自动配置
- **热重载支持**: DevTools 开发工具集成
- **API 文档**: 完整的 REST API 说明
- **测试支持**: 集成测试和单元测试框架

#### 🚀 生产部署就绪
- **内嵌服务器**: Tomcat 内嵌，无需外部部署
- **健康检查**: `/health` 端点监控应用状态
- **配置外化**: 支持环境变量和配置文件
- **容器化支持**: 支持 Docker 容器部署

## 🚀 扩展指南

### 添加新的业务流程

基于现有架构，您可以按照以下步骤添加新的业务流程：

#### 1. 创建实体类
```java
@Entity
@Table(name = "your_business")
public class YourBusiness {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 其他字段...
}
```

#### 2. 创建 Repository
```java
@Repository
public interface YourBusinessRepository extends JpaRepository<YourBusiness, Long> {
    // 自定义查询方法...
}
```

#### 3. 创建 Service
```java
@Service
public class YourBusinessService {
    public YourBusiness handleYourBusiness(YourBusiness business) {
        // 业务逻辑处理...
        return repository.save(business);
    }
}
```

#### 4. 扩展 IntegrationConfig
```java
// 添加新的通道
@Bean("yourBusinessInputChannel")
public MessageChannel yourBusinessInputChannel() { ... }

// 添加过滤器
@Filter(inputChannel = "yourBusinessInputChannel", ...)
public boolean yourBusinessFilter(YourBusiness business) { ... }

// 添加转换器  
@Transformer(inputChannel = "yourBusinessTransformChannel", ...)
public YourBusiness yourBusinessTransformer(YourBusiness business) { ... }

// 添加服务激活器
@ServiceActivator(inputChannel = "yourBusinessServiceChannel")
public void yourBusinessServiceActivator(YourBusiness business) { ... }
```

#### 5. 创建 Controller
```java
@RestController
@RequestMapping("/your-business")
public class YourBusinessController {
    @PostMapping
    public Map<String, Object> create(@RequestBody YourBusiness business) { ... }
}
```

### 推荐的扩展方向

1. **支付处理流程** - 支付验证、风控检查、支付执行
2. **库存管理流程** - 库存检查、预占、更新
3. **通知发送流程** - 邮件、短信、推送通知
4. **审批工作流** - 多级审批、状态流转
5. **数据同步流程** - 第三方系统数据同步

## 📚 相关文档

- [Spring Integration 详细指南](./SPRING_INTEGRATION_GUIDE.md) - 深入技术实现细节
- [多业务通道架构指南](./MULTI_BUSINESS_CHANNELS_GUIDE.md) - 架构设计和扩展方法
- [项目实现总结](./PROJECT_SUCCESS_SUMMARY.md) - 项目完成情况和成果

## 🤝 贡献指南

欢迎提交 Issue 和 Pull Request 来改进这个项目！

### 开发流程

1. Fork 本仓库
2. 创建特性分支 (`git checkout -b feature/amazing-feature`)
3. 提交更改 (`git commit -m 'Add some amazing feature'`)
4. 推送到分支 (`git push origin feature/amazing-feature`)
5. 开启 Pull Request

### 代码规范

- 遵循 Java 代码规范
- 添加适当的注释和文档
- 确保所有测试通过
- 保持代码简洁和可读性

## 📄 许可证

本项目采用 MIT 许可证 - 查看 [LICENSE](LICENSE) 文件了解详情。

## ❓ 常见问题

### Q: 应用启动失败怎么办？
A: 检查 Java 版本（需要 17+）和端口 8080 是否被占用。

### Q: 数据没有保存到数据库？
A: 检查 H2 控制台中的表结构，确认 JPA 配置正确。

### Q: Spring Integration 流程没有执行？
A: 查看应用日志，确认通道配置和消息发送是否正常。

### Q: 如何自定义数据库配置？
A: 修改 `application.yml` 中的数据源配置。

### Q: 如何添加更多的业务验证？
A: 在对应的 Filter 方法中添加业务规则验证逻辑。

## 📞 联系方式

如有问题或建议，欢迎通过以下方式联系：

- 📧 Email: [your-email@example.com]
- 🐛 Issues: [GitHub Issues](https://github.com/your-repo/issues)
- 💬 Discussions: [GitHub Discussions](https://github.com/your-repo/discussions)

---

⭐ 如果这个项目对您有帮助，请给个 Star 支持一下！