Spring Boot使用WebSocket

最新推荐文章于 2023-12-07 15:55:38 发布
最新推荐文章于 2023-12-07 15:55:38 发布
阅读量171 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSL201816080304/article/details/103431309
版权

半夜学习，使我快乐（摸了摸有点凉的头）




文章目录

初识

一般来说，使用websocket有两种方式：

  • 使用sockjs
  • 使用Html5

使用Html5标准自然更方便简单，所以记录的是配合h5的使用方法。


个人总结步骤

总之。

【导入依赖】

【配置有关WebSocket的类】：注入ServerEndpointExporter

在这里插入图片描述

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
 
 
@Component
public class WebSocketConfig {
 
    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
 
}

建立【websocket服务】

示例代码：

（一）

import lombok.extern.apachecommons.CommonsLog;
import org.springframework.stereotype.Component;
 
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;
 
 
@Component
@CommonsLog
@ServerEndpoint("/websocket")
public class WebSocket {
 
    private Session session;
 
    private static CopyOnWriteArraySet<WebSocket> webSocketSet = new CopyOnWriteArraySet<>();
 
    @OnOpen
    public void onOpen(Session session){
        this.session = session;
        webSocketSet.add(this);
        log.info("新建一个连接，当前连接数：" + webSocketSet.size());
    }
 
    @OnClose
    public void onClose(){
        webSocketSet.remove(this);
        log.info("关闭了一个连接，当前连接数：" + webSocketSet.size());
    }
 
    @OnMessage
    public void onMessage(String message){
        log.info("发来的消息是：" + message);
    }
 
    public void sendMessage(String message){
        for(WebSocket webSocket : webSocketSet){
            log.info("广播消息：" + message);
            try {
                webSocket.session.getBasicRemote().sendText(message);
            } catch (IOException e){
                log.error(e.fillInStackTrace());
            }
 
        }
    }
 
 
}

（二）源码地址：

https://github.com/archine/springboot-websocket

/**
 * @author Gjing
 **/
@ServerEndpoint("/test")
@Component
@Slf4j
public class MyWebsocketServer {
    /**
     * 存放所有在线的客户端
     */
    private static Map<String, Session> clients = new ConcurrentHashMap<>();

    @OnOpen
    public void onOpen(Session session) {
        log.info("有新的客户端连接了: {}", session.getId());
        //将新用户存入在线的组
        clients.put(session.getId(), session);
    }

    /**
     * 客户端关闭
     * @param session session
     */
    @OnClose
    public void onClose(Session session) {
        log.info("有用户断开了, id为:{}", session.getId());
        //将掉线的用户移除在线的组里
        clients.remove(session.getId());
    }

    /**
     * 发生错误
     * @param throwable e
     */
    @OnError
    public void onError(Throwable throwable) {
        throwable.printStackTrace();
    }

    /**
     * 收到客户端发来消息
     * @param message  消息对象
     */
    @OnMessage
    public void onMessage(String message) {
        log.info("服务端收到客户端发来的消息: {}", message);
        this.sendAll(message);
    }

    /**
     * 群发消息
     * @param message 消息内容
     */
    private void sendAll(String message) {
        for (Map.Entry<String, Session> sessionEntry : clients.entrySet()) {
            sessionEntry.getValue().getAsyncRemote().sendText(message);
        }
    }
}

（三）源码地址

https://github.com/archine/springboot-websocket

/**
 * @author Gjing
 **/
@ServerEndpoint("/test-one")
@Component
@Slf4j
public class MyOneToOneServer {
    /**
     * 用于存放所有在线客户端
     */
    private static Map<String, Session> clients = new ConcurrentHashMap<>();

    private Gson gson = new Gson();

    @OnOpen
    public void onOpen(Session session) {
        log.info("有新的客户端上线: {}", session.getId());
        clients.put(session.getId(), session);
    }

    @OnClose
    public void onClose(Session session) {
        String sessionId = session.getId();
        log.info("有客户端离线: {}", sessionId);
        clients.remove(sessionId);
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        throwable.printStackTrace();
        if (clients.get(session.getId()) != null) {
            clients.remove(session.getId());
        }
    }

    @OnMessage
    public void onMessage(String message) {
        log.info("收到客户端发来的消息: {}", message);
        this.sendTo(gson.fromJson(message, Message.class));
    }

    /**
     * 发送消息
     *
     * @param message 消息对象
     */
    private void sendTo(Message message) {
        Session s = clients.get(message.getUserId());
        if (s != null) {
            try {
                s.getBasicRemote().sendText(message.getMessage());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

（四）

@ServerEndpoint("/link/{md5}")
@Component
public class AndroidThingsSocketServer {

    private static ConcurrentHashMap<String,AndroidThingsSocketServer> webSocketMap = new ConcurrentHashMap<>();

    private Session session;
    private String md5;
    private static MeetingRoomService meetingRoomService;



    //接受新的连接，并判断权限是否足够
    @OnOpen
    public void onOpen(Session session,@PathParam("md5") String md5) throws IOException {
        if (meetingRoomService==null){
            meetingRoomService=SpringUtil.getBean(MeetingRoomService.class);
        }
        if (!meetingRoomService.judgeMeeting(md5)){
            session.close();
            System.out.println("连接失败");
            return;//错误连接，断开
        }
        this.session=session;
        this.md5=md5;
        webSocketMap.put(md5,this);
    }

    @OnClose
    public void onClose() throws IOException {
        webSocketMap.remove(this.md5);//连接断开，移除session
        this.session.close();
    }

    //发送消息
    public static boolean openDoor(String md5){
        AndroidThingsSocketServer socketServer=webSocketMap.get(md5);
        if (socketServer!=null){
            try {
                //发生成功
                socketServer.session.getBasicRemote().sendText("open");
                return true;
            }catch (IOException e){
                return false;
            }
        }
        return false;
    }

    public static boolean openDoor(int rid){
        MeetingRoom meetingRoom=new MeetingRoom();
        if (meetingRoom==null){
            meetingRoom=meetingRoomService.getMeetingRoomWithRoomId(rid);
            if (meetingRoom==null){
                return false;
            }
        }
        return openDoor(meetingRoom.getMacAddress());
    }
}

在业务中调用

@Autowired
private WebSocket webSocket;
 
...
 
webSocket.sendMessage("new-order");

例子一

pom.xml添加依赖

核心是@ServerEndpoint这个注解。这个注解是Javaee标准里的注解，tomcat7以上已经对其进行了实现，如果是用传统方法使用tomcat发布项目，只要在pom文件中引入javaee标准即可使用。

<dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
      <scope>provided</scope>
</dependency>

但使用springboot的内置tomcat时，就不需要引入javaee-api了，spring-boot已经包含了。使用springboot的websocket功能首先引入springboot组件。

springboot的高级组件会自动引用基础的组件，像spring-boot-starter-websocket就引入了spring-boot-starter-web和spring-boot-starter，所以不要重复引入。

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
            <version>1.3.5.RELEASE</version>
 </dependency>


@ServerEndpoint

使用@ServerEndpoint创立websocket endpoint

首先要注入ServerEndpointExporter，这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint。

要注意，如果使用独立的servlet容器，而不是直接使用springboot的内置容器，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。

@Configuration
public class WebSocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

接下来就是写websocket的具体实现类，很简单，直接上代码：

@ServerEndpoint(value = "/websocket")
@Component
public class MyWebSocket {
    //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;

    //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
    private static CopyOnWriteArraySet<MyWebSocket> webSocketSet = new CopyOnWriteArraySet<MyWebSocket>();

    //与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;

    /**
     * 连接建立成功调用的方法*/
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        webSocketSet.add(this);     //加入set中
        addOnlineCount();           //在线数加1
        System.out.println("有新连接加入！当前在线人数为" + getOnlineCount());
        try {
            sendMessage(CommonConstant.CURRENT_WANGING_NUMBER.toString());
        } catch (IOException e) {
            System.out.println("IO异常");
        }
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        webSocketSet.remove(this);  //从set中删除
        subOnlineCount();           //在线数减1
        System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息*/
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("来自客户端的消息:" + message);

        //群发消息
        for (MyWebSocket item : webSocketSet) {
            try {
                item.sendMessage(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 发生错误时调用
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }


    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
        //this.session.getAsyncRemote().sendText(message);
    }


    /**
     * 群发自定义消息
     * */
    public static void sendInfo(String message) throws IOException {
        for (MyWebSocket item : webSocketSet) {
            try {
                item.sendMessage(message);
            } catch (IOException e) {
                continue;
            }
        }
    }

    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        MyWebSocket.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        MyWebSocket.onlineCount--;
    }
}

使用springboot的唯一区别是要@Component声明下，而使用独立容器是由容器自己管理websocket的，但在springboot中连容器都是spring管理的。

虽然@Component默认是单例模式的，但springboot还是会为每个websocket连接初始化一个bean，所以可以用一个静态set保存起来。

前端代码

<!DOCTYPE HTML>
<html>
<head>
    <title>My WebSocket</title>
</head>

<body>
Welcome<br/>
<input id="text" type="text" /><button onclick="send()">Send</button>    <button onclick="closeWebSocket()">Close</button>
<div id="message">
</div>
</body>

<script type="text/javascript">
    var websocket = null;

    //判断当前浏览器是否支持WebSocket
    if('WebSocket' in window){
        websocket = new WebSocket("ws://localhost:8084/websocket");
    }
    else{
        alert('Not support websocket')
    }

    //连接发生错误的回调方法
    websocket.onerror = function(){
        setMessageInnerHTML("error");
    };

    //连接成功建立的回调方法
    websocket.onopen = function(event){
        setMessageInnerHTML("open");
    }

    //接收到消息的回调方法
    websocket.onmessage = function(event){
        setMessageInnerHTML(event.data);
    }

    //连接关闭的回调方法
    websocket.onclose = function(){
        setMessageInnerHTML("close");
    }

    //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
    window.onbeforeunload = function(){
        websocket.close();
    }

    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML){
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

    //关闭连接
    function closeWebSocket(){
        websocket.close();
    }

    //发送消息
    function send(){
        var message = document.getElementById('text').value;
        websocket.send(message);
    }
</script>
</html>


例子二

https://blog.csdn.net/qq516071744/article/details/86363040

pom.xml添加依赖

还是添加依赖

启动类中添加bean

@Bean
public ServerEndpointExporter serverEndpointExporter() {
   return new ServerEndpointExporter();
}

将测试页面的代码放到static目录下方

在这里插入图片描述

websocket server类

在这里插入图片描述

package com.example.springboot_one.websocket;
 
 
import org.springframework.stereotype.Component;
 
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * @Auther: shigc
 * @Date: 2018/12/15 11:53
 * @Description: websocket
 */
@ServerEndpoint("/websocket/{pageCode}")
@Component
public class WebSocket {
 
    private static final String loggerName=WebSocket.class.getName();
    //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话，可以使用Map来存放，其中Key可以为用户标识
    public static Map<String, List<Session>> electricSocketMap = new ConcurrentHashMap<String, List<Session>>();
 
    /**
     * 连接建立成功调用的方法
     *
     * @param session 可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    @OnOpen
    public void onOpen(@PathParam("pageCode") String pageCode, Session session) {
        List<Session> sessions = electricSocketMap.get(pageCode);
        if(null==sessions){
            List<Session> sessionList = new ArrayList<>();
            sessionList.add(session);
            electricSocketMap.put(pageCode,sessionList);
        }else{
            sessions.add(session);
        }
    }
 
    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(@PathParam("pageCode") String pageCode,Session session) {
        if (electricSocketMap.containsKey(pageCode)){
            electricSocketMap.get(pageCode).remove(session);
        }
    }
 
    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     * @param session 可选的参数
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("websocket received message:"+message);
        try {
            session.getBasicRemote().sendText("这是推送测试数据！您刚发送的消息是："+message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 发生错误时调用
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");;
    }
}

总结

这是server端向client端推送消息的方法；只要能获取到客户端的session，即可推送消息；

session.getBasicRemote().sendText("这是推送测试数据！您刚发送的消息是："+message);

真正需要考虑的是，根据自己的实际业务情况，将client端连接过来的session，保存起来，比如保存到一个全局map中，或者是Redis缓存中等等；等需要给客户端推送消息的时候，可以找到对应需要推送的session，这个是重点；

七天晒网
关注
专栏目录
Spring boot使用websocket实现在线聊天
张知文的博客
05-13 1228
maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId>
spring boot+websocket
04-27
在本文中，我们将深入探讨如何在Spring Boot框架中集成WebSocket技术，以便实现实时通信功能。结合jQuery在前端的应用，可以构建出一个高效、实时的Web应用。首先，让我们了解Spring Boot和WebSocket的基本概念。 ...
springboot中使用websocket
最新发布
weixin_43330675的博客
12-07 144
【代码】springboot中使用websocket。
SpringBoot集成WebSocket实现客户端与服务端长连接通信
hkl_Forever的博客
02-16 6688
1、WebSocket协议是用于前后端长连接交互的技术，此技术多用于交互不断开的场景。特点是连接不间断、更轻量，只有在关闭浏览器窗口、或者关闭浏览器、或主动close，当前会话对象才会关闭。第1步：var ws = new WebSocket("ws://localhost:7000/mpj/websocket/1");第2步：console.log("连接状态：", ws.readyState);3：CLOSED，表示连接已经关闭，或者打开连接失败。1：OPEN，表示连接成功，可以通信了。
springboot（十一）WebSocket实现前后端消息推送
南城老猫
03-26 6477
概述： WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocketAPI也被W3C定为标准。 WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服...
SpringBoot使用Websocket（一）
热门推荐
阿靖的博客
06-29 5万+
webSocket是HTML5的一种新协议，它实现了服务端与客户端的全双工通信，建立在传输层，tcp协议之上，即浏览器与服务端需要先建立tcp协议，再发送webSocket连接建立请求。webSocket的连接：客户端发送请求信息，服务端接受到请求并返回相应的信息。连接建立。客户端发送http请求时，通过 Upgrade:webSocket Connection:Upgrade 告知服务器需要建...
springboot项目中websocket入门示例
一粒小石子
01-12 1万+
接上上一篇的springboot项目搭建（idea版）https://blog.csdn.net/qq516071744/article/details/86360166，本计划把两者写到一篇里面的，后来考虑到，篇幅有点大，而且，需要搭建springboot项目的也不一定同时就需要websocket；故又分开来写了；本人菜鸟一枚，写的过程中有什么不对的地方，还望大家不吝指教；再次先行谢过啦；下面进...
Spring Boot 使用 WebSocket示例
allway2的博客
02-01 1872
Introduction to WebSocket with Spring Boot | SpringHowhttps://springhow.com/spring-boot-websocket/ 让我们看看如何将 WebSocket 支持添加到 Spring Boot 应用程序中。我们将尝试创建一个简单的聊天应用程序。请注意，此实现不使用 STOMP。 什么是 WebSocket？ WebSocket 协议有助于通过单个 TCP 连接在客户端和服务器之间建立全双工双向通信。该协议与 HTTP 不同，
Spring boot 使用 Websocket
SSL 的博客
04-05 1393
Websocket是一种基于TCP的通信协议，像我们日常使用的http协议是一种“半双工”也就是只能是客户端请求----服务器响应。而Websocket却可以实现让服务器主动给客户端发送消息。在没有Websocket之前想要实现客户端和服务器之间的，服务器主动发送消息给客户端，一般是通过客户端，轮询或者长连接的方式。Websocket在建立连接的时候用的是http协议，之后就使用的ws协议。
使用 Spring Boot 实现 WebSocket实时通信
08-28
使用 Spring Boot 实现 WebSocket 实时通信 Spring Boot 是一个基于 Java 的框架，提供了强大的工具和功能来快速构建生产级别的应用程序。 WebSocket 是一种实时通信技术，允许服务器将消息推送到客户端，而不需要...
Spring Boot 集成 WebSocket（原生注解与Spring封装方式）
09-29
内容概要：帮助读者通过 Spring Boot 框架一步步完成 WebSocket 集成，快速上手WebSocket。在通过两种方式集成的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能，例如：IOC、AOP、Bean生命周期...
如何使用Spring Boot 3.X + WebSocket来实现推送消息功能
06-14
如何使用Postman来发送数据到后端Spring Boot应用程序，并使用WebSocket建立实时通信通道，以便后端应用程序可以向Postman推送消息。 学会这个方法，就能缩短你的项目开发周期，以及提高你的开发效率。如果提出您的...
@interface与interface的区别以及@interface的用法
CSL201816080304的博客
05-20 8211
interface：声明一个Java接口 接口可以理解成一种特殊的类，在这个类中只能有常量和抽象方法；接口不可以实例化，接口中的方法没有方法体，继承接口的类必须实现接口中定义的方法。 @interface：一个继承了java.lang.annotation.Annotation接口的自定义注解，定义注释类型。 Java从1.5开始提供annotation（注解、标注），它用来修饰应用程序的元素（类、方法、属性、参数、本地变量、包、元数据），编译器将其与元数据一同存储在class文件中，运行期间..
springboot出现Error starting ApplicationContext. To display the conditions report re-run your appli
CSL201816080304的博客
05-25 3631
无语了，springboot启动出错，看了半天，发现是因为之前帮队友写的controller层的Requestmapper的value值空在那… 网上那么多复杂的错误，我却错了最傻的
synchronized的作用和用法
CSL201816080304的博客
07-18 3364
郁闷 参考： @synchronized的作用和用法 Java中Synchronized的使用 文章目录简单介绍用法实战实例修饰代码块修饰普通方法修饰静态方法 简单介绍 synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行 @synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改，保证代码的安全性。也就是包装这段代码是原子性的，安全的。 这个是objective-c的一个锁定令牌，防止self对
Springboot+WebSocket实现在线接收消息
CSL201816080304的博客
01-18 2597
寒假第八天。 写项目的时候写到了客户给前台发消息，考虑到前台要实时获取信息的情况，通过思考（百度），意识到可能要用到如题。 本来打算学习MQTT来考虑消息推送的事情，但是种种原因（懒）暂时放弃。 1 Java API for WebSocket1.1 Servlet容器扫描初始化1.2 Spring 初始化使用@ServerEndpoint创立websocket endpoint实现类前端...
Mysql使用Boolean类型数据
CSL201816080304的博客
07-21 1646
在Mysql数据库中是没有Boolean类型的，但是可以使用tinyint(1)来替代。 如果是tinyint(2)转换为java的对象类型就是Byte。 在mysql数据库中定义一个字段的类型为tinyint并且长度为一的话，使用mybatis自动生成实体类就会自动转换为Boolean类型的对象。 ...
request.setAttribute和session.setAttribute的区别
CSL201816080304的博客
04-11 1183
1 request.setAttribute 作用域是请求和被请求页面之间。 request.setAttribute()是只在此action的下一个forward需要使用的时候使用； request.setAttribute()可存放的参数是String和Object。 2 session.setAttribute 作用域是整个会话期间，在所有的页面都使用这些数据的时候使用。会话期间指的是浏览器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值