OpenClaw + Spring Boot 自动化实战：从零搭建 AI 驱动的智能后端

一、为什么是 OpenClaw + Spring Boot？

在 2026 年的 AI 工程化浪潮中，Agent 与业务系统的深度集成已经成为后端开发的核心能力。Spring Boot 作为 Java 生态最成熟的企业级框架，与 OpenClaw 这个强大的 AI Agent 运行时相结合，能够让我们：

将任意 Spring Bean 暴露为 AI 工具 — 无需额外 SDK
用自然语言操控业务逻辑 — CRUD、审批流、报表生成一句话完成
构建可审计、可回滚的自动化管线 — 每个 Agent 操作都有完整日志

本文将从零搭建一个「AI 驱动的订单管理系统」，完整演示 OpenClaw Agent 与 Spring Boot 的集成方案。

二、整体架构

┌─────────────────────────────────────────────┐
│                 用户交互层                     │
│   QQ Bot / Discord / Telegram / REST API     │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│            OpenClaw Agent Runtime             │
│   ┌──────────┐   ┌──────────┐   ┌────────┐  │
│   │ 路由引擎  │   │ 工具调度  │   │ 上下文  │  │
│   └──────────┘   └──────────┘   └────────┘  │
└──────────────────┬──────────────────────────┘
                   │ MCP / HTTP / WebSocket
┌──────────────────▼──────────────────────────┐
│         Spring Boot 业务服务层                │
│   ┌────────┐ ┌────────┐ ┌────────┐ ┌──────┐ │
│   │ 订单服务 │ │ 库存服务 │ │ 用户服务 │ │ 报表  │ │
│   └────────┘ └────────┘ └────────┘ └──────┘ │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│             数据层 (MySQL + Redis)            │
└─────────────────────────────────────────────┘

核心思路： Spring Boot 提供业务能力和 API，OpenClaw 提供 AI 编排和自然语言交互能力，两者通过 MCP (Model Context Protocol) 或 HTTP 协议通信。

三、Spring Boot 端：暴露业务能力

3.1 创建项目

使用 Spring Initializr 或直接克隆脚手架：

curl https://start.spring.io/starter.zip 
  -d dependencies=web,data-jpa,mysql,validation 
  -d artifactId=order-system 
  -d groupId=com.tmser 
  -d javaVersion=21 
  -o order-system.zip
unzip order-system.zip -d order-system
cd order-system

3.2 订单实体与 Repository

// Order.java
@Entity
@Table(name = "orders")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank
    private String customerName;

    @NotBlank
    private String productName;

    @Min(1)
    private Integer quantity;

    @Positive
    private BigDecimal unitPrice;

    @Enumerated(EnumType.STRING)
    private OrderStatus status = OrderStatus.PENDING;

    private LocalDateTime createdAt = LocalDateTime.now();
    private LocalDateTime updatedAt;
}

// OrderStatus.java
public enum OrderStatus {
    PENDING,       // 待处理
    CONFIRMED,     // 已确认
    SHIPPED,       // 已发货
    DELIVERED,     // 已送达
    CANCELLED      // 已取消
}

// OrderRepository.java
public interface OrderRepository extends JpaRepository<Order, Long> {
    List<Order> findByStatus(OrderStatus status);
    List<Order> findByCustomerNameContaining(String name);
    List<Order> findByCreatedAtBetween(LocalDateTime start, LocalDateTime end);
}

3.3 核心业务服务（将被 AI 调用）

这是关键部分：每个 public 方法都可以作为 AI 工具被调用。我们在方法上添加清晰的文档说明，帮助 LLM 理解用途。

// OrderService.java
@Service
@Slf4j
public class OrderService {

    private final OrderRepository orderRepository;

    /**
     * 创建新订单
     * @param customerName 客户姓名
     * @param productName  商品名称
     * @param quantity     数量
     * @param unitPrice    单价
     * @return 创建后的订单信息
     */
    @AiTool(description = "创建新订单，需要客户姓名、商品名称、数量和单价")
    public Order createOrder(String customerName, String productName,
                              int quantity, BigDecimal unitPrice) {
        Order order = new Order();
        order.setCustomerName(customerName);
        order.setProductName(productName);
        order.setQuantity(quantity);
        order.setUnitPrice(unitPrice);
        order.setStatus(OrderStatus.PENDING);
        Order saved = orderRepository.save(order);
        log.info("AI 创建订单: orderId={}, customer={}", saved.getId(), customerName);
        return saved;
    }

    /**
     * 查询订单列表，支持按状态筛选
     */
    @AiTool(description = "查询订单列表，可按状态筛选（PENDING/CONFIRMED/SHIPPED/DELIVERED/CANCELLED）")
    public List<Order> listOrders(@Nullable String status) {
        if (status == null || status.isBlank()) {
            return orderRepository.findAll();
        }
        return orderRepository.findByStatus(OrderStatus.valueOf(status.toUpperCase()));
    }

    /**
     * 更新订单状态
     */
    @AiTool(description = "更新订单状态，需要订单ID和目标状态")
    public Order updateOrderStatus(Long orderId, String newStatus) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new RuntimeException("订单不存在: " + orderId));
        order.setStatus(OrderStatus.valueOf(newStatus.toUpperCase()));
        order.setUpdatedAt(LocalDateTime.now());
        Order saved = orderRepository.save(order);
        log.info("AI 更新订单状态: orderId={}, status={}", orderId, newStatus);
        return saved;
    }

    /**
     * 生成指定时间段的订单报表
     */
    @AiTool(description = "生成订单报表，按日期范围统计")
    public OrderReport generateReport(String startDate, String endDate) {
        LocalDateTime start = LocalDate.parse(startDate).atStartOfDay();
        LocalDateTime end = LocalDate.parse(endDate).atTime(23, 59, 59);
        List<Order> orders = orderRepository.findByCreatedAtBetween(start, end invert);
        // 报表统计逻辑...
        return new OrderReport(orders);
    }
}

💡 @AiTool 注解 — 这是一个自定义注解，用于标记哪些方法可以暴露为 AI 工具。下文的 OpenClaw 端会自动扫描并注册。

3.4 自定义 @AiTool 注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AiTool {
    String description() default "";
    String[] parameters() default {};
}

3.5 REST API 层（可选）

虽然 OpenClaw 可以直接调用 Service，但保留 REST API 层可以：

提供传统 HTTP 集成方式
方便前台页面调用
作为 API 网关的统一入口

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderService orderService;

    @PostMapping
    public ResponseEntity<Order> create(@RequestBody CreateOrderRequest req) {
        return ResponseEntity.ok(orderService.createOrder(...));
    }

    @GetMapping
    public ResponseEntity<List<Order>> list(@RequestParam(required = false) String status) {
        return ResponseEntity.ok(orderService.listOrders(status));
    }

    @PutMapping("/{id}/status")
    public ResponseEntity<Order> updateStatus(@PathVariable Long id,
                                               @RequestBody StatusUpdateRequest req) {
        return ResponseEntity.ok(orderService.updateOrderStatus(id, req.status()));
    }
}

四、OpenClaw 端：接入 AI 能力

4.1 方案 A：通过 MCP Server 接入（推荐）

MCP（Model Context Protocol）是 OpenClaw 推荐的原生集成方式。Spring Boot 服务启动一个 MCP Server，OpenClaw 通过标准协议发现和调用工具。

在 Spring Boot 中集成 MCP Server SDK

<!-- pom.xml 添加依赖 -->
<dependency>
    <groupId>io.modelcontextprotocol</groupId>
    <artifactId>mcp-spring-boot-starter</artifactId>
    <version>0.7.1</version>
</dependency>

// MCP 配置
@Configuration
public class MCPConfig {

    @Bean
    public McpServer mcpServer(OrderService orderService) {
        return McpServer.builder()
            .name("order-system-server")
            .version("1.0.0")
            .tools(tools -> {
                // 扫描所有 @AiTool 注解的方法
                for (Method method : orderService.getClass().getMethods()) {
                    AiTool aiTool = method.getAnnotation(AiTool.class);
                    if (aiTool != null) {
                        tools.add(methodToTool(method, aiTool));
                    }
                }
            })
            .transport(new HttpServletTransport("/mcp"))
            .build();
    }

    private Tool methodToTool(Method method, AiTool aiTool) {
        // 将 Java 方法签名映射为 MCP Tool 定义
        return Tool.builder()
            .name(method.getName())
            .description(aiTool.description())
            .inputSchema(buildInputSchema(method))
            .handler(params -> {
                // 反射调用
                Object[] args = extractArgs(method, params);
                Object result = method.invoke(orderService, args);
                return new ToolResult(result);
            })
            .build();
    }
}

在 OpenClaw 中配置 MCP 连接

# openclaw.yml
mcpServers:
  order-system:
    url: "http://localhost:8080/mcp"
    description: "AI 驱动的订单管理系统"

完成！OpenClaw 启动时会自动从 MCP Server 获取工具列表，用户就可以通过自然语言操作订单了。

4.2 方案 B：通过 HTTP REST + Agent 工具文件

如果不想使用 MCP，也可以使用 OpenClaw 的静态工具定义：

// ~/.openclaw/workspace/tools/order-system.json
{
  "tools": [
    {
      "name": "create_order",
      "description": "创建新订单，参数：客户姓名(customerName)、商品名称(productName)、数量(quantity)、单价(unitPrice)",
      "command": "curl -X POST http://localhost:8080/api/orders -H 'Content-Type: application/json' -d '{"customerName":"${customerName}","productName":"${productName}","quantity":${quantity},"unitPrice":${unitPrice}}'"
    },
    {
      "name": "list_orders",
      "description": "查询订单列表，可按状态筛选，状态可选：PENDING/CONFIRMED/SHIPPED/DELIVERED/CANCELLED",
      "command": "curl 'http://localhost:8080/api/orders?status=${status}'"
    },
    {
      "name": "update_order_status",
      "description": "更新订单状态，需要订单ID(orderId)和状态(newStatus)",
      "command": "curl -X PUT http://localhost:8080/api/orders/${orderId}/status -H 'Content-Type: application/json' -d '{"status":"${newStatus}"}'"
    }
  ]
}

方案 A 更自动化，方案 B 更轻量。推荐生产环境用方案 A。

五、实战场景演示

场景 1：一句话创建订单

用户说： “帮我下个订单，张三要买 3 个 iPhone，单价 6999”

OpenClaw Agent 执行流程：

解析意图 → createOrder 工具
自动调用 MCP → POST /api/orders
返回结果给用户

AI 回复：

✅ 订单创建成功！

订单号：#1042

客户：张三

商品：iPhone × 3

总金额：¥20,997

状态：⏳ 待处理

场景 2：批量更新与报表

用户说： “查看所有待处理的订单，然后把 7 天前的全部取消”

AI 操作链：

调用 listOrders(PENDING) → 获取待处理列表
逐条检查创建时间 → createdAt < now - 7天
符合条件的调用 updateOrderStatus(id, CANCELLED)
生成汇总报告

AI 回复：

共发现 12 笔待处理订单，其中 5 笔已超过 7 天未处理：

#1010 — 李四 × 鼠标垫 (2026-05-08) ✅ 已取消

#1011 — 王五 × 键盘 (2026-05-09) ✅ 已取消

…

已全部取消，释放库存共计 ¥3,240。需要我通知客户吗？

场景 3：主动监控与预警

通过定时任务（cron）配置 OpenClaw 定期检查：

# openclaw.yml 中的 cron 配置
cron:
  - schedule: "0 9 * * *"
    task: "检查是否有超过 3 天未处理的订单，提醒我并询问是否需要处理"

每天早上 9 点，Agent 自动检查 → 发现积压 → 推送通知。这就是 AI 驱动的自动化运维。

六、企业级增强方案

6.1 安全审计

所有 AI 调用自动记录：

@Component
@Aspect
public class AiAuditAspect {
    @Around("@annotation(com.tmser.annotation.AiTool)")
    public Object audit(ProceedingJoinPoint pjp) throws Throwable {
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();
        // 记录调用日志
        auditLogService.log(
            AuditEvent.builder()
                .action(methodName)
                .parameters(args)
                .timestamp(Instant.now())
                .build()
        );
        return pjp.proceed();
    }
}

6.2 权限控制

为不同角色的 AI 访问设置不同权限：

@AiTool(description = "取消订单", requiredRole = "ADMIN")
public Order cancelOrder(Long orderId, String reason) {
    // 只有管理员角色的 AI 会话可以调用
}

6.3 幂等性与重试

AI 可能重复调用，关键操作需要幂等：

@AiTool(description = "确认订单（幂等安全）")
public Order confirmOrder(Long orderId) {
    return orderRepository.findById(orderId)
        .map(order -> {
            if (order.getStatus() == OrderStatus.CONFIRMED) {
                return order;  // 幂等：已确认则直接返回
            }
            if (order.getStatus() != OrderStatus.PENDING) {
                throw new IllegalStateException("只有待处理订单可以确认");
            }
            order.setStatus(OrderStatus.CONFIRMED);
            order.setUpdatedAt(LocalDateTime.now());
            return orderRepository.save(order);
        })
        .orElseThrow(() -> new RuntimeException("订单不存在"));
}

6.4 多通道集成

OpenClaw 天然支持多通道：

QQ Bot → OpenClaw → MCP → Spring Boot
Discord → OpenClaw → MCP → Spring Boot
微信 → OpenClaw → MCP → Spring Boot
Telegram → OpenClaw → MCP → Spring Boot

一次开发，全渠道覆盖。

七、部署与运维

7.1 Docker Compose 一键部署

version: '3.8'
services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: order_system
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
    volumes:
      - mysql-data:/var/lib/mysql

  redis:
    image: redis:7-alpine

  order-service:
    build: ./order-system
    ports:
      - "8080:8080"
    depends_on: [mysql, redis]
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/order_system
      SPRING_DATA_REDIS_HOST: redis

  openclaw-agent:
    image: openclaw/openclaw:latest
    volumes:
      - ./openclaw.yml:/app/config/openclaw.yml
    ports:
      - "3000:3000"
    depends_on: [order-service]

volumes:
  mysql-data:

7.2 启动顺序

# 1. 启动基础设施 + 业务服务
docker compose up -d mysql redis order-service

# 2. 验证 MCP 端点
curl http://localhost:8080/mcp/tools

# 3. 启动 OpenClaw
docker compose up -d openclaw-agent

八、总结与延伸

本文已实现

✅ Spring Boot 项目搭建与 @AiTool 工具定义
✅ 两种集成方案：MCP Server（推荐）& HTTP REST
✅ 完整实战场景：创建订单、批量处理、定时监控
✅ 企业级增强：审计、权限、幂等、多通道

延伸方向

多 Agent 协作 — 订单 Agent + 库存 Agent + 物流 Agent 协同工作
RAG 知识库 — 结合向量数据库让 AI 理解企业 SOP
审批流集成 — 高风险操作需人工确认后再执行
事件驱动 — Spring Boot 事件 → MQ → OpenClaw 消费

思考题

你的系统中，哪些操作适合交给 AI 自主执行？哪些需要人工审批？欢迎在评论区分享你的场景。

本文使用的 OpenClaw 版本：2026.5.7 | Spring Boot 3.4+ | Java 21

工具仓库：https://github.com/tmser/order-system-ai-demo（示例项目）

📌 下期预告： 《Java 并发原理与性能优化 —— 从 JMM 到虚拟线程的深度解析》

OpenClaw + Spring Boot 自动化实战：从零搭建 AI 驱动的智能后端

一、为什么是 OpenClaw + Spring Boot？

二、整体架构

三、Spring Boot 端：暴露业务能力

3.1 创建项目

3.2 订单实体与 Repository

3.3 核心业务服务（将被 AI 调用）

3.4 自定义 @AiTool 注解

3.5 REST API 层（可选）

四、OpenClaw 端：接入 AI 能力

4.1 方案 A：通过 MCP Server 接入（推荐）

在 Spring Boot 中集成 MCP Server SDK

在 OpenClaw 中配置 MCP 连接

4.2 方案 B：通过 HTTP REST + Agent 工具文件

五、实战场景演示

场景 1：一句话创建订单

场景 2：批量更新与报表

场景 3：主动监控与预警

六、企业级增强方案

6.1 安全审计

6.2 权限控制

6.3 幂等性与重试

6.4 多通道集成

七、部署与运维

7.1 Docker Compose 一键部署

7.2 启动顺序

八、总结与延伸

本文已实现

延伸方向

思考题

更多文章

OpenClaw + Spring Boot 自动化实战：从零搭建 AI 驱动的智能后端

后软件时代即将到来，开发人员何去何从

MCP 服务器开发与企业集成：从零构建生产级 AI 工具网关

MCP 服务器开发与企业集成实战指南