webSocket实现在线聊天

最新推荐文章于 2024-08-01 14:36:31 发布
最新推荐文章于 2024-08-01 14:36:31 发布
阅读量795 收藏 1
点赞数
分类专栏： java webSocket 文章标签： webSocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chendeyou5/article/details/80916472
版权

需要的jar

<!-- start websocket -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-messaging</artifactId>
            <version>4.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-websocket</artifactId>
            <version>4.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.3.3</version>
        </dependency>
        <!-- end websocket -->

实现具体类：

1、SpringWebSocketHandlerInterceptor类

 

package com.jero.esc.web.webSocket;

import com.jero.esc.common.utils.StringUtil;
import com.jero.esc.po.userinfo.LogInfo;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;

import javax.servlet.http.HttpSession;
import java.util.Map;

public class SpringWebSocketHandlerInterceptor extends HttpSessionHandshakeInterceptor {

    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
                                   Map<String, Object> attributes) throws Exception {
    	/** 在拦截器内强行修改websocket协议，将部分浏览器不支持的 x-webkit-deflate-frame 扩展修改成 permessage-deflate */
    	if(request.getHeaders().containsKey("Sec-WebSocket-Extensions")){
    		request.getHeaders().set("Sec-WebSocket-Extensions", "permessage-deflate");
    	}
        // TODO Auto-generated method stub
        System.out.println("Before Handshake");
        //获取当前Session
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
            HttpSession session = servletRequest.getServletRequest().getSession(false);
            if (session != null) {
                //使用userName区分WebSocketHandler，以便定向发送消息
                LogInfo currentUser=(LogInfo) session.getAttribute("logInfo");
                System.out.println(currentUser.getLogId());
                String userName = currentUser.getLogName();
                System.out.println(userName);
                String infoId = ((ServletServerHttpRequest) request).getServletRequest().getParameter("infoId");
                String receiveLogId = ((ServletServerHttpRequest) request).getServletRequest().getParameter("receiveLogId");
                String userId=currentUser.getLogId();
                String  toId="";
                if(StringUtil.isNotEmptys(infoId,receiveLogId)){
                    userId=currentUser.getLogId()+infoId;//发送者
                    toId=receiveLogId+infoId;//接收者
                }else{
                    receiveLogId="";
                    infoId="";
                }
                if (userName == null) {
                    userName = "default-system";
                }
                attributes.put("WEBSOCKET_USERNAME", userName);
                attributes.put("userId",userId);
                attributes.put("toId",toId);
                attributes.put("receiveLogId",receiveLogId);
                attributes.put("infoId",infoId);
                attributes.put("loginfoId",currentUser.getLogId());
            }else{

            }
        }
        return super.beforeHandshake(request, response, wsHandler, attributes);

    }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
                               Exception ex) {
        // TODO Auto-generated method stub
        super.afterHandshake(request, response, wsHandler, ex);
    }

}
2、SystemWebSocketHandler
 
 
package com.jero.esc.web.webSocket;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.jero.esc.common.utils.StringUtil;
import com.jero.esc.mapper.goodsinfo.ChatRecordMapper;
import com.jero.esc.mapper.userinfo.LogInfoMapper;
import com.jero.esc.po.goodsinfo.ChatRecord;
import com.jero.esc.po.userinfo.LogInfo;
import com.jero.esc.service.goodsinfo.IChatService;
import com.jero.esc.vo.goodsinfo.ChatRecordVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.socket.*;

import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class SystemWebSocketHandler implements WebSocketHandler {
    @Autowired
    private IChatService chatService;
    @Autowired
    private ChatRecordMapper chatRecordMapper;
    @Autowired
    private LogInfoMapper logInfoMapper;
    //当MyWebSocketHandler类被加载时就会创建该Map，随类而生
    public static final Map<String, WebSocketSession> userSocketSessionMap;
    static {
        userSocketSessionMap = new HashMap<String, WebSocketSession>();
    }
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        System.out.print("连接成功");
        String username= (String) session.getAttributes().get("WEBSOCKET_USERNAME");
        String userId=(String) session.getAttributes().get("userId");
        String toId=(String) session.getAttributes().get("toId");
        userSocketSessionMap.put(userId,session);
        System.out.println("当前用户数量: " + userSocketSessionMap.size());
        System.out.println("用户名 "+username);
        System.out.println("用户ID "+userId);
        if(StringUtil.isNotEmpty(toId)){
            if(userSocketSessionMap.get(toId)!=null){
                Map<String,Object> map=new HashMap<String, Object>();
                map.put("flag",true);
                sendMessageToUser(userId, new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(map)));
                sendMessageToUser(toId, new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(map)));
            }
        }

    }

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        String schatMessage = (String) message.getPayload();//用户输入
        System.out.println("用户输入" + schatMessage);
        if(message.getPayloadLength()==0)return;

        //得到Socket通道中的数据并转化为Message对象
        ChatRecord msg=new Gson().fromJson(message.getPayload().toString(),ChatRecord.class);

        Timestamp now = new Timestamp(System.currentTimeMillis());
        msg.setCreateTime(now);
        String toId=msg.getReceiveLogId()+msg.getInfoId();
        List<ChatRecordVo> recordVoList=chatRecordMapper.selectChatList((String) session.getAttributes().get("receiveLogId"));
        //将信息保存至数据库
       Map<String,Object> map=chatService.sendChat((String) session.getAttributes().get("loginfoId"),msg.getInfoId(),msg.getInfoType(),msg.getReceiveLogId(),msg.getContent());
       if(!(boolean)map.get("flag")){//如果保存数据库失败抛异常
           throw new RuntimeException(map.get("msg").toString());
       }else{
           msg.setRecordId((String) map.get("recordId"));
           //发送Socket信息
           //判断对方是否在线
           if(userSocketSessionMap.get(toId)==null){
               //判断对方是否在列表页
               if(userSocketSessionMap.get((String) session.getAttributes().get("receiveLogId"))!=null){
                   Map<String,Object> map1=new HashMap<String, Object>();
                   map1.put("flag",false);
                   for(ChatRecordVo recordVo:recordVoList){
                       if(recordVo.getInfoId().equals(msg.getInfoId())){//判断是否是第一次发送消息
                           map1.put("flag",true);//不是则推送未读消息+1
                           map1.put("infoId",msg.getInfoId());
                           map1.put("dateTimeStr",msg.getCreateTimeStr());
                           break;
                       }
                   }
                   if(!(boolean)map1.get("flag")){//如果是第一次发送消息，推送聊天列表信息
                       //聊天列表信息
                       for(ChatRecordVo recordVo: chatRecordMapper.selectChatList((String) session
                                       .getAttributes().get("receiveLogId"))){
                           if(recordVo.getInfoId().equals(msg.getInfoId())){
                               map1.put("record",recordVo);
                               break;
                           }
                       }
                   }
                   sendMessageToUser((String) session.getAttributes().get("receiveLogId"), new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(map1)));
               }
           }else{
               //在线直接推送消息
               sendMessageToUser(toId, new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(msg)));
           }
       }
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        String toId=(String) session.getAttributes().get("toId");
        if(StringUtil.isNotEmpty(toId)){
            if(userSocketSessionMap.get(toId)!=null){
                Map<String,Object> map=new HashMap<String, Object>();
                map.put("infoId",(String) session.getAttributes().get("infoId"));
                sendMessageToUser(toId, new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(map)));
            }
        }
    }

    @Override
    public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
        System.out.print("关闭连接");
        String userId=(String) webSocketSession.getAttributes().get("userId");
        System.out.println("WebSocket:"+webSocketSession.getAttributes().get("userId")+"close connection");
        Iterator<Map.Entry<String,WebSocketSession>> iterator = userSocketSessionMap.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<String,WebSocketSession> entry = iterator.next();
            if(entry.getValue().getAttributes().get("userId")==webSocketSession.getAttributes().get("userId")){
                userSocketSessionMap.remove(webSocketSession.getAttributes().get("userId"));
                System.out.println("WebSocket in staticMap:" + webSocketSession.getAttributes().get("userId") + "removed");
                break;
            }
        }
        System.out.println("用户数量: " + userSocketSessionMap.size());
        String toId=(String) webSocketSession.getAttributes().get("toId");
        if(StringUtil.isNotEmpty(toId)){
            if(userSocketSessionMap.get(toId)!=null){
                Map<String,Object> map=new HashMap<String, Object>();
                map.put("flag",false);
                sendMessageToUser(toId, new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(map)));
            }
        }
    }
    @Override
    public boolean supportsPartialMessages() {
        return false;
    }
    //发送信息的实现
    public void sendMessageToUser(String uid, TextMessage message)
            throws IOException {
        WebSocketSession session = userSocketSessionMap.get(uid);
        if (session != null && session.isOpen()) {
            session.sendMessage(message);
        }
    }

}
3、WebSocketConfig
 
package com.jero.esc.web.webSocket;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.client.standard.WebSocketContainerFactoryBean;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebMvc
@EnableWebSocket
public class WebSocketConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(systemWebSocketHandler(),"webSocket.do").addInterceptors(new SpringWebSocketHandlerInterceptor());

    }
    @Bean
    public WebSocketHandler systemWebSocketHandler(){
        return new SystemWebSocketHandler();
    }
    @Bean
    public WebSocketContainerFactoryBean createWebSocketContainer() {
        WebSocketContainerFactoryBean container = new WebSocketContainerFactoryBean();
        container.setMaxTextMessageBufferSize(8192);
        container.setMaxBinaryMessageBufferSize(8192);
        return container;
    }

}
前端连接webSocket

 

var isConnect=false;
    var webSocket;	 
    //判断当前浏览器是否支持WebSocket
	if('WebSocket' in window){
		webSocket = new WebSocket("ws://www.jindaoj.com:8083/webSocket.do?infoId=${infoId}&receiveLogId=${receiveLogId}");
		//webSocket = new WebSocket("ws://6xtbd9.natappfree.cc/escq/webSocket.do?infoId=${infoId}&receiveLogId=${receiveLogId}");
		console.log("link success");
	}else{
		alert('Not support websocket');
	}    
    webSocket.onopen = function(event){
        console.log("连接成功");
        isConnect=true;
        console.log(event);
    };
    webSocket.onerror = function(event){
        console.log("连接失败");
        isConnect=false;
        alert("对不起，连接失败，请检查您的网络情况");
    };
    webSocket.onclose = function(event){
        isConnect=false;
        console.log("Socket连接断开");
        alert("您已经断开连接，请重新连接");
        $(".btns2,.btns").click(function(){
            location.reload();
        });

    };
    webSocket.onmessage = function(event){
        //接受来自服务器的消息
        var message = JSON.parse(event.data);
        if(message.msg!=undefined){
            alert(message.msg);
        }else if(message.flag!=undefined){
            if(message.flag){
                $("#status").text("在线");
                $(".ChatHeadImg").css('-webkit-filter',"initial");
            }else{
                $(".ChatHeadImg").css("-webkit-filter","grayscale(100%)");
                $("#status").text("离线");
            }
        }else{
            $.ajax({
                url: path + '/wap/chat/updateReadStatusByAjax.html',
                data: {
                    recordId: message.recordId
                },
                dataType: 'json',
                type: 'post',
                success: function (res) {}
            });
            if(/.(gif|jpg|jpeg|png|gif|jpg|png)$/.test(message.content)){
                $(".chatBox-content-demo").append("<div class='clearfloat'>"+
                    "<div class='author-name'><small class='chat-date'>"+message.createTime+"</small></div>"+
                    "<div class='left'>"+
                    "<div class='chat-avatars'><img src='${receiveUserInfo.userPhoto}' alt='头像'/></div>"+
                    "<div class='chat-message' style='background:#fff'>"+
                    "<img src='"+message.content+"' alt='图片'></div></div></div>");
                //聊天框默认最底部
                $(document).ready(function () {
                    $("<img/>").attr("src",message.content).load(function() {//imgSrc是图片地址
                        var realHeight = this.height;
                        $("#chatBox-content-demo").scrollTop($("#chatBox-content-demo")[0].scrollHeight+realHeight);
                    })
                });
            }else{
                $(".chatBox-content-demo").append("<div class='clearfloat'>"+
                    "<div class='author-name'>"+
                    "<small class='chat-date'>"+message.createTime+"</small></div>"+
                    "<div class='left'>"+
                    "<div class='chat-avatars'><img src='${receiveUserInfo.userPhoto}' alt='头像'/></div>"+
                    "<div class='chat-message'>"+message.content+"</div> </div> </div>");
                //聊天框默认最底部
                $(document).ready(function () {
                    $("#chatBox-content-demo").scrollTop($("#chatBox-content-demo")[0].scrollHeight);
                });
            }

        }
    }

 

chendeyou5
关注
专栏目录
WebSocket实现在线聊天
皮蛋小粥的博客
04-03 1万+
这一篇文章前面部分我们会先介绍WebSocket协议的基本知识，在最后我们会用Spring Boot来集成WebSocket实现一个简单的在线聊天功能,单纯想看实现部分的话可以直接跳过前面介绍的部分。 前言 通常情况下，浏览器和服务器之间的消息通讯一般会使用Http协议，但是如果我们想服务器返回数据，我们必须先由浏览器发送请求给服务器，服务器才能响应这个请求。一般情况下Http协议基本能够满足我们...
使用 WebSocket 实现一个简易的在线聊天室（SpringBoot + Vue3，附源代码）
聂可以的博客
07-26 2831
使用 WebSocket 实现一个简易的在线聊天室（SpringBoot+Vue3，附源代码）
Java WebSocket 实现 在线聊天
qq_46020877的博客
08-03 443
Java WebSocket 实现 在线聊天 在线消息 demo
websocket 的简单应用
叶落挽枫的博客
02-27 816
今天我试着用websocket 搭建了一个简单的 网页即时通讯,记录一下步骤引入必须包,我用的是maven &lt;dependency&gt; &lt;groupId&gt;javax.websocket&lt;/groupId&gt; &lt;artifactId&gt;javax.websocket-api&lt;/artifactId&gt...
基于websocket实现在线聊天
最新发布
m0_69947483的博客
08-01 1027
WebSocket是一种在单个TCP连接上提供全双工通信的协议，它允许客户端和服务器之间进行实时数据传输。与传统的HTTP通信方式不同，WebSocket允许服务器主动向客户端推送数据，而不需要客户端先发起请求。
C#使用WebSocket实现在线聊天功能
11-29
本篇将深入探讨如何使用C#语言通过WebSocket实现在线聊天功能，并重点讲解如何实现消息的指定客户端发送。 首先，理解WebSocket协议的基础知识至关重要。WebSocket是一种在客户端和服务器之间建立长连接的协议，...
springboot+netty+webSocket实现在线聊天.zip
07-08
本项目“springboot+netty+webSocket实现在线聊天”就是针对这一需求提供的一种解决方案。它利用Spring Boot的便利性、Netty的高性能以及WebSocket的双向通信能力，创建了一个高效、稳定的实时聊天平台。 **Spring ...
JavaWeb--使用Websocket实现在线聊天功能-附件资源
03-02
JavaWeb--使用Websocket实现在线聊天功能-附件资源
websocket在线聊天源码_websocket实现一对一聊天
04-23
基于WebSocket实现网页版聊天，支持一对一聊天，功能包含登录页面、对话界面、好友列表、上下线提醒等。 运行步骤: 1、获取GoEasy Appkey 先到GoEasy官网（https://www.goeasy.io）注册一个账号，登录后，创建一个应用，就能得到您的appkey。 2、配置您的appkey 在service.js，将appkey替换为您自己的common key
c# ASP.MVC websocket在线聊天
01-12
C# MVCwebsocket在线聊天。项目使用Asp.net MVC技术结合websocket技术开发。
C# mvc websocket 在线聊天实例
07-10
C# mvc websocket 在线聊天实例
C# 使用websocket实现网页聊天功能Demo
01-15
代码请清晰简洁适合新手，利用html 5 websocket做个山寨版web聊天室(手写C#服务器)，C# 实现WebSocket服务端
基于Websocket的在线聊天源码
05-29
本人不擅长前端，jsp页面可能不适合所有分辨率，但是核心功能都在后台代码上，希望大家可以弄懂源码，写出性能更强的聊天功能！
Websocket 技术实践 实现在线聊天系统
qq_50909707的博客
10-13 3394
WebSocket是一种在单个TCP连接上进行全双工通信的协议。全双工：可以同时双向传输数据(B->A,A->B可以同时进行)。推送技术是建立在客户端服务器的一种机制，就是由服务器主动将信息发往客户端的技术。就像广播电台播音。
webSocket+Node+Js实现在线聊天（包含所有代码）
见贤思齐焉，见不贤内自省
05-24 1649
webSocket+Node+Js实现在线聊天（包含所有代码）
微信小程序 WebSocket 通信 —— 在线聊天
热门推荐
灵魂学者的博客
04-29 1万+
本篇通过WebSocket通信实现客户端(小程序)和服务器端(Node.js搭载的服务器)的对话聊天，客户端通过小程序的WebSocket API 实现，服务器使用Node.js来搭载简易的服务器。感兴趣的读者可以观览一下！
Java Websocket 实现在线聊天功能详解
【资源摘要信息】: "Java使用websocket实现在线聊天功能，通过WebSocket服务器和客户端的交互，实现多浏览器的实时通信。本文将展示如何在Java中设置WebSocket服务，并演示使用不同浏览器进行测试的效果。" 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值