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

前后端分离项目–二手交易平台小程序

即时聊天

这个使用了websocket,在springboot下使用很简单。前端是小程序,这个就比较坑,小程序即时聊天上线需要域名并且使用wss协议,就是ws+ssl更加安全。但是要上线这还不够,你必须为企业主体开发者。个人开发者即时聊天属于社交、不在服务类目内,审核会不通过!!!
功能 :我们的小程序是个二手交易小程序,即时聊天对于一个后台服务器只是单核2g的来说有点抗不住。所以在双方都在线的时候没有存储聊天消息,只是在单方不在线时存储了离线消息。而且只能发三条离线消息。仿照了csdn的聊天。
使用:我们是点击进入聊天之后才发起websocket,这就造成了一个问题,就是用户退出到消息列表又重新点进入就会重新发送一个websocket请求。每次请求session都不一样。而且微信限制一个用户只能同时发起5个请求。一开始前端没能退出聊天页面就端开,就错误唉!!。只能后台去断使用sessioin.close()会调用onClose()方法 这个session是你要断的session。不过后来前端可以自己断了就nice了!
效果
SpringBoot----即时聊天(webSocket)_第1张图片
SpringBoot----即时聊天(webSocket)_第2张图片

数据库设计

  • 对于展示消息聊天列表使用了一张表。last_context为对方发送的最后一条消息。只要有一方点击了私信进入聊天页面就会往表中插入两条记录。方便之后删除聊天,毕竟一方删除不能让另一方也看不到信息
    SpringBoot----即时聊天(webSocket)_第3张图片
  • 对于消息详细离线内容,则使用了另外一张表。
    SpringBoot----即时聊天(webSocket)_第4张图片
    后台代码
    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

你可能感兴趣的:(前后端分离项目,数据库,websocket,java,小程序)