苍穹外卖10（Spring Task定时任务，WebSocket双向通信，订单状态定时处理，来电提醒，客户催单）

package com.sky;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableCaching
@EnableScheduling //开启定时任务功能
@SpringBootApplication
@EnableTransactionManagement //开启注解方式的事务管理
@Slf4j
public class SkyApplication {
    public static void main(String[] args) {
        SpringApplication.run(SkyApplication.class, args);
        log.info("server started");
    }
}

创建任务类，在方法上加@Scheduled

package com.sky.task;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalTime;

@Component
public class DemoTask {
    
    @Scheduled(fixedDelay = 1000)
    public void demo(){
        System.out.println(LocalTime.now());
    }
}

功能测试

运行引导类启动服务，可看到控制台上每秒输出一次当前时间

3. 详解

1 @Scheduled注解

哪个方法需要周期性执行，就在哪个方法上添加注解@Scheduled。通过这个注解可以设置执行任务的周期

@Scheduled注解常用的属性有：

2 cron表达式

在使用定时任务时

fixedRate和fixedDelay：已经能满足大部分简单的定时任务。但是复杂的调度周期，就需要使用cron表达式了
cron：适合于执行周期比较复杂的定时任务，例如每年父亲节上行8点整执行，使用表达式：0 0 8 ? 6 7#3

cron表达式的编写相对麻烦，大家可以：

网上有很多生成器，直接生成cron表达式。直接百度“cron”就能搜到。比如：

Cron - 在线Cron表达式生成器，或在线Cron表达式生成器， ……
需要使用时，上网直接搜，有很多人提供写好的cron表达式；
自己积累一些常用的cron表达式

1 cron表达式6个域

语法：分为6或7个域，由空格分隔开。按顺序分别是：秒分时日月周年。通常不需要“年”
注意：“日”和“周”互斥，其中一个有值，另外一个必写成?
示例：0 0 8 * * ? 表示每年每月每天的08:00:00 触发

各个域的语法如下：

2 各个域的取值说明

*星号

作用：表示在这个域上包含所有合法的值。

例如在月份域上使用了星号，表示所有月份都会触发
示例：0 * 17 * * ?，表示每月、每天的17:00至17:59分，每分钟都会触发一次

?问号

作用：“我不关心这个域上是什么值”，它不同于星号：
- 星号表示这个域上所有合法值
- 问号表示不给这个域指定值
注意：只能用在日和周域上，但不能在这两个域上同时使用

不能同时这两个域上指定值的理由是难以解释甚至是难以理解的。

基本上，假定同时指定值的话，意义就会变得含混不清了：考虑一下，如果一个表达式在日域上有值11，同时在周域上指定了 WED。那么是要仅在每个月11号，且正好又是星期三那天被激发？还是在每个星期三的11号被激发呢？要去除这种不明确性的办法就是不能同时在这两个域上指定值。

只要记住，假如你为这两域的其中一个指定了值，那就必须在另一个字值上放一个 ?。
示例：0 10 14 ? 3 3，表示3月每个星期2的14:10:00触发一次

,逗号

作用：逗号表示给这个域指定一个值列表，即指定多个值

例如在秒域上使用值0,15,30,45 表示每15秒触发一次
示例：0 0,15,30,45 * * * ? 表示每天都会每15分钟触发一次

/斜杠

作用：用于时间递增。刚刚我们用逗号实现15秒触发一次，也可以写成0/15
示例：0 0/15 * * * ?表示每天都会每15分钟触发一次

-横杠

作用：用于指定时间范围。

例如在小时域上指定值8-18，表示8点至18点
注意：范围必须是从小到大，不能回转。即不能写成18-8
示例：0 0 8-18 * * ?表示每天8:00至18:00

#井号

作用：用于指定第几个周几。
注意：仅用于周域中
示例：
- 6#3表示第3个周五（6在周里表示周五，因为周日是第一天、值是1）
- 2#1表示第1个周一
- 0 0 8 ? 6 1#3 表示每年的6月第3个星期日上午8点（父亲节）

L字母

作用：表示某域上允许的最后一个值
注意：
- 只允许用在日域和周域上
- 不要让范围和列表值与L连用，会产生不可预知的结果
示例：
- 用在日域上时，表示的是月域的最后一天。0 0 8 L * ?表示每月最后一天的8:00触发
- 用在周域上时，在L前加数字X，表示最后一个星期X。0 0 8 ? * 1L表示每月最后一个周一8:00触发

W字母

作用：表示工作日（平日，周一至周五），只能用在日域上，将在离指定日期最近的一个工作日触发。
示例：0 0 8 2W * ?表示每月如果2号是工作日，则2号触发；如果2号不是工作日，则找2号最近的工作日触发
注意：找寻最近的工作日时，不会跨月

package com.sky.task;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalTime;

@Component
public class DemoTask {

    /**
     * 注解@Scheduled：加在方法上，表示要周期性执行。
     * 执行的时机，是通过注解的一些属性参数配置的，常用的：
     *  一些简单的定时任务，使用
     *      fixedDelay：设置一个毫秒值，是上一次任务执行结束后，延迟多长时间开始下一次任务
     *      fixedRate：设置一个毫秒值，是上一次任务执行开始之后， 延迟多长时间开始下一次任务
     *  一些复杂的定时任务(比如每个月最后一天早上8:00执行)，使用
     *      cron：设置一个cron表达式，通过cron表达式可以非常方便的表示一些复杂的执行周期
     *  cron表达式：
     *      语法：由7个域组成，使用空格隔开，是  秒 分 时 日 月 周 年  但是“年”一般不写，所以使用时通常用前6个域
     *      说明：
     *          如果写精确值，就表示只有这个值才会触发
     *          * 表示所有合法值都会触发
     *          ? 表示忽略这个值。通常 日和周两个域，一个有值，另外一个就必须是?。如果日和周两个域都有值，就会出现不可预测的结果
     *          , 表示可以在一个域上设置多个值
     *          - 表示设置一个范围值。在指定范围内每个合法值都会触发
     *          / 表示设置一个递增值。比如 1/5 从1开始，每递增5就触发一次
     *          L 表示last，可以用在日和周域上
     *              如果用在日域上，表示月的最后一天
     *              如果用在周域上，前边要加一个数字X，表示最后一个星期X。 3L 最后一个星期三
     *          W 表示Weekday，离指定日期最近的工作日(不跨月)触发
     *          # 用在周域上，X#Y 表示第Y个星期X触发
     *      示例：
     *          0 0 0 1 1 ?  表示每年的1月1日 00:00:00
     *          0 0 0 * * ?  表示每年、每月、每天的 00:00:00
     *          0 0 0 1 * ?  表示每年、每月、1号的 00:00:00
     *          * * * * * ?  表示每年、每月、每天的 每小时、每分钟、每一秒
     *          5 * * * * ?  表示每年、每月、每天的 每小时、每分钟的 第5秒时
     *          0,30 * * * * ? 表示每年、每月、每天的 每小时、每分钟的 第0秒和第30秒执行
     *          0-30 * * * * ? 表示每年、每月、每天的 每小时、每分钟的 第0~30秒中每秒执行
     *          0/5 * * * * ?  表示每年、每月、每天的 每小时、每分钟的 第0秒开始，5秒执行一次
     *          0 0 0 1W * ?   表示每年、每月的1号(离1号最近的工作日)那天 00:00:00
     *          0 0 8 ? 6 7#3  每年父亲节早上8点整触发执行一次（每年6月的第3个星期日）
     *     使用：
     *          学习语法，每次根据语法编写cron表达式。
     *          有一些在线生成cron表达式的网站。百度 cron在线
     *          日常收集一些常用的
     */
    // @Scheduled(fixedRate = 1000)
    @Scheduled(cron = "0/5 * * * * ?")
    public void demo(){
        System.out.println(LocalTime.now());
    }
}

4. 小结

SpringTask的使用步骤：
   1. 在引导类上加注解@EnableScheduling，开启定时任务调度的功能
   2. 哪个方法需要周期性执行，就在哪个方法上加注解 @Scheduled(fixedRate=间隔周期毫秒值)
@Scheduled注解的使用：
   如果是简单的定时任务，使用
       fixedRate设置一个毫秒值，表示上一次任务开始之后，间隔多长时间开始下一次任务
       fixedDelay设置一个毫秒值，表示上一次任务结束之后，间隔多长时间开始下一次任务
   如果是复杂的定时任务，使用
       cron 设置一个cron表达式
cron表达式的语法：
   6个域秒分时日月周；最后还可以加一个“年”，但是通常不需要
   每个域的值：
       可以写精确值，当时间到这个值的时候才会触发
       * 域里每个合法值都会触发
       ? 用在日和周两个域，必定有一个用?，否则会出现不可预测的结果
       , 可以写多个精确值触发。 0,30 * * * * ?
       - 表示范围值，在范围内每个合法值都触发 0-30 * * * * ?
       / 表示递增值，1/5 表示从1开始，每隔5触发一次

       L 用在日和周
           用在日上，表示每月的最后一天 0 0 8 L * ?
           用在周上，写法XL表示最后一个星期X
       W 用在日上，表示离指定日期最近的一个工作日触发（不跨月）
       # 用在周上，写法X#Y表示第Y个星期X

二、订单状态定时处理

1. 需求分析

1 问题分析

用户下单后可能存在的情况：

下单后未支付，订单一直处于“待支付”状态
用户收货后管理端未点击完成按钮，订单一直处于“派送中”状态

2 功能需求

对于上面两种情况需要通过定时任务来修改订单状态：

自动取消超时未支付的订单：

通过定时任务，每分钟检查一次是否存在支付超时订单（下单后超过15分钟仍未支付则判定为支付超时订单），如果存在则修改订单状态为“已取消”
自动完成派送中超时的订单

通过定时任务，每天凌晨1点检查一次是否存在“派送中”的订单，如果存在则修改订单状态为“已完成”

2. 代码开发

1 修改引导类加@EnableScheduling

package com.sky;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableCaching
@EnableScheduling //开启定时任务调度功能
@SpringBootApplication
@EnableTransactionManagement 
@Slf4j
public class SkyApplication {
    public static void main(String[] args) {
        SpringApplication.run(SkyApplication.class, args);
        log.info("server started");
    }
}

2 创建OrderTask类

package com.sky.task;

import com.github.pagehelper.Page;
import com.sky.dto.OrdersPageQueryDTO;
import com.sky.entity.Orders;
import com.sky.mapper.OrderMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Slf4j
@Component
public class OrderTask {
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 处理超时订单
     * 执行时机：每分钟一次
     * 执行任务：扫描数据库，找出超时未支付的订单，取消订单
     */
    @Scheduled(fixedRate = 1000*60)
    public void processTimeoutOrder(){
        //1. 查找超时未支付的订单：15分钟前下单，状态是待付款的订单
        OrdersPageQueryDTO dto = new OrdersPageQueryDTO();
        dto.setStatus(Orders.PENDING_PAYMENT);
        dto.setEndTime(LocalDateTime.now().minusMinutes(15));
        List<Orders> ordersList = orderMapper.selectList(dto);
        if (ordersList!=null && ordersList.size() > 0) {
            //2. 取消订单
            for (Orders orders : ordersList) {
                orders.setStatus(Orders.CANCELLED);
                orders.setCancelReason("超时未支付，自动取消订单");
                orders.setCancelTime(LocalDateTime.now());
                orderMapper.update(orders);
                log.info("订单{}下单时间：{}，超时未支付，已自动取消", orders.getId(), orders.getOrderTime());
            }
        }
    }

    /**
     * 处理“派送中”的订单
     * 执行时机：每天凌晨1点整
     * 执行任务：扫描数据库，找出派送中的订单，设置为“已完成”
     */
    @Scheduled(cron = "0 0 1 * * ?")
    public void processDeliveryOrder(){
        //1. 查询“派送中”的订单
        OrdersPageQueryDTO dto = new OrdersPageQueryDTO();
        dto.setStatus(Orders.DELIVERY_IN_PROGRESS);
        List<Orders> ordersList = orderMapper.selectList(dto);

        //2. 如果有，就修改这些订单的状态
        if (ordersList != null && ordersList.size()>0) {
            for (Orders orders : ordersList) {
                orders.setStatus(Orders.COMPLETED);
                orderMapper.update(orders);
                log.info("订单{}派送时间{}，派送已超时，自动完成", orders.getId(), orders.getDeliveryTime());
            }
        }
    }
}

3. 功能测试

可以通过如下方式进行测试：

查看控制台sql
查看数据库中数据变化

三、WebSocket

1. 介绍

WebSocket是基于 TCP 的一种新的网络协议，它实现了浏览器与服务器全双工通信——浏览器和服务器只需要握手成功，两者之间就可以创建持久性的连接，并进行双向数据传输。

但是WebSocket并不能完全取代HTTP，它只适合在特定的场景下使用。

1 WebSocket和HTTP对比

WebSocket是长连接；而HTTP是短连接
WebSocket支持双向通信；而HTTP通信是单向主动的，基于请求响应模式
HTTP和WebSocket底层都是TCP连接

思考：既然WebSocket支持双向通信，功能看似比HTTP强大，那么我们是不是可以基于WebSocket开发所有的业务功能？

2 WebSocket缺点

服务器长期维护长连接需要一定的成本
各个浏览器支持程度不一；服务器的支持程度也不同
WebSocket 是长连接，受网络限制比较大，需要处理好重连

3 WebSocket应用场景

实时性要求较高的场景

适合使用WebSocket通信：服务端什么时候有新数据，什么时候主动向客户端推送即可
不推荐的方式：仍然使用HTTP。比如客户端每隔1s，向服务端发请求，查询最新的数据并显示到页面上

1). 视频弹幕

2). 网页聊天

3). 体育实况更新

4). 股票基金报价实时更新

4 SpringBoot整合WebSocket使用步骤

准备服务端：

创建Server端类：

创建Java类，类上加@Component，交给Spring管理

类上加@ServerEndPoint("访问路径")，声明这是一个WebSocket服务端程序。客户端可以通过此路径与服务端连接并通信
- @OnOpen：加在方法上，此方法将会在客户端与服务端连接成功时执行
- @OnMessage：加在方法上，此方法将会在客户端传递消息过来时执行
- @OnClose：加在方法上，此方法将会在客户端与服务端断开连接时执行
- @OnError：加在方法上，此方法将会在连接出错时执行
创建配置类

类上加@Configuration

在配置类里创建方法，使用@Bean方式把ServerEndpointExporter对象注册到Spring容器里

准备客户端：

使用js，创建WebSocket对象

2. 入门案例

1 案例分析

需求：实现浏览器与服务器全双工通信。浏览器既可以向服务器发送消息，服务器也可主动向浏览器推送消息。

效果展示：

实现步骤：

1). 直接使用websocket.html页面作为WebSocket客户端

2). 导入WebSocket的maven坐标

3). 导入WebSocket服务端组件WebSocketServer，用于和客户端通信

4). 导入配置类WebSocketConfiguration，注册WebSocket的服务端组件

5). 导入定时任务类WebSocketTask，定时向客户端推送数据

2 代码开发

1 准备前端页面

定义websocket.html页面，不需要加到项目里，放到桌面上直接双击打开就行

<!DOCTYPE HTML>
<html>
<head>
    <meta charset="UTF-8">
    <title>WebSocket Demo</title>
</head>
<body>
    <input id="text" type="text" />
    <button onclick="send()">发送消息</button>
    <button onclick="closeWebSocket()">关闭连接</button>
    <div id="message">
    </div>
</body>
<script type="text/javascript">
    var websocket = null;
    var clientId = Math.random().toString(36).substr(2);
    document.getElementById("message").innerHTML = "你的id是：" + clientId + "<br/>";

    //判断当前浏览器是否支持WebSocket
    if('WebSocket' in window){
        //连接WebSocket节点
        websocket = new WebSocket("ws://localhost:8080/ws/"+clientId);
    }
    else{
        alert('Not support websocket')
    }

    //连接发生错误的回调方法
    websocket.onerror = function(){
        setMessageInnerHTML("error");
    };

    //连接成功建立的回调方法
    websocket.onopen = function(){
        setMessageInnerHTML("连接成功");
    }

    //接收到消息的回调方法
    websocket.onmessage = function(event){
        setMessageInnerHTML(event.data);
    }

    //连接关闭的回调方法
    websocket.onclose = function(){
        setMessageInnerHTML("close");
    }

    //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
    window.onbeforeunload = function(){
        websocket.close();
    }

    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML){
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

    //发送消息
    function send(){
        var message = document.getElementById('text').value;
        websocket.send(message);
    }
	
	//关闭连接
    function closeWebSocket() {
        websocket.close();
    }
</script>
</html>

2 准备服务端代码

导入maven坐标

在sky-server模块pom.xml中已定义

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

3 定义WebSocket服务端组件

直接导入到sky-server模块即可

package com.sky.websocket;

import org.springframework.stereotype.Component;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/**
 * WebSocket服务
 */
@Component
@ServerEndpoint("/ws/{sid}")
public class WebSocketServer {

    //存放会话对象
    private static Map<String, Session> sessionMap = new HashMap();

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("sid") String sid) {
        System.out.println("客户端：" + sid + "建立连接");
        sessionMap.put(sid, session);
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, @PathParam("sid") String sid) {
        System.out.println("收到来自客户端：" + sid + "的信息:" + message);
        sendToAllClient(sid + "说： " + message);
    }

    /**
     * 连接关闭调用的方法
     *
     * @param sid
     */
    @OnClose
    public void onClose(@PathParam("sid") String sid) {
        System.out.println("连接断开:" + sid);
        sessionMap.remove(sid);
    }

    /**
     * 群发
     *
     * @param message
     */
    public void sendToAllClient(String message) {
        Collection<Session> sessions = sessionMap.values();
        for (Session session : sessions) {
            try {
                //服务器向客户端发送消息
                session.getBasicRemote().sendText(message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

4 定义配置类

注册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;

/**
 * WebSocket配置类，用于注册WebSocket的Bean
 */
@Configuration
public class WebSocketConfiguration {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

5 定义定时任务类，定时向客户端推送数据

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;

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

    /**
     * 通过WebSocket每隔5秒向客户端发送消息
     */
    @Scheduled(cron = "0/5 * * * * ?")
    public void sendMessageToClient() {
        webSocketServer.sendToAllClient("这是来自服务端的消息：" + DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalDateTime.now()));
    }
}

3 功能测试

启动服务，打开websocket.html页面

浏览器向服务器发送数据：

服务器向浏览器间隔5秒推送数据：

3. 小结

WebSocket是什么
   是基于TCP协议的一种双向通信的网络协议。允许客户端和服务端之间建立长连接，双方都可以主动发送消息给对方
WebSocket和HTTP的对比：
   都是基于TCP协议的网络协议
   WebSocket基于长连接的；HTTP基于短连接
   WebSocket是双向通信；HTTP是基于请求响应，有请求才会有响应
WebSocket的缺点：
   需要服务端维护长连接，成本更高一些
   浏览器和服务器的支持程度不确定
   还需要处理连接断开与重连的情况
什么情况下适合使用WebSocket：
   客户端要求查询的数据，实时性较高的情况

WebSocket的使用步骤：
   服务端：
       创建服务器程序，创建一个类
           类上：加@Component， @ServerEndpoint("访问路径")
           类里：加方法
               @OnOpen：方法将会在客户端和服务端建立连接时执行。方法里可以加参数
                   Session：封装了客户端和服务端的会话信息，通过这个对象可以给客户端发送消息
                   如果要接收路径变量值：@PathParam("占位符名称")
               @OnMessage：方法将会在收到消息的时候执行。方法上可以加形参
                   String：接收得到的消息内容
                   可以使用@PathParam获取参数
               @OnClose：方法将会在断开连接时执行
                   可以使用@PathParam获取参数
               @OnError：方法将会在出错时执行
           如果要给客户端发送消息：利用session对象
               session.getBasicRemote().sendText(String content);
   客户端：
   参考资料里的代码即可

四、来单提醒

1. 需求分析和设计

用户下单并且支付成功后，需要第一时间通知外卖商家。通知的形式有如下两种：

语音播报
弹出提示框

设计思路：

通过WebSocket实现管理端页面和服务端保持长连接状态
当客户支付后，调用WebSocket的相关API实现服务端向客户端推送消息
客户端浏览器解析服务端推送的消息，判断是来单提醒还是客户催单，进行相应的消息提示和语音播报
约定服务端发送给客户端浏览器的数据格式为JSON，字段包括：type，orderId，content
- type 为消息类型，1为来单提醒 2为客户催单
- orderId 为订单id
- content 为消息内容

2. 代码开发

在OrderServiceImpl中注入WebSocketServer对象，修改paySuccess方法，加入如下代码：

	@Autowired
    private WebSocketServer webSocketServer;
	/**
     * 支付成功，修改订单状态
     *
     * @param outTradeNo
     */
    public void paySuccess(String outTradeNo) {
        // 当前登录用户id
        Long userId = BaseContext.getCurrentId();

        // 根据订单号查询当前用户的订单
        Orders ordersDB = orderMapper.getByNumberAndUserId(outTradeNo, userId);

        // 根据订单id更新订单的状态、支付方式、支付状态、结账时间
        Orders orders = Orders.builder()
                .id(ordersDB.getId())
                .status(Orders.TO_BE_CONFIRMED)
                .payStatus(Orders.PAID)
                .checkoutTime(LocalDateTime.now())
                .build();

        orderMapper.update(orders);
		//
        Map map = new HashMap();
        map.put("type", 1);//消息类型，1表示来单提醒
        map.put("orderId", orders.getId());
        map.put("content", "订单号：" + outTradeNo);

        //通过WebSocket实现来单提醒，向客户端浏览器推送消息
        webSocketServer.sendToAllClient(JSON.toJSONString(map));
        ///
    }

1). 登录管理端后台

登录成功后，浏览器与服务器建立长连接

查看控制台日志

2). 小程序端下单支付

修改回调地址，利用内网穿透获取域名

下单支付

3). 查看来单提醒

支付成功后，后台收到来单提醒，并有语音播报

五、客户催单

1. 需求分析和设计

用户在小程序中点击催单按钮后，需要第一时间通知外卖商家。通知的形式有如下两种：

语音播报
弹出提示框

设计思路：

通过WebSocket实现管理端页面和服务端保持长连接状态
当用户点击催单按钮后，调用WebSocket的相关API实现服务端向客户端推送消息
客户端浏览器解析服务端推送的消息，判断是来单提醒还是客户催单，进行相应的消息提示和语音播报约定服务端发送给客户端浏览器的数据格式为JSON，字段包括：type，orderId，content
- type 为消息类型，1为来单提醒 2为客户催单
- orderId 为订单Orders对象的id
- content 为消息内容

当用户点击催单按钮时，向服务端发送请求。

接口设计(催单)：

2. 代码开发

//修改UserOrderController

@GetMapping("/reminder/{id}")
@ApiOperation("用户催单")
public Result reminderOrder(@PathVariable("id") Long id){
    return orderService.reminderOrder(id);
}

-----------
//修改OrderService

    /**
     * 用户催单
     * @param orderId
     * @return
     */
    Result reminderOrder(Long orderId);


-----------
//修改OrderServiceImpl

    @Override
    public Result reminderOrder(Long orderId) {
        //1. 查询订单信息
        Orders orders = orderMapper.selectById(orderId);
        if (orders == null) {
            throw new OrderBusinessException(MessageConstant.ORDER_NOT_FOUND);
        }

        //2. 利用WebSocket向管理端发送催单提醒
        Map<String, Object> map = new HashMap<>();
        map.put("type", 2);//2代表用户催单
        map.put("orderId", orders.getId());
        map.put("content", "订单号：" + orders.getNumber());
        webSocketServer.sendToAllClient(JSON.toJSONString(map));
        return Result.success();
    }

3. 功能测试

可以通过如下方式进行测试：

查看浏览器调试工具数据交互过程
前后端联调

1). 登录管理端后台

登录成功后，浏览器与服务器建立长连接

查看控制台日志

2). 用户进行催单

用户可在订单列表或者订单详情，进行催单

3). 查看催单提醒

既有催单弹窗，同时语音播报

总结：

定时任务调度技术：SpringTask，可以周期性的执行任务
使用步骤：
   1. 先在引导类上加注解@EnableScheduling
   2. 哪个方法需要周期性执行，就在方法上加@Scheduled
@Scheduled注解使用
   简单的定时任务：
       fixedRate：上次任务执行开始，间隔多长时间开启下一次任务
       fixedDelay：上次任务执行结束，间隔多长时间开启下一次任务
   复杂的定时任务：
       cron：设置cron表达式
cron表达式的请求：
   6个域是秒分时日月周
   每个域的值：
       精确值
       * 域上所有的合法值都会触发
       ? 忽略这个域。用在日和周上，两个域必定有一个域的值是?
       , 可以给某个域设置多个精确值
       - 可以设置一个范围，在范围内每个合法值都会触发
       / 设置一个递增值， 0/5 在0、5、10……会触发

WebSocket
   WebSocket是基于TCP协议的一种双向通信协议，允许客户端和服务端在建立连接之后，双向互相发消息
   WebSocket和HTTP的对比：
       都是基于TCP协议的
       HTTP是基于短连接；WebSocket是基于长连接
       HTTP是请求驱动的通信；WebSocket是双向通信的
   WebSocket的缺点：
       服务端需要维护与所有客户端的连接，成本相对高一点
       WebSocket，浏览器客户端和服务器的支持度不一
       还需要处理断开重连的问题
   WebSocket的使用
   服务端：
       1. 创建一个类，作为WebSocket的服务器程序
           类上加@Component，@ServerEndpoint("访问路径，支持{}占位符")
           类里编写方法，方法上加：
               @OnOpen：方法会在客户端与服务端连接成功的时候自动执行。可以加形参Session，可以用@PathParam获取路径变量
               @OnMessage：方法会在收到消息时自动执行。可以加形参 String获取消息内容，可以用@PathParam获取路径变量
               @OnClose：方法会在连接断开的时候自动执行
               @OnError：方法会在出错时执行
       2. 创建一个配置类
           类上加@Configuration
           类里使用@Bean，把ServerEndpointExporter对象放到Spring容器里。它会扫描所有的@ServerEndpoint注解
       如果想要给客户端发消息：使用session对象的方法 session.getBasicRemote().sendText(String msg);
   客户端：使用JavaScript实现
   什么场景合适使用WebSocket：
   客户端要求实时展示一些数据的时候
   服务端可以利用WebSocket，在有数据变量时立即推送给客户端
来单提醒：
   在微信用户支付成功之后，服务端的程序主动向管理端页面发通知
客户催单：
   用户在小程序里点击“催单”按钮，发请求到服务端
   服务端再向管理端界面发通知