springBoot快速搭建WebSocket

已于 2024-09-23 22:22:47 修改
阅读量457 收藏 1
点赞数 2
分类专栏： springBoot 文章标签： spring boot websocket 后端
于 2024-07-30 16:47:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43832604/article/details/140800900
版权
  1. 添加依赖
    在pom.xml中加入WebSocket相关依赖：
<dependencies>
      <!-- websocket -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!-- websocket -->
</dependencies>
  1. 创建SocketHandler（我们socket的消息类型有两种：TextMessage 类型用于处理文本帧， BinaryMessage 类型用于处理二进制帧）
    创建MyWebSocketHandler处理文本帧
import org.springframework.stereotype.Component;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

@Component
public class MyWebSocketHandler extends TextWebSocketHandler {

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        String payload = message.getPayload();//接收到的消息
        System.out.println("Received: " + payload);
        session.sendMessage(new TextMessage(payload));
    }
}

创建MyBinaryWebSocketHandler处理二进制帧

import org.springframework.stereotype.Component;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.nio.ByteBuffer;

@Component
public class MyBinaryWebSocketHandler extends BinaryWebSocketHandler {

    @Override
    public void handleBinaryMessage(WebSocketSession session, BinaryMessage message) throws Exception {
        // 从BinaryMessage中获取二进制数据
        ByteBuffer byteBuffer = message.getPayload();
        // 这里可以处理接收到的二进制数据
        while (byteBuffer.hasRemaining()) {
            byte b = byteBuffer.get();
            // 处理每一个字节
            System.out.println("Received byte: " + b);
        }
        //发送二进制响应
        //session.sendMessage(new BinaryMessage(byteBuffer));
        //或发送文本响应
        session.sendMessage(new TextMessage("111111"));
    }
}
  1. 创建WebSocketConfig
import org.springframework.context.annotation.Configuration;
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
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    private final MyWebSocketHandler myWebSocketHandler;

    private final MyBinaryWebSocketHandler myBinaryWebSocketHandler;

    public WebSocketConfig(MyWebSocketHandler myWebSocketHandler, MyBinaryWebSocketHandler myBinaryWebSocketHandler) {
        this.myWebSocketHandler = myWebSocketHandler;
        this.myBinaryWebSocketHandler = myBinaryWebSocketHandler;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myWebSocketHandler, "/TextMessage").setAllowedOrigins("*");//接收/TextMessage结尾的文本消息
        registry.addHandler(myBinaryWebSocketHandler, "/BinaryMessage").setAllowedOrigins("*");//接收/BinaryMessage结尾的二进制帧消息
    }
}

提供另一种方式：同时接收TextMessage 类型用于处理文本帧， BinaryMessage 类型用于处理二进制帧
创建SocketHandler

package com.game.module.gamemodule.config;

import com.game.module.gamemodule.domain.moneyComing.Content;
import com.game.module.gamemodule.domain.moneyComing.UserAccount;
import com.game.module.gamemodule.utils.UserAccountCacheUtils;
import com.google.gson.Gson;
import org.json.JSONObject;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;

@Component
@Slf4j
public class SocketHandler extends TextWebSocketHandler {

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // 连接建立时调用
        log.info("WebSocket connection established: " + session.getId());
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // 连接关闭时调用
        log.info("WebSocket connection closed: " + session.getId() + ", Status: " + status);
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        // 处理文本消息
        log.info("Received text message: " + message.getPayload());
        session.sendMessage(new TextMessage(message.getPayload()));
    }

    @Override
    protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) {
        // 处理二进制消息
        ByteBuffer payload = message.getPayload();
        payload.rewind(); // 重置position到0以确保从头开始读取
        // 读取指定长度的字节数组
        byte[] byteArray = new byte[payload.remaining()];
        payload.get(byteArray);
        // 或者转换整个ByteBuffer为字节数组
        byte[] fullByteArray = payload.array();
        StringBuffer stringBuffer = new StringBuffer();
        for (byte aByte : fullByteArray) {
            stringBuffer.append(aByte + " ,");
        }
        log.info("Received binary message : {}", stringBuffer.toString());
        log.info("Received binary message with length: {}", payload.limit());
        try {
            session.sendMessage(new TextMessage("111"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

创建WebSocketConfig

package com.game.module.gamemodule.config;

import org.springframework.context.annotation.Configuration;
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
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    private final SocketHandler socketHandler;

    public WebSocketConfig(SocketHandler socketHandler) {
        this.socketHandler = socketHandler;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(socketHandler, "/ws").setAllowedOrigins("*");
        //  接收/ws结尾的消息
    }
}
  1. 创建前端页面index.html 文件，包含一个简单的 WebSocket 客户端，这个只能发文本消息
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>WebSocket Demo</title>
</head>
<body>
    <h1>WebSocket Demo</h1>
    <button onclick="connect()">Connect</button>
    <button onclick="disconnect()">Disconnect</button>
    <br>
    <input type="text" id="message" placeholder="Enter message">
    <button onclick="sendMessage()">Send</button>
    <ul id="messages"></ul>
 
    <script>
        var webSocket;
 
        function connect() {
            webSocket = new WebSocket('ws://localhost:8080/TextMessage');
 
            webSocket.onmessage = function(event) {
                var messages = document.getElementById('messages');
                var message = document.createElement('li');
                message.textContent = event.data;
                messages.appendChild(message);
            };
 
            webSocket.onopen = function(event) {
                console.log('Connected to WebSocket');
            };
 
            webSocket.onclose = function(event) {
                console.log('Disconnected from WebSocket');
            };
        }
 
        function disconnect() {
            if (webSocket) {
                webSocket.close();
            }
        }
 
        function sendMessage() {
            var messageInput = document.getElementById('message');
            var message = messageInput.value;
            webSocket.send(message);
            messageInput.value = '';
        }
    </script>
</body>
</html>

增强版可发文本和二进制

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>WebSocket Demo</title>
</head>
<body>
<h1>WebSocket Demo</h1>
<button onclick="connect()">Connect</button>
<button onclick="disconnect()">Disconnect</button>
<br>
<input type="text" id="message" placeholder="Enter message">
<button onclick="sendMessage()">SendText</button>
<button onclick="sendBinaryMessage()">SendBinary</button>
<ul id="messages"></ul>

<script>
    var webSocket;
	
    function connect() {
        webSocket = new WebSocket('ws://localhost:9101/ws');
		webSocket.binaryType = 'arraybuffer';
        webSocket.onmessage = function(event) {
            var messages = document.getElementById('messages');
            var message = document.createElement('li');
            message.textContent = event.data;
            messages.appendChild(message);
        };

        webSocket.onopen = function(event) {
            console.log('Connected to WebSocket');
        };

        webSocket.onclose = function(event) {
            console.log('Disconnected from WebSocket');
        };
    }
	
	

    function disconnect() {
        if (webSocket) {
            webSocket.close();
        }
    }
	

	
	
	function sendBinaryMessage() {
		var data = new Uint8Array([1, 2, 3, 4, 5]); // 创建一个二进制数组
		webSocket.send(data.buffer); // 发送 ArrayBuffer 对象
	}

    function sendMessage() {
        var messageInput = document.getElementById('message');
        var message = messageInput.value;
        webSocket.send(message);
        messageInput.value = '';
    }
</script>
</body>
</html>
  1. 运行应用程序
    运行 Spring Boot 应用程序，然后浏览器打开 index.html。你应该会看到一个简单的 WebSocket 客户端界面。
    点击 “Connect” 按钮连接到 WebSocket 服务器，输入消息并点击 “Send” 按钮发送消息。你应该会在页面上看到服务器返回的 “Echo” 消息。

6.升级版动态路径
每个用户登陆成功后用Token拼在WS路径中

在这里插入图片描述

package com.game.module.common.config;

import com.game.module.common.proto.loginData;
import com.game.module.common.proto.serverProto;
import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import java.io.IOException;
import java.net.URI;
import java.nio.ByteBuffer;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
@Slf4j
public class SocketHandler extends TextWebSocketHandler {

    private final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>();

    private String getTokenFromSession(WebSocketSession session) {
        // 从WebSocketSession中获取用户token
        return session.getUri().getPath().split("/")[3]; // 路径格式为 /xx/xxx/{token}
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // 连接建立时调用
        log.info("WebSocket connection established: {}", session.getId());
        URI uri = session.getUri();
        String path = uri.getPath();
        log.info("WebSocket 已连接 path: {}", path);
        // 获取查询参数
        String query = uri.getQuery();
        if (query != null) {
            String[] params = query.split("&");
            for (String param : params) {
                String[] keyValue = param.split("=");
                if (keyValue.length == 2) {
                    log.info("{}: {}", keyValue[0], keyValue[1]);
                }
            }
        }
        //获取用户token
        String token = getTokenFromSession(session);
        log.info("WebSocket 已连接 token: {}", token);
        //如果token失效，则移除用户
//        if (isValidToken) {
//            session.close();
//            return;
//        }
        sessions.put(token, session);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // 连接关闭时调用
        URI uri = session.getUri();
        String path = uri.getPath();
        log.info("WebSocket 断开连接 path: {}", path);
        log.info("WebSocket connection closed: {}", session.getId() + ", Status: " + status);
        // 断开连接时移除用户的WebSocketSession
        String userId = getTokenFromSession(session);
        sessions.remove(userId);
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        log.info("Received text message: " + message.getPayload());
        // 处理文本消息
        session.sendMessage(new TextMessage("111111"));
    }

    @Override
    protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) {
        //打印消息
        try {
            printBinaryMessage(message);
        } catch (InvalidProtocolBufferException e) {
            throw new RuntimeException(e);
        }
        try {
            serverProto.Command.Builder command = serverProto.Command.newBuilder();
            command.setType(50);
            session.sendMessage(new BinaryMessage(command.build().toByteArray()));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private void printBinaryMessage(BinaryMessage message) throws InvalidProtocolBufferException {
        // 处理二进制消息
        ByteBuffer payload = message.getPayload();
        payload.rewind(); // 重置position到0以确保从头开始读取
        // 读取指定长度的字节数组
        byte[] byteArray = new byte[payload.remaining()];
        payload.get(byteArray);
        // 或者转换整个ByteBuffer为字节数组
        byte[] fullByteArray = payload.array();
        StringBuffer stringBuffer = new StringBuffer();
        for (byte aByte : fullByteArray) {
            stringBuffer.append(aByte + " ,");
        }
        serverProto.Command command = serverProto.Command.parseFrom(fullByteArray);
        log.info("command : {}", command.toString());
        ByteString data = command.getData();
        loginData.LoginDataAck loginDataAck = loginData.LoginDataAck.parseFrom(data);
        log.info("loginDataAck : {}", loginDataAck.toString());
        log.info("Received binary message : {}", stringBuffer.toString());
        log.info("Received binary message with length: {}", payload.limit());
    }

//    private String buildUserAccount() {
//        //session.sendMessage(new TextMessage("{\"error\":0,\"message\":\"{\\\"cmdType\\\":9,\\\"content\\\":{\\\"Errcode\\\":0,\\\"Message\\\":\\\"\\\",\\\"Time\\\":\\\"2024-07-30T10:05:56.859130816+07:00\\\",\\\"Balance\\\":199833,\\\"CurrencyNumber\\\":6,\\\"AccountID\\\":0}}\"}"));
//        JSONObject transformedObject = new JSONObject();
//        transformedObject.put("error", 0);
//        UserAccount userAccount = UserAccountCacheUtils.getCacheValue("monkey");
//        if (userAccount == null) {
//            userAccount = new UserAccount();
//            userAccount.setCmdType(9);
//            Content content = new Content();
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSSSSZZZ");
//            String format = sdf.format(new Date());
//            content.setTime("2024-07-30T10:05:56.859130816+07:00");
//            content.setAccountID(0);
//            content.setMessage("");
//            content.setCurrencyNumber(6);
//            content.setBalance(200000.0);
//            content.setErrcode(0);
//            userAccount.setContent(content);
//            UserAccountCacheUtils.setCacheValue("monkey", userAccount);
//        }
//        Gson gson = new Gson();
//        String json = gson.toJson(userAccount);
//        transformedObject.put("message", json.toString());
//        return transformedObject.toString();
//    }
}

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>WebSocket Demo</title>
</head>
<body>
<h1>WebSocket Demo</h1>
<input type="text" id="token" placeholder="Enter token">
<button onclick="connect()">Connect</button>
<button onclick="disconnect()">Disconnect</button>
<br>
<br>
<input type="text" id="message" placeholder="Enter message">
<button onclick="sendMessage()">SendText(发送文本消息)</button>
<button onclick="sendBinaryMessage()">SendBinary(发送二进制消息)</button>
<ul id="messages"></ul>

<script>
    var webSocket;

    function connect() {
        var token = document.getElementById('token').value;
        webSocket = new WebSocket('ws://localhost:9102/avitor/ws/' + token + '?r=123');
        webSocket.binaryType = 'arraybuffer';
        webSocket.onmessage = function (event) {
            var messages = document.getElementById('messages');
            var message = document.createElement('li');
            message.textContent = event.data;
            messages.appendChild(message);
        };

        webSocket.onopen = function (event) {
            console.log('Connected to WebSocket');
        };

        webSocket.onclose = function (event) {
            console.log('Disconnected from WebSocket');
        };
    }


    function disconnect() {
        if (webSocket) {
            webSocket.close();
        }
    }


    function sendBinaryMessage() {
        var data = new Uint8Array([18, 66, 26, 58, 8, 146, 140, 229, 151, 4, 18, 12, 98, 50, 100, 54, 52, 101, 118, 55, 100, 106, 105, 106, 34, 36, 8, 6, 17, 123, 20, 174, 71, 33, 217, 194, 64, 25, 0, 0, 0, 0, 0, 0, 240, 63, 33, 133, 235, 81, 184, 30, 133, 219, 63, 42, 3, 226, 130, 185, 48, 4, 58, 4, 8, 1, 18, 0]); // 创建一个二进制数组
        webSocket.send(data.buffer); // 发送 ArrayBuffer 对象
    }

    function sendMessage() {
        var messageInput = document.getElementById('message');
        var message = messageInput.value;
        webSocket.send(message);
        messageInput.value = '';
    }

    function SendToken() {
        var tokenInput = document.getElementById('token');
        var token = tokenInput.value;
        // 发送 HTTP 请求
        var url = "http://localhost:9102/setTokenSocket?token=" + token;
        fetch(url)
            .then(response => {
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                alert('Token sent successfully')
            })
            .then(data => {
                console.log('Success:', data);
            })
            .catch((error) => {
                console.error('Error:', error);
            });
    }
</script>
</body>
</html>
SpringBoot学习－（十二）SpringBoot中建立WebSocket连接
大白能的博客
09-26 8897
WebSocket握手图解：建立连接的步骤： pom文件中添加依赖 创建握手拦截器 创建WebSocket处理类 配置WebSocket 前端页面访问 项目目录结构: 1.pom文件中添加依赖<!-- springboot websocket --> <dependency> <groupId>org.springframework.boot</groupId> <artifact
SpringBoot之WebSocket服务搭建
yuanjinshenglife的专栏
02-24 2735
SpringBoot之WebSocket服务搭建
springboot整合websocket
最新发布
qq_57756904的博客
04-16 804
通过以上步骤，Spring Boot 即可快速整合 WebSocket，实现实时通信功能。根据需求选择原生 WebSocket 或 STOMP 协议扩展功能。
Spring Boot WebSocket 客户端_springboot创建websocket客户端
2401_84254364的博客
04-12 1749
外链图片转存中…(img-MoMKOEeI-1712914457688)]
SpringBoot快速搭建WebSocket服务端和客户端
摘星编程的博客
11-23 1385
由于工作需要,研究了SpringBoot搭建WebSocket双向通信的过程,其他的教程看了许多,感觉讲得太复杂,很容易弄乱,这里我只展示快速搭建过程。
Springboot项目搭建简单的websocket
qq_42537736的博客
10-28 3005
websocket初步搭建
SpringBoot 构建 WebSocket
永远相信美好的事情即将发生
05-07 1654
项目中有需要使用到 WebSocket，这里记录一下： 添加依赖坐标，除了基本的 spring-boot-starter-web依赖之外，还需要添加一个 websocket相关的依赖： <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> 添加 Configurer配置类，将 websocket 访问路径入口与 ha
快速搭建springboot websocket客户端
Wcybaonier
04-10 2671
WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。HTML5 定义的 WebSocket 协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。HTML5 定义的 WebSocket 协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接交换数据。
SpringBoot系列之搭建WebSocket应用
06-20
### Spring Boot 系列之搭建 WebSocket 应用 ...Spring Boot 提供了一套简洁的框架来快速实现 WebSocket 应用，极大地简化了开发流程。希望本文能够帮助开发者们更好地理解和应用 WebSocket 技术。
Springboot集成websocket+protobuf基本Demo，可实现后端与前端数据实时发_Protobuf.zip
09-16
在Spring Boot应用中，可以通过声明式地添加依赖和配置WebSocket消息代理来快速搭建WebSocket服务器。Protobuf则通过定义数据结构的proto文件，在编译时生成对应的数据访问类，这些类可以用于序列化和反序列化消息...
springboot + jwt + websocket + 拦截
09-02
Spring Boot的特点包括自动配置、内嵌式Web服务器（如Tomcat）、 Starter依赖等，使得开发者可以快速搭建应用程序。 JWT是一种轻量级的身份验证标准，常用于用户身份验证。它包含三部分：Header、Payload和...
springboot+netty+websocket+redis
03-08
**SpringBoot+Netty+WebSocket+Redis：构建分布式实时聊天应用** 在当今的互联网世界中，实时通信和数据共享是许多应用程序的核心需求。Spring Boot作为一款流行的Java框架，因其简洁的配置和快速开发特性而备受...
SpringBoot搭建WebSocket服务
swmfizl的博客
01-13 3410
SpringBoot搭建WebSocket服务一、环境准备二、后端搭建WebSocket服务1.新建SpringBoot项目，并勾选WebSocket服务2.项目目录结构如下3.新建类文件WebSocket，文件位置如项目结构所示，代码编写如下4.新建类文件WebSocketConfig，文件位置如项目结构所示，代码编写如下三、新建前端项目1.新建index.html文件，代码如下四、项目演示1....
SpringBoot快速搭建WebSocket
liangshitian的博客
12-22 2万+
目录 前言 pom的依赖 编写WebSocketConfig配置类 编写WebSocketServerController配置类 前端初始化查询用户创建数 测试 项目目录结构 前言 前段时间公司做一个代办收件功能，后来要求在菜单右上角显示有多少笔代办件，由于时间充忙就直接查询数据库了，没有实时想前端推送新增的办件。所以在休息的时候来做这件事，你本文写的demo是查询当...
使用SpringBoot快速构建WebSocket项目
A___B___C的博客
07-24 1155
目前大数据越来越火爆，大量的数据墙如何快速构建完成，webSocket将是至关重要的一环。、 github地址：git@github.com:juejuedog/SpringBootDemo.git 1、首先要引入webSocket的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket&l
SpringBoot快速搭建简易WebSocket系统（springboot整合thymeleaf模板引擎）
weixin_44315761的博客
12-26 405
1.新建maven项目 2.导入pom依赖 <!-- SpringBoot核心jar包 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.4.RELEASE</version> </parent&g
SpringBoot实现WebSocket
热门推荐
山不见我，我自见山
12-06 3万+
WebSocket是HTML5下一种新的协议（websocket协议本质上是一个基于tcp的协议） 它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的。
从零开始，SpringBoot搭建WebSocket
Ricardo的树屋
05-07 3333
一 什么是WebSocket 1.1 首先分清几个概念 **http协议：**超文本传输协议，属于应用层。它的任务是与服务器交换信息。至于怎么连接到服务器，怎么保证数据正确，http不管。 **TCP协议：**传输控制协议，属于传输层。任务是保证连接的可靠，包括防止丢失，出错。所以在初次连接的时候进行3次握手，断开连接时进行4次挥手。至于连接上以后具体传送什么数据，tcp不管。 PS：别的应用层协议也能通过tcp进行，那么这协议在底层也进行三次握手。 1.2 混淆点 WebSocket：基于T
springboot快速搭建WebSocket
make__It的博客
07-17 861
一：webSocket概述   学习过计算机网络的同学知道，HTTP是 拉 协议，即服务端等待客户端发送消息，而邮件协议SMTP则是 推 协议，服务器可以主动将消息发送到客户端。在网页应用中，某些情况下我们往往需要服务器能够主动发送消息给给客户端，后端能够主动联系前端。于是便需要使用到websocket;   Websocket 是一种基于TCP的网络通信协议。连接允许客户端和服务器之间进行全...
SpringBoot搭建简易WebSocket系统教程
总结来说，Spring Boot提供了一套完善的工具和库来快速搭建WebSocket系统，而Thymeleaf的引入使得与WebSocket集成的Web界面开发更加简单高效。开发者能够利用这些工具快速构建出具备实时通信功能的现代Web应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值