WebSocket使用

最新推荐文章于 2025-03-13 16:26:47 发布
最新推荐文章于 2025-03-13 16:26:47 发布
阅读量403 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java websocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34623714/article/details/115691350

文章目录

前言

WebSocket与前端消息通讯应用，提供连接建立、关闭，发生错误，数据接收、发送，权限校验（待补充）等方法
* 支持监控在线连接数
* 支持发送消息并回调结果，类似HTTP形式

一、WebSocket是什么？

	WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。
	WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

websocket的特点

	WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。
	WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。
	在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。
	浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接交换数据。

二、使用步骤

1.消息通讯处理服务代码

import java.io.IOException;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

import javax.websocket.CloseReason;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.SendHandler;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import com.linkcm.sxssy.espms.job.websocket.model.MsgResult;

/***  
     * <b>function: WebSocket服务
     * 提供连接建立、关闭，发生错误，数据接收、发送，权限校验（待补充）等方法
     * 支持监控在线连接数
     * 支持发送消息并回调结果，类似HTTP形式
     * </b>
 	 * @project sxssy-espms-job
 	 * @package com.linkcm.sxssy.espms.job.websocket.Service
 	 * @filename WebSocketService.java
 	 * @createtime 2021年4月13日 下午4:45:15  
 	 * @author peibinchen
 	 */
@ServerEndpoint("/websocket/{token}/{userName}")
@Component
public class WebSocketService {

    private final static Logger log = LoggerFactory.getLogger(WebSocketService.class);

    // 存放每个客户端对应的WebSocket对象
    private final static ConcurrentHashMap<String, WebSocketService> webSocketServices =
            new ConcurrentHashMap<String, WebSocketService>();
    
    // 存放待处理的ICallBack回调对象
    private final static ConcurrentHashMap<String, ICallBack> callBackMap =
            new ConcurrentHashMap<String, ICallBack>();
    
    // 当前在线连接数
    private final static AtomicInteger onlineCount = new AtomicInteger();
    // 回调超时时间，单位：毫秒
    public final static int WAIT_TIME = 30000;
    // 回调超时时间，单位：毫秒
    public final static String REAL_TIME_FALG = "【realTime】";
    // 回调超时时间，单位：毫秒
    public final static String REAL_TIME_KEY_VALUE_SPLIT = "=>";

    // 与某个客户端的连接会话
    private Session session;
    private String token;
    private String userName;

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam(value = "token") String token, @PathParam(value = "userName") String userName) {
        this.session = session;
        this.token = token;
        this.userName = userName;
        
        boolean security = isAuth(token, userName);
        if (security == false) {
            try {
                session.close(new CloseReason(CloseReason.CloseCodes.CANNOT_ACCEPT, "Illegal token"));
            } catch (IOException e) {
                log.error("close session ocurre error: {} .", e.getMessage());
            }
            return;
        }
        
        webSocketServices.put(this.session.getId() + "_" + userName, this);
        //在线数加1
        addOnlineCount();           
        log.info("有新窗口开始监听:"+session.getId()+", userName:"+this.userName+", 当前在线会话数为:" + getOnlineCount());
    }
    
    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        webSocketServices.remove(this.session.getId());
        //在线数减1
        subOnlineCount();           
        log.info("有一连接关闭！当前在线会话数为:" + getOnlineCount());
    }

    /**
     * 出现错误时处理方法
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误",error);
    }
    
    /**
     * 收到客户端消息后调用的方法
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("【服务端】收到来自窗口"+session.getId()+"的信息:"+message);
        if (isHeartMessage(message)) return;
        
        /*
         * 如果消息格式为："【realTime】"+{key}+"=>"+{data}，则表示是实时消息，特殊处理，并执行回调函数
         */
        if(message.startsWith(REAL_TIME_FALG)) {
            String dataMsg = message.substring(REAL_TIME_FALG.length());
            if(!dataMsg.contains(REAL_TIME_KEY_VALUE_SPLIT)) {
                log.error("实时消息格式有误:{}", dataMsg);
            }
            String[] dataArr = dataMsg.split(REAL_TIME_KEY_VALUE_SPLIT);
            String key = dataArr[0];     // 回调函数存储的key值
            String data = dataArr[1];    // 真实数据部分
            log.info("data:{}", data);
            
            ICallBack callBack = callBackMap.get(key);  // 获取回调函数
            if(callBack != null) {
                callBack.solve(data);    // 执行回调函数
                callBackMap.remove(key); // 移除待处理回调函数
            }
        }
    }
    
    /**
     * 推送消息
     * SendHandler为发送成功后的处理器
     * SendHandler sendHandler = new SendHandler() {
                @Override
                public void onResult(SendResult result) {
                    log.info(result.toString());
                }
            };
     */
    public void sendMessage(String message, SendHandler sendHandler) {
        try {
            // 异步发送消息
            this.session.getAsyncRemote().sendText(message, sendHandler);
        } catch (Exception e) {
            log.error("send to application: {} fail.", message);
        }
    }
    
    /**
     * 推送消息（异步）
     */
    public void sendMessage(String message) {
        try {
            // 异步发送消息
            this.session.getAsyncRemote().sendText(message);

        } catch (Exception e) {
            log.error("send to application: {} fail.", message);
        }
    }
    
    /**
     * 推送消息，anyc=true为异步，anyc为false为同步
     */
    public void sendMessage(String message, boolean anyc) {
        try {
            sendMessage(this.session, message, anyc);
        } catch (Exception e) {
            log.error("send to application: {} fail.", message);
        }
    }
    
    /**
     * 推送消息，anyc=true为异步，anyc为false为同步
     */
    public void sendMessage(Session session, String message, boolean anyc) {
        try {
            if(anyc) {
                // 异步发送消息
                session.getAsyncRemote().sendText(message);
            } else {
                // 同步发送消息
                session.getBasicRemote().sendText(message);
            }
        } catch (Exception e) {
            log.error("send to application: {} fail.", message);
        }
    }
    
    /**  
     * sendForBack:      发送消息并支持回调函数
     * @author chenpb
     * @param key        回调key值，用于回调时判断，执行对应回调函数
     * @param msg        发送的消息
     * @param callBack   回调函数
     */
    public void sendForBack(String key, String msg, ICallBack callBack) {
        callBackMap.put(key, callBack);
        this.sendMessage(msg);
    }
    
    /**  
     * sendForBack: 发送消息并等待回调结果
     * 实时消息格式为："【realTime】"+{key}+"=>"+{data}
     * @author chenpb
     * @param key
     * @param msg
     * @return
     * @throws InterruptedException  
     */
    public MsgResult sendForBack(String key, String message) throws InterruptedException {
        final MsgResult msgResult = new MsgResult();
        // 发送消息
        this.sendForBack(key, message, new ICallBack(){
            @Override
            public void solve(String result) {
                log.info("回调数据：{}", result);
                synchronized (msgResult) {
                    msgResult.setResult(result);
                    msgResult.notifyAll();
                }
            }
        });
        // 等待处理，不管有没超时，最终都会移除回调函数
        synchronized(msgResult) {
            long start = System.currentTimeMillis();
            log.info("等待开始");
            msgResult.wait(WAIT_TIME);   // 超时时间
            long end = System.currentTimeMillis();
            log.info("等待结束，等待时间：{}s", (end - start)/1000);
            
            WebSocketService.getCallBackMap().remove(key);
            log.info("待回调函数数量：{}", WebSocketService.getCallBackMap().size());
        }
        return msgResult;
    }
    
    /**
     * 判断是否是心跳消息
     */
    public boolean isHeartMessage(String message) {
        // ToDo ...
        return false;
    }

    /**
     * 鉴权
     */
    private boolean isAuth(String token, String userName) {
        // ToDo ...
        return true;
    }
    
    public int getOnlineCount() {
        return onlineCount.get();
    }

    private void addOnlineCount() {
        onlineCount.incrementAndGet();
    }

    private void subOnlineCount() {
        onlineCount.decrementAndGet();
    }
    
    public static ConcurrentHashMap<String, WebSocketService> getAgentserverendpoints() {
        return webSocketServices;
    }
    
    public static ConcurrentHashMap<String, ICallBack> getCallBackMap() {
        return callBackMap;
    }
    
    public WebSocketService getAgentServerEndpoint(String userName) {
        for(Entry<String, WebSocketService> entry : webSocketServices.entrySet()) {
            if(entry.getKey().equals(userName)) {
                return entry.getValue();
            }
        }
        return null;
    }
    
    public Session getSession() {
        return session;
    }
}

2.回调接口

代码如下（示例）：

/***  
 * <b>function: 回调接口</b>
 * @project sxssy-espms-job
 * @package com.linkcm.sxssy.espms.job.common.job
 * @filename IcallBack.java
 * @createtime 2021年4月13日 下午3:16:04  
 * @author peibinchen
 */
public interface ICallBack {
    public void solve(String result);
}

3.http接口服务

提供WebSocket模拟http接口形式的实时消息通讯接口

import io.swagger.annotations.ApiOperation;

import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;

import lombok.extern.slf4j.Slf4j;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.linkcm.sxssy.espms.job.common.bean.ResponseResult;
import com.linkcm.sxssy.espms.job.common.util.RandomFlagUtils;
import com.linkcm.sxssy.espms.job.common.util.RestResultUtils;
import com.linkcm.sxssy.espms.job.websocket.Service.WebSocketService;
import com.linkcm.sxssy.espms.job.websocket.model.MsgResult;
import com.linkcm.sxssy.espms.job.websocket.model.ReqMsgData;

/***  
     * <b>function: websocket http接口服务</b>
 	 * @project sxssy-espms-job
 	 * @package com.linkcm.sxssy.espms.job.websocket.Controller
 	 * @filename WebSocketController.java
 	 * @createtime 2021年4月14日 上午9:51:37  
 	 * @author peibinchen
 	 */
@Slf4j
@RestController
@RequestMapping("/websocket")
public class WebSocketController {

	/**  
	 * test: 测试消息发送并回调方法
	 * @author chenpb
	 * @return
	 * @throws InterruptedException  
	 */
	@ApiOperation(value = "", notes = "")
    @GetMapping(value = "/test")
    public ResponseResult<Object> test() throws InterruptedException {
	    log.info("********* websocket实时推送数据开始  **************");
	    
	    /*
	     * 测试数据
	     */
	    String key = "test";
	    String jsonData = "【realTime】" + key + "=>测试";
	    
        ConcurrentHashMap<String, WebSocketService> service = 
                WebSocketService.getAgentserverendpoints();

        MsgResult msgResult = new MsgResult();
        
        for(Entry<String, WebSocketService> entry : service.entrySet()) {
            WebSocketService point = entry.getValue();
            
            // 获取待发送消息
            log.info("发送的消息：" + jsonData);
            
            // 发送消息
            msgResult = point.sendForBack(key, jsonData);
        }
        
        log.info("********* websocket实时推送数据结束 **************");
        return RestResultUtils.successResult(msgResult.getResult());
    }
	
	/**  
     * test: 消息发送并回调
     * @author chenpb
     * @return
     * @throws InterruptedException  
     */
    @ApiOperation(value = "", notes = "")
    @PostMapping(value = "/sendForBack")
    public ResponseResult<Object> sendForBack(@RequestBody ReqMsgData reqMsgData) throws InterruptedException {
        log.info("********* websocket实时推送消息开始  **************");
        
        String key = RandomFlagUtils.randomDateTime();
        String msg = WebSocketService.REAL_TIME_FALG + key + WebSocketService.REAL_TIME_KEY_VALUE_SPLIT + reqMsgData.getData();
        
        ConcurrentHashMap<String, WebSocketService> service = 
                WebSocketService.getAgentserverendpoints();

        MsgResult msgResult = new MsgResult();
        
        for(Entry<String, WebSocketService> entry : service.entrySet()) {
            WebSocketService point = entry.getValue();
            
            // 获取待发送消息
            log.info("发送的消息：" + msg);
            
            // 发送消息
            msgResult = point.sendForBack(key, msg);
        }
        
        log.info("********* websocket实时推送消息结束 **************");
        return RestResultUtils.successResult(msgResult.getResult());
    }
}

4.回调结果对象

import lombok.Data;

/***  
 * <b>function: 回调结果对象</b>
 * @project sxssy-espms-job
 * @package com.linkcm.sxssy.espms.job.common.job
 * @filename MsgResult.java
 * @createtime 2021年4月13日 下午4:05:56  
 * @author peibinchen
 */
@Data
public class MsgResult {

    public String result;
}

5.http请求参数实体

import lombok.Data;

/***  
 * <b>function: http请求参数实体</b>
 * @project sxssy-espms-job
 * @package com.linkcm.sxssy.espms.job.websocket.model
 * @filename ReqMsgData.java
 * @createtime 2021年4月13日 下午5:22:56  
 * @author peibinchen
 */
@Data
public class ReqMsgData {

    private String data;
    
}

参考资料

https://www.jianshu.com/p/4e678e639161

总结

qq_34623714
关注
基于Token认证的WebSocket连接
weixin_33937499的博客
10-31 1万+
概要 WebSocket作为一种支持浏览器与服务器全双工通信的协议，对于复杂的前端应用，在交互体验和性能的改进上，是一种非常合适的解决方案。随着WebSocket更多地应用于生产开发，安全也成为了必须要关注的问题。 关于安全有一个可能的误区是：如果用户通过了web应用的认证（登录了系统），建立的WebSocket连接，就也是经过认证的。实际上，这是两个完...
java websocket @ServerEndpoint注解说明
weixin_33913332的博客
04-27 7512
http://www.blogjava.net/qbna350816/archive/2016/07/24/431302.html https://segmentfault.com/q/1010000004955225 https://www.cnblogs.com/interdrp/p/4091056.html   框架是workermansocket.io 使用四种框架分别实现百万w...
传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序
java思维导图
05-02 1万+
小Hub领读：通过websocket的两种使用方式，让你更加深入理解用法。很多人不懂websocket怎么辨别是谁发送过来的，文中说到实现WebSocketConfigurer接口，定义...
websocket @ServerEndpoint
m0_37346206的博客
04-12 1202
WebSocket是JavaEE7新支持的： Javax.websocket.server包含注解，类，接口用于创建和配置服务端点 Javax.websocket包则包含服务端点和客户断电公用的注解，类，接口，异常 创建一个编程式的端点，需要继承Endpoint类，重写它的方法。 创建一个注解式的端点，将自己的写的类以及类中的一些方法用前面提到的包中的注解装...
前端在WebSocket中加入Token
weixin_47793340的博客
02-06 8120
在WebSocket通信中加入Token主要是为了实现身份验证和授权，确保只有经过验证的用户可以建立WebSocket连接。由于WebSocket API本身不支持直接在连接时设置HTTP头部，因此需要采用一些变通的方法来传递Token。
websocket使用案例
08-28
在这个"WebSocket使用案例"中，我们可以预期会了解到以下关键点： 1. **WebSocket握手**：WebSocket连接的建立始于客户端发起一个HTTP Upgrade请求，服务器回应101 Switching Protocols状态码，表示同意升级到...
WebSocket 使用教程
最新发布
kalle2021的博客
03-13 1489
WebSocket 是一种支持服务器与客户端全双工通信的网络协议，在实时性要求高的应用场景中优势显著。本文详细介绍了 WebSocket 的基本概念，包括握手过程、数据帧及连接管理等；阐述了客户端与服务器端的使用方法，并给出完整示例。同时，对比分析了 WebSocket 的优势，如实时性高、带宽消耗少等，以及劣势，如安全存挑战、服务器资源占用大等。旨在帮助开发者全面了解 WebSocket，以便在实际项目中合理应用 。
Python 中的 WebSocket 使用
pumpkin84514的博客
08-12 2737
WebSocket 是一种网络通信协议，能够在客户端和服务器之间建立全双工（双向）通信通道。这种连接使得双方可以在无需重新建立连接的情况下随时发送数据，适合需要实时数据传输的场景。WebSocket 在需要实时双向通信的场景下非常有用，如聊天应用、实时数据更新等。在 Python 中，可以使用websockets库或FastAPI框架来实现 WebSocket 服务。通过掌握这些库的 API 和实际应用场景，可以轻松构建实时通信应用。
C# WebSocket使用实例源码，包含服务端和客户端
03-13
总的来说，这个"C# WebSocket使用实例"是一个很好的学习资源，它涵盖了WebSocket的基本概念和C#实现细节。通过研究和运行这个示例，开发者可以更好地理解和掌握WebSocket在实际项目中的应用，特别是在需要实时数据...
go-websocket-examples:Go语言WebSocket使用例子
05-16
本项目"Go语言WebSocket使用例子"提供了一系列示例，帮助开发者理解和实践Go中的WebSocket编程。 在Go中，WebSocket的实现主要依赖于`gorilla/websocket`库，这是一个非常流行的WebSocket库，提供了易于使用的API。...
serverendpoint注解_传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序...
weixin_39637723的博客
12-06 1万+
小Hub领读：通过websocket的两种使用方式，让你更加深入理解用法。很多人不懂websocket怎么辨别是谁发送过来的，文中说到实现WebSocketConfigurer接口，定义拦截器可以绑定用户信息，还有其他很多，细细品，对比看比较好！文末有源码地址~对了，看完记得点个[ 在看 ]支持一下哈。作者：编码妙妙屋https://www.skypyb.com/2019/02/jish...
WebSocket详解
Erica_1230的专栏
04-29 1418
WebSocket 前世今生 众所周知，Web 应用的交互过程通常是客户端通过浏览器发出一个请求，服务器端接收请求后进行处理并返回结果给客户端，客户端浏览器将信息呈现，这种机制对于信息变化不是特别频繁的应用尚可，但对于实时要求高、海量并发的应用来说显得捉襟见肘，尤其在当前业界移动互联网蓬勃发展的趋势下，高并发与用户实时响应是 Web 应用经常面临的问题，比如金融证券的实时信息，Web 导
WebSocket之ServerEndPoint
热门推荐
兜兜里全是糖_博客
10-13 2万+
WebSocket是JavaEE7新支持的：   The javax.websocket.server package contains annotations, classes, and interfaces to create and configure server endpoints.     Javax.websocket.server包含注解，类，接口用于创建和配置服务端点 T
Websocket带token发起连接
华灯初上
08-04 1万+
今天碰到一个需要在连接websocket服务时提交token的业务场景，无奈websocket不支持同时提交header，翻阅官方文档时候发现了可以携带一个自定义协议，我们可以通过将token存放在自定义协议中达到提交token的目的。 根据文档，我们调整下代码: //请务必注意，协议提交的是一个字符串数组类型。 var socket = new WebSocket('wss://url',['用户的token']); 好，这样我们的前端改造就完成了，简单吧～。 接下来就是后端的取值.
websocket jwt token
shelutai的博客
03-20 4124
在websocket中，目前未提供修改请求头字段的方法，不过可以借助于“Sec-WebSocket-Protocol”，将token放入请求头中，后端收到请求后，从请求头中取得token做校验。另外需要注意的是，在响应头上添加Sec-Websocket-Protocol,如下是在grilla/websocket响应中设置Sec-Websocket-Protocol的方式。后端接收到请求后，从header中取出“Sec-WebSocket-Protocol”，做校验。在后面加上[这里是token内容]。
websocket如何在header中携带token参数
weixin_69043813的博客
10-20 7957
【代码】websocket如何在header中携带token参数。
Websocket实现token认证方式
Cain的博客
07-26 1万+
websocket token认证
Springboot使用@ServerEndpoint做Websocket遇到前后端分离跨域问题，即网页链接和wss链接不一样引起的跨域问题，亲测解决方案。
qq_38680405的博客
03-04 3149
Springboot使用@ServerEndpoint做Websocket遇到前后端分离跨域问题，即网页链接和wss链接不一样引起的跨域问题，亲测解决方案。
websocket使用
09-25
WebSocket使用一个特殊的HTTP握手请求来建立连接，然后使用持续连接（persistent connection）来进行实时的双向数据传输。它基于TCP协议，可以使用HTTP或HTTPS进行握手。与传统的HTTP请求-响应模式相比，WebSocket...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值