Java使用Websocket向客户端推送消息

喜欢ヅ旅行 2022-04-03 02:47 524阅读 0赞

需求：外卖平台收到订单后，向商家推送消息，有新订单了，并播放音频。

客户端 list.ftl

  1. <html>
  2. <#include "../common/header.ftl">
  4. <body>
  5. <div id="wrapper" class="toggled">
  7.     <#--边栏sidebar-->
  8.     <#include "../common/nav.ftl">
  10.     <#--主要内容content-->
  11.     <div id="page-content-wrapper">
  12.         <div class="container-fluid">
  13.             <div class="row clearfix">
  14.                 <div class="col-md-12 column">
  15.                     <table class="table table-bordered table-condensed">
  16.                         <thead>
  17.                         <tr>
  18.                             <th>订单id</th>
  19.                             <th>姓名</th>
  20.                             <th>手机号</th>
  21.                             <th>地址</th>
  22.                             <th>金额</th>
  23.                             <th>订单状态</th>
  24.                             <th>支付状态</th>
  25.                             <th>创建时间</th>
  26.                             <th colspan="2">操作</th>
  27.                         </tr>
  28.                         </thead>
  29.                         <tbody>
  31.                         <#list orderDTOPage.content as orderDTO>
  32.                         <tr>
  33.                             <td>${orderDTO.orderId}</td>
  34.                             <td>${orderDTO.buyerName}</td>
  35.                             <td>${orderDTO.buyerPhone}</td>
  36.                             <td>${orderDTO.buyerAddress}</td>
  37.                             <td>${orderDTO.orderAmount}</td>
  38.                             <td>${orderDTO.getOrderStatusEnum().message}</td>
  39.                             <td>${orderDTO.getPayStatusEnum().message}</td>
  40.                             <td>${orderDTO.createTime}</td>
  41.                             <td><a href="/sell/seller/order/detail?orderId=${orderDTO.orderId}">详情</a></td>
  42.                             <td>
  43.                                 <#if orderDTO.getOrderStatusEnum().message == "新订单">
  44.                                     <a href="/sell/seller/order/cancel?orderId=${orderDTO.orderId}">取消</a>
  45.                                 </#if>
  46.                             </td>
  47.                         </tr>
  48.                         </#list>
  49.                         </tbody>
  50.                     </table>
  51.                 </div>
  53.             <#--分页-->
  54.                 <div class="col-md-12 column">
  55.                     <ul class="pagination pull-right">
  56.                     <#if currentPage lte 1>
  57.                         <li class="disabled"><a href="#">上一页</a></li>
  58.                     <#else>
  59.                         <li><a href="/sell/seller/order/list?page=${currentPage - 1}&size=${size}">上一页</a></li>
  60.                     </#if>
  62.                     <#list 1..orderDTOPage.getTotalPages() as index>
  63.                         <#if currentPage == index>
  64.                             <li class="disabled"><a href="#">${index}</a></li>
  65.                         <#else>
  66.                             <li><a href="/sell/seller/order/list?page=${index}&size=${size}">${index}</a></li>
  67.                         </#if>
  68.                     </#list>
  70.                     <#if currentPage gte orderDTOPage.getTotalPages()>
  71.                         <li class="disabled"><a href="#">下一页</a></li>
  72.                     <#else>
  73.                         <li><a href="/sell/seller/order/list?page=${currentPage + 1}&size=${size}">下一页</a></li>
  74.                     </#if>
  75.                     </ul>
  76.                 </div>
  77.             </div>
  78.         </div>
  79.     </div>
  81. </div>
  83. <#--弹窗-->
  84. <div class="modal fade" id="myModal" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
  85.     <div class="modal-dialog">
  86.         <div class="modal-content">
  87.             <div class="modal-header">
  88.                 <button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
  89.                 <h4 class="modal-title" id="myModalLabel">
  90.                     提醒
  91.                 </h4>
  92.             </div>
  93.             <div class="modal-body">
  94.                 你有新的订单
  95.             </div>
  96.             <div class="modal-footer">
  97.                 <button onclick="javascript:document.getElementById('notice').pause()" type="button" class="btn btn-default" data-dismiss="modal">关闭</button>
  98.                 <button onclick="location.reload()" type="button" class="btn btn-primary">查看新的订单</button>
  99.             </div>
  100.         </div>
  101.     </div>
  102. </div>
  104. <#--播放音乐-->
  105. <audio id="notice" loop="loop">
  106.     <source src="/sell/mp3/song.mp3" type="audio/mpeg" />
  107. </audio>
  109. <script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
  110. <script src="https://cdn.bootcss.com/bootstrap/3.3.5/js/bootstrap.min.js"></script>
  111. <script>
  112.     var websocket = null;
  113.     if('WebSocket' in window) {
  114.         websocket = new WebSocket('ws://域名/sell/webSocket');
  115.     }else {
  116.         alert('该浏览器不支持websocket!');
  117.     }
  119.     websocket.onopen = function (event) {
  120.         console.log('建立连接');
  121.     }
  123.     websocket.onclose = function (event) {
  124.         console.log('连接关闭');
  125.     }
  127.     websocket.onmessage = function (event) {
  128.         console.log('收到消息:' + event.data)
  129.         //弹窗提醒, 
  130.         $('#myModal').modal('show');
  131.         // 播放音乐
  132.         document.getElementById('notice').play();
  133.     }
  135.     websocket.onerror = function () {
  136.         alert('websocket通信发生错误！');
  137.     }
  139.     window.onbeforeunload = function () {
  140.         websocket.close();
  141.     }
  143. </script>
  145. </body>
  146. </html>

Java 服务端

第一步：在spring boot项目中引入jar包

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-websocket</artifactId>
  4.         </dependency>

引入后,右击pom.xml->reimpoit

第二步：编写配置 config/WebSocketConfig.java

  1. package com.imooc.config;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.stereotype.Component;
  5. import org.springframework.web.socket.server.standard.ServerEndpointExporter;
  7. @Component
  8. public class WebSocketConfig {
  10.     @Bean
  11.     public ServerEndpointExporter serverEndpointExporter() {
  12.         return new ServerEndpointExporter();
  13.     }
  14. }

第三步：service/WebSocket.java

  1. package com.imooc.service;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.stereotype.Component;
  6. import javax.websocket.OnClose;
  7. import javax.websocket.OnMessage;
  8. import javax.websocket.OnOpen;
  9. import javax.websocket.Session;
  10. import javax.websocket.server.ServerEndpoint;
  11. import java.util.concurrent.CopyOnWriteArraySet;
  13. @Component
  14. @ServerEndpoint("/webSocket")
  15. @Slf4j
  16. public class WebSocket {
  18.     private Session session;
  20.     private static CopyOnWriteArraySet<WebSocket> webSocketSet = new CopyOnWriteArraySet<>();
  22.     @OnOpen
  23.     public void onOpen(Session session) {
  24.         this.session = session;
  25.         webSocketSet.add(this);
  26.         log.info("【websocket消息】有新的连接, 总数:{}", webSocketSet.size());
  27.     }
  29.     @OnClose
  30.     public void onClose() {
  31.         webSocketSet.remove(this);
  32.         log.info("【websocket消息】连接断开, 总数:{}", webSocketSet.size());
  33.     }
  35.     @OnMessage
  36.     public void onMessage(String message) {
  37.         log.info("【websocket消息】收到客户端发来的消息:{}", message);
  38.     }
  40.     public void sendMessage(String message) {
  41.         for (WebSocket webSocket: webSocketSet) {
  42.             log.info("【websocket消息】广播消息, message={}", message);
  43.             try {
  44.                 webSocket.session.getBasicRemote().sendText(message);
  45.             } catch (Exception e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.     }
  51. }

第四步：实现业务需求 ，在用户创建了订单后，给商家推送有新订单的消息，并播放音频

  1. package com.imooc.service.impl;
  3. import com.imooc.converter.OrderMaster2OrderDTOConverter;
  4. import com.imooc.dataobject.OrderDetail;
  5. import com.imooc.dataobject.OrderMaster;
  6. import com.imooc.dataobject.ProductInfo;
  7. import com.imooc.dto.CartDTO;
  8. import com.imooc.dto.OrderDTO;
  9. import com.imooc.enums.OrderStatusEnum;
  10. import com.imooc.enums.PayStatusEnum;
  11. import com.imooc.enums.ResultEnum;
  12. import com.imooc.exception.SellException;
  13. import com.imooc.repository.OrderDetailRepository;
  14. import com.imooc.repository.OrderMasterRepository;
  15. import com.imooc.service.*;
  16. import com.imooc.utils.KeyUtil;
  17. import lombok.extern.slf4j.Slf4j;
  18. import org.springframework.beans.BeanUtils;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.data.domain.Page;
  21. import org.springframework.data.domain.PageImpl;
  22. import org.springframework.data.domain.Pageable;
  23. import org.springframework.stereotype.Service;
  24. import org.springframework.transaction.annotation.Transactional;
  25. import org.springframework.util.CollectionUtils;
  27. import java.math.BigDecimal;
  28. import java.math.BigInteger;
  29. import java.util.List;
  30. import java.util.stream.Collectors;
  33. @Service
  34. @Slf4j
  35. public class OrderServiceImpl implements OrderService {
  37.     @Autowired
  38.     private ProductService productService;
  40.     @Autowired
  41.     private OrderDetailRepository orderDetailRepository;
  43.     @Autowired
  44.     private OrderMasterRepository orderMasterRepository;
  46.     @Autowired
  47.     private PayService payService;
  49.     @Autowired
  50.     private PushMessageService pushMessageService;
  52.     // 创建订单
  53.     @Autowired
  54.     private WebSocket webSocket;
  56.     @Override
  57.     @Transactional
  58.     public OrderDTO create(OrderDTO orderDTO) {
  60.         String orderId = KeyUtil.genUniqueKey();
  61.         BigDecimal orderAmount = new BigDecimal(BigInteger.ZERO);
  63. //        List<CartDTO> cartDTOList = new ArrayList<>();
  65.         //1. 查询商品（数量, 价格）
  66.         for (OrderDetail orderDetail: orderDTO.getOrderDetailList()) {
  67.             ProductInfo productInfo =  productService.findOne(orderDetail.getProductId());
  68.             if (productInfo == null) {
  69.                 throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);
  70.             }
  72.             //2. 计算订单总价
  73.             orderAmount = productInfo.getProductPrice()
  74.                     .multiply(new BigDecimal(orderDetail.getProductQuantity()))
  75.                     .add(orderAmount);
  77.             //订单详情入库
  78.             orderDetail.setDetailId(KeyUtil.genUniqueKey());
  79.             orderDetail.setOrderId(orderId);
  80.             BeanUtils.copyProperties(productInfo, orderDetail);
  81.             orderDetailRepository.save(orderDetail);
  83. //            CartDTO cartDTO = new CartDTO(orderDetail.getProductId(), orderDetail.getProductQuantity());
  84. //            cartDTOList.add(cartDTO);
  85.         }
  88.         //3. 写入订单数据库（orderMaster和orderDetail）
  89.         OrderMaster orderMaster = new OrderMaster();
  90.         orderDTO.setOrderId(orderId);
  91.         BeanUtils.copyProperties(orderDTO, orderMaster);
  92.         orderMaster.setOrderAmount(orderAmount);
  93.         orderMaster.setOrderStatus(OrderStatusEnum.NEW.getCode());
  94.         orderMaster.setPayStatus(PayStatusEnum.WAIT.getCode());
  95.         orderMasterRepository.save(orderMaster);
  97.         //4. 扣库存
  98.         List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream().map(e ->
  99.                 new CartDTO(e.getProductId(), e.getProductQuantity())
  100.         ).collect(Collectors.toList());
  101.         productService.decreaseStock(cartDTOList);
  103.         // 发送websocket消息
  104.         webSocket.sendMessage(orderDTO.getOrderId());
  106.         return orderDTO;
  107.     }
  109.     @Override
  110.     public OrderDTO findOne(String orderId) {
  112.         OrderMaster orderMaster = orderMasterRepository.findOne(orderId);
  113.         if (orderMaster == null) {
  114.             throw new SellException(ResultEnum.ORDER_NOT_EXIST);
  115.         }
  117.         List<OrderDetail> orderDetailList = orderDetailRepository.findByOrderId(orderId);
  118.         if (CollectionUtils.isEmpty(orderDetailList)) {
  119.             throw new SellException(ResultEnum.ORDERDETAIL_NOT_EXIST);
  120.         }
  122.         OrderDTO orderDTO = new OrderDTO();
  123.         BeanUtils.copyProperties(orderMaster, orderDTO);
  124.         orderDTO.setOrderDetailList(orderDetailList);
  126.         return orderDTO;
  127.     }
  129.     @Override
  130.     public Page<OrderDTO> findList(String buyerOpenid, Pageable pageable) {
  131.         Page<OrderMaster> orderMasterPage = orderMasterRepository.findByBuyerOpenid(buyerOpenid, pageable);
  133.         List<OrderDTO> orderDTOList = OrderMaster2OrderDTOConverter.convert(orderMasterPage.getContent());
  135.         return new PageImpl<OrderDTO>(orderDTOList, pageable, orderMasterPage.getTotalElements());
  136.     }
  138.     @Override
  139.     @Transactional
  140.     public OrderDTO cancel(OrderDTO orderDTO) {
  141.         OrderMaster orderMaster = new OrderMaster();
  143.         //判断订单状态
  144.         if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
  145.             log.error("【取消订单】订单状态不正确, orderId={}, orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus());
  146.             throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
  147.         }
  149.         //修改订单状态
  150.         orderDTO.setOrderStatus(OrderStatusEnum.CANCEL.getCode());
  151.         BeanUtils.copyProperties(orderDTO, orderMaster);
  152.         OrderMaster updateResult = orderMasterRepository.save(orderMaster);
  153.         if (updateResult == null) {
  154.             log.error("【取消订单】更新失败, orderMaster={}", orderMaster);
  155.             throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
  156.         }
  158.         //返回库存
  159.         if (CollectionUtils.isEmpty(orderDTO.getOrderDetailList())) {
  160.             log.error("【取消订单】订单中无商品详情, orderDTO={}", orderDTO);
  161.             throw new SellException(ResultEnum.ORDER_DETAIL_EMPTY);
  162.         }
  163.         List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream()
  164.                 .map(e -> new CartDTO(e.getProductId(), e.getProductQuantity()))
  165.                 .collect(Collectors.toList());
  166.         productService.increaseStock(cartDTOList);
  168.         //如果已支付, 需要退款
  169.         if (orderDTO.getPayStatus().equals(PayStatusEnum.SUCCESS.getCode())) {
  170.             payService.refund(orderDTO);
  171.         }
  173.         return orderDTO;
  174.     }
  176.     @Override
  177.     @Transactional
  178.     public OrderDTO finish(OrderDTO orderDTO) {
  179.         //判断订单状态
  180.         if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
  181.             log.error("【完结订单】订单状态不正确, orderId={}, orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus());
  182.             throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
  183.         }
  185.         //修改订单状态
  186.         orderDTO.setOrderStatus(OrderStatusEnum.FINISHED.getCode());
  187.         OrderMaster orderMaster = new OrderMaster();
  188.         BeanUtils.copyProperties(orderDTO, orderMaster);
  189.         OrderMaster updateResult = orderMasterRepository.save(orderMaster);
  190.         if (updateResult == null) {
  191.             log.error("【完结订单】更新失败, orderMaster={}", orderMaster);
  192.             throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
  193.         }
  195.         //推送微信模版消息
  196.         pushMessageService.orderStatus(orderDTO);
  198.         return orderDTO;
  199.     }
  201.     @Override
  202.     @Transactional
  203.     public OrderDTO paid(OrderDTO orderDTO) {
  204.         //判断订单状态
  205.         if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
  206.             log.error("【订单支付完成】订单状态不正确, orderId={}, orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus());
  207.             throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
  208.         }
  210.         //判断支付状态
  211.         if (!orderDTO.getPayStatus().equals(PayStatusEnum.WAIT.getCode())) {
  212.             log.error("【订单支付完成】订单支付状态不正确, orderDTO={}", orderDTO);
  213.             throw new SellException(ResultEnum.ORDER_PAY_STATUS_ERROR);
  214.         }
  216.         //修改支付状态
  217.         orderDTO.setPayStatus(PayStatusEnum.SUCCESS.getCode());
  218.         OrderMaster orderMaster = new OrderMaster();
  219.         BeanUtils.copyProperties(orderDTO, orderMaster);
  220.         OrderMaster updateResult = orderMasterRepository.save(orderMaster);
  221.         if (updateResult == null) {
  222.             log.error("【订单支付完成】更新失败, orderMaster={}", orderMaster);
  223.             throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
  224.         }
  226.         return orderDTO;
  227.     }
  229.     @Override
  230.     public Page<OrderDTO> findList(Pageable pageable) {
  231.         Page<OrderMaster> orderMasterPage = orderMasterRepository.findAll(pageable);
  233.         List<OrderDTO> orderDTOList = OrderMaster2OrderDTOConverter.convert(orderMasterPage.getContent());
  235.         return new PageImpl<>(orderDTOList, pageable, orderMasterPage.getTotalElements());
  236.     }
  237. }

发表评论

表情：
评论列表 （有 0 条评论，524人围观）

还没有评论，来说两句吧...

相关阅读