Springboot集成WebSocket

最新推荐文章于 2024-08-10 21:45:19 发布
最新推荐文章于 2024-08-10 21:45:19 发布
阅读量402 收藏 2
点赞数
分类专栏： Spring&SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SIMBA1949/article/details/105205700
版权

Springboot集成WebSocket

前言

博客书

版本说明

spring-boot-starter-parent=2.2.4.RELEASE

相关链接：

  • spring-boot-starter-websocket : https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-websocket

参考链接：

  • https://www.jianshu.com/p/8c4983a3ca2e

实战演练

核心依赖

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-websocket -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

pom 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>top.simba1949</groupId>
    <artifactId>web-socket-springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <finalName.text>web-socket-springboot</finalName.text>
        <!--https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
        <spring-cloud-dependencies.version>Hoxton.RELEASE</spring-cloud-dependencies.version>
        <!--https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <fastjson.version>1.2.67</fastjson.version>
        <!--https://mvnrepository.com/artifact/com.google.guava/guava -->
        <guava.version>28.2-jre</guava.version>
        <!--https://mvnrepository.com/artifact/cn.hutool/hutool-all -->
        <hutool-all.version>5.2.4</hutool-all.version>
    </properties>

    <!--spring-boot 和 spring-cloud 版本兼容参考 https://spring.io/projects/spring-cloud -->
    <!-- Inherit defaults from Spring Boot -->
    <!--https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.4.RELEASE</version>
    </parent>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!--Core starter, including auto-configuration support, logging and YAML-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- spring-cloud-context，使 bootstrap.properties 配置文件生效 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-context</artifactId>
        </dependency>
        <!--Starter for using Spring Boot's Actuator which provides production ready features to help you monitor and manage your application-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--Starter for testing Spring Boot applications with libraries including JUnit, Hamcrest and Mockito-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--Spring Boot Configuration Processor-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>
        <!--Spring Boot Developer Tools-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional> <!-- 表示依赖不会传递 -->
        </dependency>

        <!--Common tools starter-->
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool-all.version}</version>
        </dependency>
        <!--Common tools end -->

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-websocket -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>${finalName.text}</finalName>
        <plugins>
            <!--The Compiler Plugin is used to compile the sources of your project.-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <!--The Resources Plugin handles the copying of project resources to the output directory. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!--Spring Boot Maven Plugin-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!--main of springboot project-->
                    <!--<mainClass>top.simba1949.Application</mainClass>-->
                    <!-- 如果没有该配置，devtools不会生效 -->
                    <fork>true</fork>
                    <skip>true</skip>
                    <!--将项目注册到linux服务上，可以通过命令开启、关闭以及伴随开机启动等功能-->
                    <executable>true</executable>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <!--Maven Surefire MOJO in maven-surefire-plugin.-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <!--跳过测试-->
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- docker的maven插件，详情请见 https://blog.csdn.net/SIMBA1949/article/details/83064083-->
        </plugins>

        <!--IDEA是不会编译src的java目录的文件，如果需要读取，则需要手动指定哪些配置文件需要读取-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

核心配置(WebSocketConfig)

package top.simba1949.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * @Author Theodore
 * @Date 2020/3/30 17:12
 */
@Configuration
public class WebSocketConfig {

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

核心代码(WebSocketServer)

package top.simba1949.websocket;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import top.simba1949.modle.Message;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用 userId 标识用户唯一
 * @Author Theodore
 * @Date 2020/3/30 17:13
 */
@Slf4j
@ServerEndpoint("/websocket/{userId}")
@Component
public class WebSocketServer {
    /** 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。*/
    private static final AtomicInteger ON_LINE_COUNT = new AtomicInteger(0);
    /**
     * concurrent包的线程安全 Set，用来存放每个客户端对应的 MyWebSocket 对象。
     * 若要实现服务端与单一客户端通信的话，可以使用Map来存放，其中 Key 可以为用户标识
     */
    private static ConcurrentHashMap<String, WebSocketServer> webSocketSet = new ConcurrentHashMap<>();
    /** 某个客户端的连接会话，需要通过它来给客户端发送数据 */
    private Session session;
    /** 当前发消息的人员 userId */
    private String userId;

    /**
     * 连接建立成功调用的方法
     * @param param
     * @param session
     * @param config
     */
    @OnOpen
    public void onOpen( @PathParam(value = "userId") String param, Session session, EndpointConfig config) {
        userId = param;
        this.session = session;
        // 加入map中
        webSocketSet.put(param, this);
        // 在线数加1
        int cnt = ON_LINE_COUNT.incrementAndGet();
        log.info("有连接加入，当前连接数为：{}", cnt);
        sendMessage(this.session, "连接成功");
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        if (!userId.equals("")){
            // 从set中删除
            webSocketSet.remove(userId);
            int cnt = ON_LINE_COUNT.decrementAndGet();
            log.info("有连接关闭，当前连接数为：{}", cnt);
        }
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("来自客户端的消息：{}", message);
        Message msg = JSON.parseObject(message, Message.class);
        if (msg.getType() == 0){
            // 群发
            sendToGroup(msg.getMessage());
        }else {
            // 私发
            sendToUser(msg.getTo(), msg.getMessage());
        }
    }

    /**
     * 发生错误时调用的方法
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误：{}，Session ID： {}",error.getMessage(),session.getId());
        error.printStackTrace();
    }

    /**
     * 发送消息，实践表明，每次浏览器刷新，session会发生变化。
     * @param session
     * @param message
     */
    public void sendMessage(Session session, String message) {
        try {
            session.getBasicRemote().sendText(String.format("%s (From Server，Session ID=%s)", message, session.getId()));
        } catch (IOException e) {
            log.error("发送消息出错：{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 群发消息
     * @param message
     */
    public void sendToGroup(String message) {
        for (String key : webSocketSet.keySet()) {
            Session session = webSocketSet.get(key).session;
            if(session != null && session.isOpen() && !userId.equals(key)){
                sendMessage(session, message);
            }
        }
    }

    /**
     * 指定 Session 发送消息
     * @param userId
     * @param message
     */
    public void sendToUser(String userId, String message) {
        WebSocketServer webSocketServer = webSocketSet.get(userId);
        if ( webSocketServer != null && webSocketServer.session.isOpen()){
            sendMessage(webSocketServer.session, message);
        }else{
            log.warn("当前用户不在线：{}",userId);
        }
    }
}

Message 信息

package top.simba1949.modle;

import lombok.Data;
import java.io.Serializable;

/**
 * @Author Theodore
 * @Date 2020/3/30 17:46
 */
@Data
public class Message implements Serializable {
    private static final long serialVersionUID = -6513719561109260800L;

    private Integer type;
    private String to;
    private String from;
    private String message;
}

启动类

package top.simba1949;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author Theodore
 * @Date 2020/3/30 17:00
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

前端页面

如果不支持可以引入：stomp.js 、sockjs.js

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>WebSocket Demo</title>
    </head>
    <body>
        <h2>WebSocket Demo---- user0 </h2>
        <input id="text" type="text" /> 
        <button onclick="send()"> Send </button>   
        <button onclick="closeWebSocket()"> Close </button>
        <div id="message"></div>
    </body>
    
    <script type="text/javascript">
    // 判断当前浏览器是否支持WebSocket
    if('WebSocket' in window){
        websocket = new WebSocket("ws://localhost:8080/websocket/user0");
        console.log("link success")
    }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(){
        let message = document.getElementById('text').value;
        let data = {};
        // 群发 type = 0；私发 type = 1；
        data.type = 1;
        // 需要复制该页面 websocket = new WebSocket("ws://localhost:8080/websocket/user1"); 在创建一个user1用户
        data.to = 'user1';
        data.message = message;
        
        websocket.send(JSON.stringify(data));
    }
    </script>
</html>
Simba1949
关注
专栏目录
springboot整合websocket
10-16
springboot整合websocketspringboot整合websocketspringboot整合websocket
SpringBoot集成WebSocket长连接实际应用详解
08-19
SpringBoot集成WebSocket长连接实际应用详解 本文主要介绍了SpringBoot集成WebSocket长连接实际应用详解，通过示例代码详细介绍了WebSocket的应用场景和实现方式，对大家的学习或者工作具有一定的参考学习价值。 ...
Springboot集成websocket
囚徒之困
05-23 4072
Springboot集成websocket
springboot使用WebSocket
最新发布
weixin_45476535的博客
08-10 423
【代码】springboot使用WebSocket。
springboot 集成websocket
大哥一声吼
05-29 8165
springboot 和websocket 集成
SpringBoot整合WebSocket
KyrieXJL的博客
09-16 352
SpringBoot 整合 websocket
SpringBoot集成WebSocket实现前后端消息互传的方法
08-25
SpringBoot集成WebSocket实现前后端消息互传的方法 SpringBoot集成WebSocket实现前后端消息互传的方法是当前互联网技术中的一种常见的实现方式。WebSocket是一种基于TCP的网络协议，能够实现浏览器与服务器的全双工...
Springboot集成websocket+protobuf基本Demo，可实现后端与前端数据实时发送与接收.zip
01-04
WebSocket是一种在客户端和服务器之间建立长连接的协议，它允许双方进行全双工通信，即...这个示例项目"Springboot集成websocket+protobuf基本Demo"提供了一个基础的实现，可以帮助开发者快速理解和实践这一技术组合。
springboot集成websocket的简单例子
03-02
首先，为了集成WebSocket，我们需要引入相关的依赖。在Spring Boot项目中，我们通常通过添加`spring-boot-starter-websocket`依赖来启用WebSocket功能。在`pom.xml`或`build.gradle`文件中添加如下依赖： ```xml <!...
springboot集成websocket实现简单聊天
03-29
在本项目中，我们将探讨如何利用Spring Boot集成WebSocket，以实现一个简单的聊天应用。 首先，我们需要在Spring Boot项目中引入WebSocket的相关依赖。Spring Boot本身并不直接支持WebSocket，但可以通过Spring ...
Spring Boot -- 整合Websocket
03-20
spring boot整合websocket, 通过http请求给websocket server给websocket client发送消息.实现消息推送和网页聊天功能.
JAVA (Springboot) 集成WebSocket
weixin_47054648的博客
05-29 2175
WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，同时也允许客户端向服务器发送数据。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。
SpringBoot 集成WebSocket
m0_67907445的博客
08-29 1505
在海量并发及客户端与服务器交互负载流量大的情况下，极大的节省了网络带宽资源的消耗，有明显的性能优势，且客户端发送和接受消息是在同一个持久连接上发起，实现了“真·长链接”，实时性优势明显。* 要注意，如果项目使用外置的servlet容器，而不是直接使用springboot内置容器的话，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。长轮询的间隔期一般很长，例如 30s、60s，并且服务端 hold 住连接不会消耗太多服务端资源。降低轮询的间隔，延迟降低，压力增加；
springboot集成websocket
qq_42922707的博客
02-21 6087
springboot集成websocket 记录下自己使用wensocket的踩坑过程，如有不对，请见谅 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 配置websocket
springboot集成 websocket
05-27
SpringBoot集成WebSocket可以使用Spring框架提供的WebSocket API来实现。在SpringBoot中，使用WebSocket需要进行以下几个步骤： 1. 添加依赖：在pom.xml文件中添加spring-boot-starter-websocket依赖。 2. 创建WebSocket配置类：创建一个WebSocket配置类，用于配置WebSocket相关的参数，如注册EndPoint、消息编解码器、拦截器等。 3. 创建EndPoint：创建一个WebSocket的EndPoint类，用于处理WebSocket连接、消息发送、关闭等操作。可以通过实现Spring提供的WebSocketHandler接口或者继承TextWebSocketHandler来实现。 4. 添加拦截器：可以添加自定义的拦截器，用于处理WebSocket连接建立、消息发送等事件。 5. 配置WebSocket消息代理：使用Spring提供的消息代理，可以实现WebSocket消息的广播和点对点传递。 以下是一个简单的SpringBoot集成WebSocket的示例代码： 1. 添加依赖 ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 2. 创建WebSocket配置类 ``` @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(myHandler(), "/myHandler") .addInterceptors(new WebSocketInterceptor()); } @Bean public WebSocketHandler myHandler() { return new MyHandler(); } } ``` 3. 创建EndPoint ``` public class MyHandler extends TextWebSocketHandler { @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { // 处理连接建立事件 } @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { // 处理消息事件 } @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { // 处理连接关闭事件 } } ``` 4. 添加拦截器 ``` public class WebSocketInterceptor extends HandshakeInterceptor { @Override public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception { // 处理连接建立前事件 return true; } @Override public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception ex) { // 处理连接建立后事件 } } ``` 5. 配置WebSocket消息代理 ``` @Configuration @EnableWebSocketMessageBroker public class WebSocketMessageBrokerConfig implements WebSocketMessageBrokerConfigurer { @Override public void configureMessageBroker(MessageBrokerRegistry registry) { registry.enableSimpleBroker("/topic"); registry.setApplicationDestinationPrefixes("/app"); } @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/myEndpoint") .setAllowedOrigins("*") .withSockJS(); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Simba1949

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值