SpringBoot----即時聊天(webSocket)

前后端分離專案–二手交易平臺小程式

即時聊天

這個使用了websocket，在springboot下使用很簡單，前端是小程式，這個就比較坑，小程式即時聊天上線需要域名并且使用wss協議，就是ws+ssl更加安全，但是要上線這還不夠，你必須為企業主體開發者，個人開發者即時聊天屬于社交、不在服務類目內，審核會不通過！！！
功能 ：我們的小程式是個二手交易小程式，即時聊天對于一個后臺服務器只是單核2g的來說有點抗不住，所以在雙方都在線的時候沒有存盤聊天訊息，只是在單方不在線時存盤了離線訊息，而且只能發三條離線訊息，仿照了csdn的聊天，
使用:我們是點擊進入聊天之后才發起websocket，這就造成了一個問題，就是用戶退出到訊息串列又重新點進入就會重新發送一個websocket請求，每次請求session都不一樣，而且微信限制一個用戶只能同時發起5個請求，一開始前端沒能退出聊天頁面就端開，就錯誤唉！！，只能后臺去斷使用sessioin.close()會呼叫onClose()方法 這個session是你要斷的session，不過后來前端可以自己斷了就nice了！
效果：

資料庫設計：

• 對于展示訊息聊天串列使用了一張表，last_context為對方發送的最后一條訊息，只要有一方點擊了私信進入聊天頁面就會往表中插入兩條記錄，方便之后洗掉聊天，畢竟一方洗掉不能讓另一方也看不到資訊
  
• 對于訊息詳細離線內容，則使用了另外一張表，
  
  后臺代碼：

  package com.w.wx.controller.WebSocket;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;
  import com.w.wx.domain.ChatMessage;
  import com.w.wx.service.ChatService;
  import com.w.wx.utils.ALToHMUtil;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Component;
  
  import javax.annotation.PostConstruct;
  import javax.websocket.*;
  import javax.websocket.server.PathParam;
  import javax.websocket.server.ServerEndpoint;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.atomic.AtomicInteger;
  
  @Slf4j
  @ServerEndpoint("/wx/{fromOpenid}/{toOpenid}")
  @Component
  public class WebSocketServer {
  
      public static WebSocketServer webSocketServer;
      @Autowired
      private ChatService chatService;
  
      @PostConstruct        //此注解的方法在bean加載前執行
      private void init() {
          webSocketServer = this;
          //初始化時將靜態化的interFaceInfoMapper進行了實體化
          webSocketServer.chatService = this.chatService;
      }
  
  
  	 //靜態變數，用來記錄當前在線連接數，應該把它設計成執行緒安全的，
      private static AtomicInteger onlineNum = new AtomicInteger();
  
      //concurrent包的執行緒安全HashMap，用來存放每個客戶端對應的WebSocketServer物件，
      private static ConcurrentHashMap<String, Session> sessionPools = new ConcurrentHashMap<>();
  
      //發送訊息
      public void sendMessage(Session session, ChatMessage message) throws IOException {
          if(session != null){
              synchronized (session) {
  
                  String s = JSONObject.toJSONString(message);
                  System.out.println("52 發送資料：" + s);
                  session.getBasicRemote().sendText(s);
              }
          }
      }
      //給指定用戶發送資訊
      public void sendInfo(String to_openid, ChatMessage message){
          Session session = sessionPools.get(to_openid);
  
          if(session == null){
              webSocketServer.chatService.addDeInfo(message);
          }else{
              try {
                  sendMessage(session, message);
              }catch (Exception e){
                  e.printStackTrace();
              }
          }
  
  
      }
      // 群發訊息
      public void broadcast(ChatMessage message){
      	for (Session session: sessionPools.values()) {
              try {
                  sendMessage(session, message);
              } catch(Exception e){
                  e.printStackTrace();
                  continue;
              }
          }
      }
  
  
  
      //收到客戶端資訊后，根據接收人的username把訊息推下去或者群發
      // to=-1群發訊息
      @OnMessage
      public void onMessage(String message) throws IOException{
          ChatMessage msg=JSON.parseObject(message, ChatMessage.class);
          sessionPools.get(msg.getToOpenid());
  
          webSocketServer.chatService.addInfo(message);
  
  
          if (msg.getToOpenid().equals("-1")) {
              broadcast(msg);
          } else {
              sendInfo(msg.getToOpenid(),msg);
          }
  
      }
  
  
  
      //建立連接成功呼叫
      @OnOpen
      public void onOpen(Session session, @PathParam(value = "fromOpenid") String fromOpenid,@PathParam(value = "toOpenid") String toOpenid) throws IOException {
  
          ArrayList<ChatMessage> list = webSocketServer.chatService.getAllNotRead(fromOpenid,toOpenid);
          if (!list.isEmpty()) {
              Iterator<ChatMessage> it = list.iterator();
              while (it.hasNext()) {
                  ChatMessage chatMessage = it.next();
                  chatMessage.setContent(ALToHMUtil.toUnicode(chatMessage.getContent()));
                  sendMessage(session, chatMessage);
                  log.info("115 當前用戶接收離線訊息" + chatMessage.toString());
              }
          }
  
          sessionPools.put(fromOpenid, session);
  
          addOnlineCount();
          System.out.println("125 "+fromOpenid + "加入webSocket！當前人數為" + onlineNum);
  
  
      }
  
      //關閉連接時呼叫
      @OnClose
      public void onClose(@PathParam(value = "fromOpenid") String fromOpenid) throws IOException {
  
          Session session = sessionPools.get(fromOpenid);
  
          session.close();
          sessionPools.remove(fromOpenid);
  
          subOnlineCount();
          System.out.println(fromOpenid + "斷開webSocket連接！當前人數為" + onlineNum);
  
      }
      //錯誤時呼叫
      @OnError
      public void onError(Session session, Throwable throwable){
         // System.out.println("發生錯誤");
          throwable.printStackTrace();
      }
  
      public static void addOnlineCount(){
          onlineNum.incrementAndGet();
      }
  
      public static void subOnlineCount() {
          onlineNum.decrementAndGet();
      }
      
      public static AtomicInteger getOnlineNumber() {
          return onlineNum;
      }
      
      public static ConcurrentHashMap<String, Session> getSessionPools() {
          return sessionPools;
      }
  }
  
  

  2021/4/27 20:33