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

Cron 表达式详解

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 * ?")

线程池配置（重要）

默认情况下，Spring Task 使用单线程执行任务。如果某个任务耗时过长，会阻塞后续任务。生产环境中建议配置异步线程池。

@Configuration
@EnableScheduling
public class SchedulingConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 设置线程池大小为 10
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
    }
}

或者在 application.yml 中配置：

spring:
  task:
    scheduling:
      pool:
        size: 10
        thread-name-prefix: my-scheduler-

最佳实践

1. 避免阻塞：耗时操作应放入异步线程中执行。

   @Scheduled(cron = "0/10 * * * * ?")
   public void longRunningTask() {
       CompletableFuture.runAsync(() -> {
           // 耗时业务逻辑
       });
   }
   

2. 异常处理：定时任务异常不会自动打印到控制台，需手动捕获记录日志。
3. 动态配置：可通过配置文件动态修改 Cron 表达式，实现运行时调整。

WebSocket 实时通信

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，解决了 HTTP 单向通信的局限性，非常适合即时通讯和实时推送场景。

为什么需要 WebSocket？

• HTTP 局限：客户端必须主动发起请求，服务器无法主动推送数据。轮询方式效率低且延迟高。
• WebSocket 优势：全双工通信，服务器可主动推送；一次握手建立持久连接；低延迟。

服务端实现

1. 依赖引入

<!-- 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>

2. 配置类

需要注册 ServerEndpointExporter 以自动扫描 @ServerEndpoint 注解。

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() {
        return new ServerEndpointExporter();
    }
}

3. 核心类

使用 ConcurrentHashMap 存储在线会话，保证线程安全。

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 {
    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 s = sessionMap.get(sid);
        if (s != null && s.isOpen()) {
            try {
                s.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void sendToAll(String message) {
        for (String key : sessionMap.keySet()) {
            sendMessage(key, message);
        }
    }

    public static int getOnlineCount() {
        return sessionMap.size();
    }
}

前端客户端实现

前端通过 JavaScript 的 WebSocket API 建立连接。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>WebSocket 聊天室</title>
    <style>
        body { font-family: 'Microsoft YaHei', sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); height: 100vh; display: flex; justify-content: center; align-items: center; margin: 0; }
        .chat-container { width: 800px; height: 600px; background: white; border-radius: 10px; box-shadow: 0 10px 30px rgba(0,0,0,0.3); display: flex; flex-direction: column; overflow: hidden; }
        .chat-header { background: #4a90e2; color: white; padding: 15px 20px; font-size: 18px; font-weight: bold; }
        .chat-messages { flex: 1; overflow-y: auto; padding: 20px; background: #f5f5f5; }
        .message { margin-bottom: 15px; display: flex; align-items: flex-start; }
        .message.system { justify-content: center; }
        .message.system .content { background: #e0e0e0; color: #666; font-size: 12px; padding: 5px 15px; border-radius: 15px; }
        .message.other { justify-content: flex-start; }
        .message.self { justify-content: flex-end; }
        .message .content { max-width: 70%; padding: 10px 15px; border-radius: 10px; word-wrap: break-word; }
        .message.other .content { background: white; border: 1px solid #ddd; }
        .message.self .content { background: #4a90e2; color: white; }
        .chat-input { padding: 20px; background: white; border-top: 1px solid #ddd; display: flex; gap: 10px; }
        .chat-input input { flex: 1; padding: 10px; border: 1px solid #ddd; border-radius: 5px; font-size: 14px; }
        .chat-input button { padding: 10px 20px; background: #4a90e2; color: white; border: none; border-radius: 5px; cursor: pointer; font-size: 14px; }
        .status { padding: 10px 20px; background: #f0f0f0; font-size: 12px; color: #666; border-top: 1px solid #ddd; }
    </style>
</head>
<body>
<div class="chat-container">
    <div class="chat-header">🚀 WebSocket 聊天室</div>
    <div class="chat-messages" id="messages"></div>
    <div class="chat-input">
        <input type="text" id="messageInput" placeholder="输入消息..." onkeypress="handleKeyPress(event)">
        <button onclick="sendMessage()">发送</button>
    </div>
    <div class="status" id="status">连接状态：未连接</div>
</div>
<script>
let ws = null;
let userId = 'user_' + Math.random().toString(36).substr(2, 6);

function addMessage(message, type, sender) {
    const messagesDiv = document.getElementById('messages');
    const messageDiv = document.createElement('div');
    messageDiv.className = `message ${type}`;
    let html = '';
    if (type === 'system') {
        html = `<div class="content">📢 ${message}</div>`;
    } else {
        html = `<div class="info">${sender || (type === 'self' ? '我' : userId)}</div><div class="content">${message}</div>`;
    }
    messageDiv.innerHTML = html;
    messagesDiv.appendChild(messageDiv);
    messagesDiv.scrollTop = messagesDiv.scrollHeight;
}

function connect() {
    const wsUrl = `ws://localhost:8080/ws/${userId}`;
    ws = new WebSocket(wsUrl);
    ws.onopen = function() {
        .();
        .(). = ;
        (, );
    };
    ws. = () {
        .(, event.);
        (event., , );
    };
    ws. = () {
        .();
        .(). = ;
        (, );
    };
    ws. = () {
        .(, error);
        (, );
    };
}

 () {
     input = .();
     message = input..();
     (!message) ;
     (ws && ws. === .) {
        ws.(message);
        (message, , );
        input. = ;
    }  {
        (, );
    }
}

 () {
     (event. === ) ();
}

. = () { (); };
. = () {  (ws) ws.(); };
</script>
</body>
</html>

苍穹外卖场景落地

在实际项目中，我们利用上述技术实现订单状态的实时同步。

1. 订单状态流转优化

在无微信支付场景中，下单后直接跳过待付款状态，进入待接单流程。

• Service 层修改：在 submitOrder 方法中，将订单状态设为 2（待接单），支付状态设为 1（已支付）。
• 数据库：无需修改表结构，保持原有状态码定义即可。

2. 来单提醒

商家端登录后自动连接 WebSocket，当有新订单时，后端推送消息触发前端弹窗或提示音。

// 商家端前端
let ws = null;
let shopId = 'shop_001';

function connectWebSocket() {
    ws = new WebSocket(`ws://localhost:8080/ws/${shopId}`);
    ws.onopen = function() {
        console.log('WebSocket 连接成功，商家 ID：' + shopId);
    };
    ws.onmessage = function(event) {
        const message = JSON.parse(event.data);
        if (message.type === 'NEW_ORDER') {
            playNewOrderSound();
            showNotification('有新订单啦！');
        }
    };
    ws.onclose = function() {
        setTimeout(connectWebSocket, 5000); // 断线重连
    };
}

3. 催单通知

用户点击催单按钮时，后端查询订单并立即通过 WebSocket 推送给对应商家。

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

    @Override
    public void remindOrder(Long orderId) {
        Orders order = orderMapper.getById(orderId);
        if (order == null) throw new BusinessException("订单不存在");
        
        Map<String, Object> remindMessage = new HashMap<>();
        remindMessage.put("type", "REMINDER");
        remindMessage.put("data", Map.of(
            "orderId", order.getId(),
            "orderNumber", order.getNumber()
        ));
        
        String jsonMessage = JSON.toJSONString(remindMessage);
        // 发送给指定商家
        webSocketServer.sendToClient("shop_001", jsonMessage);
    }
}

4. 实时数据统计

通过定时任务每隔几秒获取今日订单数、营业额等数据，推送到所有在线商家端，实现数据大屏实时更新。

@Component
public class WebSocketTask {
    @Autowired
    private WebSocketServer webSocketServer;
    @Autowired
    private OrderMapper orderMapper;

    @Scheduled(cron = "0/5 * * * * ?")
    public void pushRealTimeData() {
        Map<String, Object> data = new HashMap<>();
        data.put("type", "REAL_TIME_DATA");
        data.put("todayOrders", orderMapper.getTodayOrderCount());
        data.put("todayAmount", orderMapper.getTodayTurnover());
        data.put("onlineCount", WebSocketServer.getOnlineCount());
        
        String jsonMessage = JSON.toJSONString(data);
        webSocketServer.sendToAll(jsonMessage);
    }
}

通过 Spring Task 与 WebSocket 的组合，我们可以构建出响应迅速、交互流畅的后端服务，显著提升系统的实时性和用户体验。