苍穹外卖实战：Spring Task 定时任务与 WebSocket 实时通信

核心注解与属性

@Scheduled 常用参数

组合使用示例

// 启动后延迟 10 秒，然后每 5 秒执行一次
@Scheduled(initialDelay = 10000, fixedRate = 5000)
public void delayedTask() {
    System.out.println("延迟启动的定时任务");
}

Cron 表达式详解

语法格式

文本

秒 分 时 日 月 周 [年]

常用示例

// 每天凌晨 2 点执行
@Scheduled(cron = "0 0 2 * * ?")

// 每 10 分钟执行一次
@Scheduled(cron = "0 */10 * * * ?")

// 工作日上午 9 点执行
@Scheduled(cron = "0 0 9 * * MON-FRI")

// 每月最后一天 23:59:59 执行
@Scheduled(cron = "59 59 23 L * ?")

// 每周一至周五 9-17 点，每隔 30 分钟执行
@Scheduled(cron = "0 0/30 9-17 * * MON-FRI")

配置线程池（重要）

默认情况下，Spring Task 使用单线程执行所有定时任务。如果某个任务执行时间过长，会阻塞其他任务。

配置异步线程池

@Configuration
@EnableScheduling
public class SchedulingConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
    }
}

或通过配置文件（Spring Boot）：

spring:
  task:
    scheduling:
      pool:
        size: 10 # 线程池大小
      thread-name-prefix: my-scheduler- # 线程名称前缀

最佳实践

1. 避免长时间任务阻塞

@Scheduled(cron = "0/10 * * * * ?")
public void longRunningTask() {
    // 异步执行耗时操作，避免阻塞调度线程
    CompletableFuture.runAsync(() -> {
        // 耗时业务逻辑
    });
}

2. 异常处理

定时任务中的异常不会打印到控制台，建议统一处理：

@Scheduled(cron = "0/30 * * * * ?")
public void robustTask() {
    try {
        // 业务逻辑
    } catch (Exception e) {
        logger.error("定时任务执行失败", e);
        // 可选：发送告警通知
    }
}

3. 动态配置 cron 表达式

通过配置文件动态修改定时时间：

@Component
public class DynamicTask {
    @Value("${task.cron:0 0 2 * * ?}")
    private String cron;

    @Scheduled(cron = "${task.cron:0 0 2 * * ?}")
    public void dynamicTask() {
        // 业务逻辑
    }
}

Spring Task vs Quartz

Spring Task 是 Spring 生态中最便捷的定时任务解决方案，适合 80% 的常规定时任务场景。对于需要集群部署、任务持久化、动态管理等高级特性的场景，建议考虑 Quartz 或 XXL-JOB 等专业调度框架。

快速记忆：

1. 启动类加 @EnableScheduling
2. 任务类加 @Component
3. 方法上加 @Scheduled 并配置时间规则（可以使用在线生成器）
4. 记得配置线程池避免任务阻塞

WebSocket 简介

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，它解决了 HTTP 协议单向通信的局限性。

为什么需要 WebSocket？

**HTTP 的局限：**客户端必须主动发起请求才能获取数据，服务器无法主动推送数据给客户端，实时性差，需要使用轮询（频繁请求）才能实现'伪实时'。

**WebSocket 的优势：**全双工通信，服务器可以主动推送数据；一次连接，持久通信；低延迟，实时性好。适合即时通讯、消息通知、实时监控、协同编辑、多人实时游戏等场景。

基础概念

连接生命周期

客户端 服务器
|
|--握手请求--->|
|<--握手响应---|
|
|<--推送数据---|
|--发送数据--->|
|<--推送数据---|
|
|--关闭连接--->|
|<--关闭确认---|

关键事件

• onOpen：连接建立时触发
• onMessage：收到消息时触发
• onClose：连接关闭时触发
• onError：发生错误时触发

Java WebSocket 服务端实现

项目依赖（pom.xml）

<!-- Spring Boot WebSocket 支持 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<!-- Java WebSocket API -->
<dependency>
    <groupId>javax.websocket</groupId>
    <artifactId>javax.websocket-api</artifactId>
    <version>1.1</version>
    <scope>provided</scope>
</dependency>

WebSocket 配置类

package com.sky.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfiguration {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        // 自动注册 @ServerEndpoint 注解的类
        return new ServerEndpointExporter();
    }
}

WebSocket 服务端核心类

package com.sky.websocket;

import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;

@Component
@ServerEndpoint("/ws/{sid}")
public class WebSocketServer {
    // 存储所有在线会话，使用线程安全的 ConcurrentHashMap
    private static ConcurrentHashMap<String, Session> sessionMap = new ConcurrentHashMap<>();
    // 当前会话
    private Session session;
    // 当前用户标识
    private String sid;

    /**
     * 连接建立时触发
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("sid") String sid) {
        this.session = session;
        this.sid = sid;
        sessionMap.put(sid, session);
        System.out.println("【连接】用户 " + sid + " 已连接，当前在线人数：" + sessionMap.size());
        // 发送欢迎消息
        sendMessage(sid, "欢迎 " + sid + " 连接成功！");
    }

    /**
     * 收到客户端消息时触发
     */
    @OnMessage
    public void onMessage(String message, @PathParam("sid") String sid) {
        System.out.println("【消息】用户 " + sid + " 发送：" + message);
        // 处理不同消息类型
        if ("ping".equals(message)) {
            sendMessage(sid, "pong");
        } else {
            // 广播消息给所有用户
            sendToAll(sid + " 说：" + message);
        }
    }

    /**
     * 连接关闭时触发
     */
    @OnClose
    public void onClose(@PathParam("sid") String sid) {
        sessionMap.remove(sid);
        System.out.println("【关闭】用户 " + sid + " 已断开，当前在线人数：" + sessionMap.size());
        // 通知其他用户
        sendToAll("用户 " + sid + " 离开了聊天室");
    }

    /**
     * 发生错误时触发
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("【错误】" + error.getMessage());
        error.printStackTrace();
    }

    /**
     * 发送消息给指定用户
     */
    public void sendMessage(String sid, String message) {
        Session session = sessionMap.get(sid);
        if (session != null && session.isOpen()) {
            try {
                session.getBasicRemote().sendText(message);
                System.out.println("【发送】给 " + sid + "：" + message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 发送消息给所有用户（群发）
     */
    public void sendToAll(String message) {
        for (String sid : sessionMap.keySet()) {
            sendMessage(sid, message);
        }
    }

    /**
     * 获取在线人数
     */
    public static int getOnlineCount() {
        return sessionMap.size();
    }
}

苍穹外卖集成示例

订单状态流转建议

在没有微信支付功能的场景下，下单流程可简化为直接设置待接单状态，跳过待付款环节。

1. 下单时直接设置：在 OrderServiceImpl 的 submitOrder 方法中，将订单状态设为 2（待接单），支付状态设为 1（已支付）。
2. 数据库无需额外设置：不需要修改表结构，订单状态按照正常流程流转即可：2(待接单) → 3(待配送) → 4(配送中) → 5(已完成)。

来单提醒功能

商家端连接 WebSocket

商家登录后自动连接 WebSocket，监听新订单消息：

// 商家端前端页面（如 orders.html）
let ws = null;
let shopId = 'shop_001'; // 实际从登录信息获取

// 连接 WebSocket
function connectWebSocket() {
    ws = new WebSocket(`ws://localhost:8080/ws/${shopId}`);
    ws.onopen = function() {
        console.log('WebSocket 连接成功，商家 ID：' + shopId);
        showToast('连接成功，等待新订单...');
    };
    ws.onmessage = function(event) {
        // 接收服务器推送的消息
        const message = JSON.parse(event.data);
        handlePushMessage(message);
    };
    ws.onclose = function() {
        console.log('WebSocket 连接断开，5 秒后重连');
        setTimeout(connectWebSocket, 5000);
    };
    ws.onerror = function(error) {
        console.error('WebSocket 错误：', error);
    };
}

// 处理推送消息
function handlePushMessage(message) {
    switch(message.type) {
        case 'NEW_ORDER':
            addNewOrder(message.data); // 添加新订单到列表
            playNewOrderSound(); // 播放提示音
            showNotification('有新订单啦！');
            break;
        case 'REMINDER':
            showReminder(message.data); // 显示催单提醒
            break;
        case 'ORDER_STATUS':
            updateOrderStatus(message.data); // 更新订单状态
            break;
        default:
            console.log('未知消息类型：', message.type);
    }
}

// 添加新订单到页面
function addNewOrder(order) {
    const ordersDiv = document.getElementById('orderList');
    const orderCard = `
        <div>
            <div>订单号：${order.number}</div>
            <div>金额：¥${order.amount}</div>
            <div>时间：${order.createTime}</div>
            <button onclick="acceptOrder(${order.id})">接单</button>
            <button onclick="rejectOrder(${order.id})">拒单</button>
        </div>
    `;
    ordersDiv.insertAdjacentHTML('afterbegin', orderCard);
}

// 播放提示音
function playNewOrderSound() {
    const audio = new Audio('/audio/new_order.mp3');
    audio.play().catch(e => console.log('播放失败：', e));
}

// 页面加载时连接
document.addEventListener('DOMContentLoaded', function() {
    connectWebSocket();
});

// 页面关闭时断开连接
window.addEventListener('beforeunload', function() {
    if (ws) {
        ws.close();
    }
});

用户端下单时触发 WebSocket 推送

用户点击下单后，后端推送消息给商家：

// OrderServiceImpl.java
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private WebSocketServer webSocketServer; // 注入 WebSocket 服务

    @Override
    @Transactional
    public void submitOrder(OrderSubmitDTO orderSubmitDTO) {
        // 1. 保存订单信息到数据库
        Orders order = new Orders();
        // ... 设置订单信息
        orderMapper.insert(order);

        // 2. 保存订单明细
        // ... 保存明细

        // 3. 清空购物车
        // ... 清空购物车

        // 4. 通过 WebSocket 推送新订单给商家
        // 构建推送消息
        Map<String, Object> pushMessage = new HashMap<>();
        pushMessage.put("type", "NEW_ORDER");
        pushMessage.put("data", order);
        pushMessage.put("timestamp", System.currentTimeMillis());
        String jsonMessage = JSON.toJSONString(pushMessage);

        // 发送给商家（假设商家 ID 固定为 "shop_001"）
        // 如果有多商家，需要根据订单中的 shopId 发送
        webSocketServer.sendToClient("shop_001", jsonMessage);
        System.out.println("【来单提醒】已推送新订单：" + order.getNumber());
    }
}

催单提醒功能

用户端发送催单消息

用户在小程序或网页上点击催单按钮：

// 用户端前端
function remindOrder(orderId) {
    // 发送催单请求到后端
    fetch('/user/order/remind', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ orderId: orderId })
    })
    .then(response => response.json())
    .then(data => {
        if (data.code === 1) {
            alert('催单成功，商家将尽快处理');
        }
    });
}

后端处理催单并推送

// OrderController.java
@RestController
@RequestMapping("/user/order")
public class OrderController {
    @Autowired
    private OrderService orderService;

    /**
     * 用户催单
     */
    @PostMapping("/remind")
    @ApiOperation("用户催单")
    public Result remind(@RequestBody RemindDTO remindDTO) {
        orderService.remindOrder(remindDTO.getOrderId());
        return Result.success();
    }
}

// OrderServiceImpl.java
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private WebSocketServer webSocketServer;

    @Override
    public void remindOrder(Long orderId) {
        // 1. 查询订单信息
        Orders order = orderMapper.getById(orderId);
        if (order == null) {
            throw new BusinessException("订单不存在");
        }

        // 2. 检查订单状态（只有待接单或待配送状态可以催单）
        if (order.getStatus() != Orders.PENDING_PAYMENT && order.getStatus() != Orders.TO_BE_CONFIRMED) {
            throw new BusinessException("当前订单状态不支持催单");
        }

        // 3. 记录催单日志（可选）
        orderMapper.updateRemindTime(orderId);

        // 4. 推送催单消息给商家
        Map<String, Object> remindMessage = new HashMap<>();
        remindMessage.put("type", "REMINDER");
        remindMessage.put("data", Map.of(
            "orderId", order.getId(),
            "orderNumber", order.getNumber(),
            "remindTime", LocalDateTime.now()
        ));
        String jsonMessage = JSON.toJSONString(remindMessage);
        webSocketServer.sendToClient("shop_001", jsonMessage);
        log.info("用户催单：订单号 {}，已通知商家", order.getNumber());
    }
}

定时推送订单统计数据

WebSocketTask 定时任务

完善 sendMessageToClient 方法，定期推送实时数据：

package com.sky.task;

import com.sky.websocket.WebSocketServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

@Component
public class WebSocketTask {
    @Autowired
    private WebSocketServer webSocketServer;
    @Autowired
    private OrderMapper orderMapper; // 注入订单 Mapper

    /**
     * 每隔 5 秒推送实时数据给商家
     */
    @Scheduled(cron = "0/5 * * * * ?")
    public void pushRealTimeData() {
        try {
            // 获取实时统计数据
            Map<String, Object> data = new HashMap<>();
            data.put("type", "REAL_TIME_DATA");
            data.put("timestamp", LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));

            // 今日订单数
            Integer todayOrders = orderMapper.getTodayOrderCount();
            data.put("todayOrders", todayOrders);

            // 今日营业额
            Double todayAmount = orderMapper.getTodayTurnover();
            data.put("todayAmount", todayAmount);

            // 待处理订单数
            Integer pendingOrders = orderMapper.getPendingOrderCount();
            data.put("pendingOrders", pendingOrders);

            // 当前在线人数（WebSocket 连接数）
            data.put("onlineCount", WebSocketServer.getOnlineCount());

            // 推送消息给所有商家
            String jsonMessage = JSON.toJSONString(data);
            webSocketServer.sendToAll(jsonMessage);
            System.out.println("定时推送实时数据：" + jsonMessage);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

商家端接收实时数据

// 商家端接收实时数据
function handlePushMessage(message) {
    if (message.type === 'REAL_TIME_DATA') {
        // 更新页面上的统计数据
        document.getElementById('todayOrders').innerText = message.todayOrders;
        document.getElementById('todayAmount').innerText = '¥' + message.todayAmount;
        document.getElementById('pendingOrders').innerText = message.pendingOrders;
        document.getElementById('onlineCount').innerText = message.onlineCount;
        document.getElementById('updateTime').innerText = message.timestamp;
    }
}