WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议

已于 2025-02-02 10:30:24 修改
阅读量251 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring cloud(as vast as cloud) Kafka(Scala Java ecosystem) 文章标签： java
于 2020-05-27 01:42:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blog_programb/article/details/106369501
本文介绍Maven自动化构建工具的使用，包括Maven Wrapper的下载与配置过程，以及如何利用Maven进行项目依赖管理和构建。涵盖Maven的官方文档、Spring Boot Maven插件指南、创建OCI镜像等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议。它允许服务器和客户端之间进行实时的数据交换，使得网页应用能够实现类似桌面应用的即时交互功能。与传统的 HTTP 请求/响应模式不同，WebSocket 提供了一个持久的连接，使得数据可以在任何时候从服务器发送到客户端，而无需等待客户端请求。

WebSocket 的主要特点包括：

  1. 全双工通信：支持双向数据传输，即服务器可以主动向客户端推送消息。
  2. 低延迟：由于建立了持久连接，减少了建立连接的开销，从而降低了通信延迟。
  3. 高并发性：一个 WebSocket 连接可以处理多个消息，适合需要频繁通信的场景。
  4. 跨域支持：通过适当的配置，WebSocket 可以支持跨域请求，但需要注意浏览器的安全策略。

WebSocket 的使用场景非常广泛，包括但不限于：

  • 实时聊天应用
  • 在线游戏
  • 实时金融行情更新
  • 协作编辑工具
  • 实时通知系统

以下是一个简单的 WebSocket 示例代码：

服务端 (Node.js)

const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', function connection(ws) {
  ws.on('message', function incoming(message) {
    console.log('received: %s', message);
  });

  ws.send('something');
});

客户端 (HTML + JavaScript)

<!DOCTYPE html>
<html>
<head>
  <title>WebSocket Test</title>
</head>
<body>
  <script>
    var ws = new WebSocket('ws://localhost:8080');
    ws.onopen = function() {
      console.log('Connected to server');
    };
    ws.onmessage = function(event) {
      console.log('Received: ', event.data);
    };
  </script>
</body>
</html>

WebSocket 和 HTTP 轮询是两种不同的实时通信技术，它们在实现方式、性能和适用场景上有明显的区别。

  1. 连接类型：

    • WebSocket：WebSocket 是一种持久的双向连接，一旦建立连接，服务器和客户端可以通过同一个 TCP 连接进行全双工通信。这意味着数据可以在任意时刻从客户端发送到服务器，反之亦然，而不需要重新建立连接。
    • HTTP 轮询：HTTP 轮询是一种基于 HTTP 请求的单向通信方式。客户端定时向服务器发送 HTTP 请求以获取最新数据，每次请求都是独立的，并且需要重新建立连接。

  2. 性能：

    • WebSocket：由于 WebSocket 保持一个持续的连接，减少了频繁建立和关闭连接的开销，因此在实时性要求高的应用中表现更好。延迟较低，数据传输效率更高。
    • HTTP 轮询：HTTP 轮询需要频繁地发送请求，这会导致较高的网络流量和服务器负载。此外，每次轮询都有一定的延迟，因此不适合对实时性要求非常高的场景。

  3. 资源消耗：

    • WebSocket：WebSocket 连接一旦建立，资源消耗相对稳定，不会因为频繁的连接和断开导致额外的开销。
    • HTTP 轮询：HTTP 轮询会频繁地创建和销毁连接，增加了服务器的资源消耗，尤其是在高并发的情况下，这种开销会更加明显。

  4. 适用场景：

    • WebSocket：适用于需要高实时性的应用场景，如在线游戏、实时聊天、金融行情等。
    • HTTP 轮询：适用于对实时性要求不高的场景，或者在不支持 WebSocket 的环境中作为替代方案使用。

  5. 兼容性：

    • WebSocket：现代浏览器对 WebSocket 的支持较好，但在一些老旧的浏览器中可能需要 polyfill 或降级处理。
    • HTTP 轮询：几乎所有的浏览器都支持 HTTP 请求，因此兼容性更好，但需要考虑性能问题。

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，它的主要优点包括：

  1. 低延迟：WebSocket 允许服务器和客户端之间进行实时双向通信，减少了传统 HTTP 请求/响应模式中的延迟。
  2. 节省带宽：由于 WebSocket 保持一个持续的连接，避免了频繁的握手和建立连接的过程，从而节省了带宽。
  3. 简化开发：WebSocket 提供了一个简单的 API，使得开发者可以更容易地实现实时通信功能，而不需要处理底层的 TCP 连接细节。
  4. 高并发支持：WebSocket 能够高效地处理大量并发连接，适合需要实时数据推送的应用，如在线游戏、金融行情等。
  5. 跨平台兼容性：WebSocket 得到了广泛的浏览器支持，并且可以在不同的操作系统和设备上使用，确保了应用的广泛可用性。

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，与传统的 HTTP 轮询相比具有以下优势：

  1. 持久连接：WebSocket 建立的是持久连接，一旦连接建立，服务器可以随时向客户端发送消息，而不需要客户端请求。这减少了延迟和不必要的网络开销。

  2. 双向通信：WebSocket 支持服务器到客户端（Server-to-Client）和客户端到服务器（Client-to-Server）的双向通信，使得实时应用更加高效。

  3. 低延迟：由于 WebSocket 保持了持久连接，避免了频繁的连接建立和关闭操作，从而显著降低了通信延迟。

  4. 资源利用：相比于传统的 HTTP 轮询，WebSocket 减少了多次请求带来的带宽和服务器资源的浪费，因为只需要一个持续的连接来处理所有通信。

  5. 简化开发：WebSocket 提供了简单的 API，使得开发者可以更容易地实现实时通信功能，而不必处理复杂的轮询逻辑。

  6. 更好的控制：WebSocket 允许更精细的控制，例如可以设置心跳检测机制来确保连接的稳定性，以及通过帧分片传输大数据。
    WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，适用于需要实时数据传输和双向通信的应用场景。以下是一些常见的 WebSocket 适用场景：

  7. 实时聊天应用：WebSocket 可以实现即时通讯功能，用户之间可以实时发送和接收消息，无需刷新页面。

  8. 在线游戏：用于实时同步玩家的状态和游戏数据，减少延迟，提高用户体验。

  9. 实时金融行情：股票、期货等金融市场的数据变化频繁，WebSocket 可以实时推送最新的行情数据到客户端。

  10. 实时通知系统：如社交媒体的通知、邮件提醒等，通过 WebSocket 可以及时将新信息推送给用户。

  11. 远程控制：例如远程桌面、智能家居控制等，通过 WebSocket 实现对设备的实时控制和状态监控。

  12. 协作工具：如在线文档编辑、白板工具等，多个用户可以同时对同一个文档进行编辑，WebSocket 保证数据的实时同步。

  13. 直播流媒体：在视频直播或音频直播中，WebSocket 可以用于传输实时的音视频数据。

  14. 物联网（IoT）应用：设备与服务器之间的实时数据交换，如传感器数据上报、远程控制指令下发等。

  15. 实时数据分析：用于大数据处理中的实时分析，将分析结果实时反馈给前端展示。

  16. 在线客服系统：客户与客服人员之间的实时交流，提升客户服务体验。

WebSocket 和 HTTP 是两种不同的网络协议，它们在功能和使用场景上存在显著差异。以下是 WebSocket 与 HTTP 的主要区别：

  1. 连接方式：

    • HTTP：每次请求都需要建立一个新的 TCP 连接，完成请求后立即断开连接。这种方式被称为“无状态”的通信模式。
    • WebSocket：一旦建立了一个 WebSocket 连接，这个连接会一直保持打开状态，允许服务器和客户端之间进行双向通信。这种持续的连接使得实时数据交换更加高效。

  2. 通信模式：

    • HTTP：基于请求/响应模型，客户端发送请求到服务器，服务器处理请求并返回响应。每个请求都是独立的，没有持久的连接。
    • WebSocket：基于事件驱动的模型，允许服务器主动向客户端推送消息，而不需要等待客户端的请求。这种机制特别适合需要实时更新的应用，如在线聊天、股票行情等。

  3. 数据传输效率：

    • HTTP：由于每次请求都需要建立和关闭连接，传输效率相对较低。此外，HTTP 头信息较大，增加了不必要的开销。
    • WebSocket：一旦连接建立，后续的数据包只需要很小的头部信息，减少了传输的开销，提高了数据传输的效率。

  4. 适用场景：

    • HTTP：适用于传统的网页浏览、文件下载等场景，这些场景通常不需要频繁的双向通信。
    • WebSocket：适用于需要实时交互的应用，如在线游戏、实时聊天、金融交易系统等。

  5. 资源占用：

    • HTTP：由于每次请求都需要建立新的连接，频繁的请求会导致较高的资源消耗。
    • WebSocket：通过保持长连接，减少了频繁建立和关闭连接的资源开销，适合高并发的场景。

  6. 安全性：

    • HTTP：可以通过 HTTPS 来保证数据传输的安全性，但每次请求都需要重新建立加密通道。
    • WebSocket：可以在初始握手时使用 HTTPS 来保证连接的安全性，之后的数据通信则通过已建立的安全通道进行。

总结来说，WebSocket 提供了一种高效的双向通信机制，适合需要实时数据交换的应用；而 HTTP 更适合传统的请求/响应模式，适用于大多数静态内容的传输。

Getting Started

Reference Documentation

For further reference, please consider the following sections:

Guides

The following guides illustrate how to use some features concretely:

/*
 * Copyright 2007-present the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import java.net.*;
import java.io.*;
import java.nio.channels.*;
import java.util.Properties;

public class MavenWrapperDownloader {

    private static final String WRAPPER_VERSION = "0.5.6";
    /**
     * Default URL to download the maven-wrapper.jar from, if no 'downloadUrl' is provided.
     */
    private static final String DEFAULT_DOWNLOAD_URL = "https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/"
        + WRAPPER_VERSION + "/maven-wrapper-" + WRAPPER_VERSION + ".jar";

    /**
     * Path to the maven-wrapper.properties file, which might contain a downloadUrl property to
     * use instead of the default one.
     */
    private static final String MAVEN_WRAPPER_PROPERTIES_PATH =
            ".mvn/wrapper/maven-wrapper.properties";

    /**
     * Path where the maven-wrapper.jar will be saved to.
     */
    private static final String MAVEN_WRAPPER_JAR_PATH =
            ".mvn/wrapper/maven-wrapper.jar";

    /**
     * Name of the property which should be used to override the default download url for the wrapper.
     */
    private static final String PROPERTY_NAME_WRAPPER_URL = "wrapperUrl";

    public static void main(String args[]) {
        System.out.println("- Downloader started");
        File baseDirectory = new File(args[0]);
        System.out.println("- Using base directory: " + baseDirectory.getAbsolutePath());

        // If the maven-wrapper.properties exists, read it and check if it contains a custom
        // wrapperUrl parameter.
        File mavenWrapperPropertyFile = new File(baseDirectory, MAVEN_WRAPPER_PROPERTIES_PATH);
        String url = DEFAULT_DOWNLOAD_URL;
        if(mavenWrapperPropertyFile.exists()) {
            FileInputStream mavenWrapperPropertyFileInputStream = null;
            try {
                mavenWrapperPropertyFileInputStream = new FileInputStream(mavenWrapperPropertyFile);
                Properties mavenWrapperProperties = new Properties();
                mavenWrapperProperties.load(mavenWrapperPropertyFileInputStream);
                url = mavenWrapperProperties.getProperty(PROPERTY_NAME_WRAPPER_URL, url);
            } catch (IOException e) {
                System.out.println("- ERROR loading '" + MAVEN_WRAPPER_PROPERTIES_PATH + "'");
            } finally {
                try {
                    if(mavenWrapperPropertyFileInputStream != null) {
                        mavenWrapperPropertyFileInputStream.close();
                    }
                } catch (IOException e) {
                    // Ignore ...
                }
            }
        }
        System.out.println("- Downloading from: " + url);

        File outputFile = new File(baseDirectory.getAbsolutePath(), MAVEN_WRAPPER_JAR_PATH);
        if(!outputFile.getParentFile().exists()) {
            if(!outputFile.getParentFile().mkdirs()) {
                System.out.println(
                        "- ERROR creating output directory '" + outputFile.getParentFile().getAbsolutePath() + "'");
            }
        }
        System.out.println("- Downloading to: " + outputFile.getAbsolutePath());
        try {
            downloadFileFromURL(url, outputFile);
            System.out.println("Done");
            System.exit(0);
        } catch (Throwable e) {
            System.out.println("- Error downloading");
            e.printStackTrace();
            System.exit(1);
        }
    }

    private static void downloadFileFromURL(String urlString, File destination) throws Exception {
        if (System.getenv("MVNW_USERNAME") != null && System.getenv("MVNW_PASSWORD") != null) {
            String username = System.getenv("MVNW_USERNAME");
            char[] password = System.getenv("MVNW_PASSWORD").toCharArray();
            Authenticator.setDefault(new Authenticator() {
                @Override
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(username, password);
                }
            });
        }
        URL website = new URL(urlString);
        ReadableByteChannel rbc;
        rbc = Channels.newChannel(website.openStream());
        FileOutputStream fos = new FileOutputStream(destination);
        fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
        fos.close();
        rbc.close();
    }

}


distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.6.3/apache-maven-3.6.3-bin.zip
wrapperUrl=https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar


package com.example.demo;

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

@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

}


<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-activemq</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-amqp</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-artemis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-integration</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-websocket</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.kafka</groupId>
			<artifactId>kafka-streams</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.integration</groupId>
			<artifactId>spring-integration-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

在这里插入图片描述

WebSocket 详解：全双工通信的实现与应用
Future_yzx的博客
01-25 2036
WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议。它使得客户端和服务器之间的数据交换变得更加简单，允许服务器主动向客户端推送数据。通过 WebSocket API，浏览器和服务器只需完成一次握手，即可建立持久性连接，开始双向数据传输。
【计算机网络】WebSocket协议
大雨的博客
08-25 1365
WebSocket协议是一种在单个TCP连接上进行全双工通信的协议。它为网络应用提供了一种在客户端和服务器之间建立持久连接的方式，使得双方可以进行实时数据交换。WebSocket协议由RFC 6455定义，它允许服务器主动向客户端推送信息，而不需要客户端的请求。
异常处理-SpringBoot-WebSocket使用MessagingTemplate向前台推送数据
xiaobanv1的专栏
12-25 4700
错误信息： ERROR 105284 --- [nboundChannel-4] .WebSocketAnnotationMethodMessageHandler : Unhandled exception from message handler method. org.springframework.messaging.converter.MessageConversionExcept...
Messaging——WebSocket
十年梦归尘的专栏
12-09 143
WebSocket
WebSocket：实现全双工实时通信的现代Web技术详解
最新发布
Leaton的博客
05-20 1114
WebSocket是一种先进的网络通信协议，允许在单个TCP连接上进行全双工通信，实现服务器与客户端之间的实时数据交换。与传统的HTTP请求-响应模式相比，WebSocket具有低延迟、低开销和跨域支持等优势。它通过一次握手建立持久连接，支持服务器主动推送数据，适用于实时聊天、在线游戏、金融交易等场景。WebSocket协议由IETF标准化，现代浏览器广泛支持。其核心特点包括全双工通信、低延迟、低开销和跨域支持。WebSocket的API简单易用，支持文本和二进制数据传输。服务器端实现可通过Java、Spr
长连接与短连接、全双工与半双工，单工
时光钟摆
05-06 2404
长连接： 连接建立后，需要通过心跳继续维持连接，这样发消息的时候不用每次都建立连接。 通信的过程：建立连接 --> 数据传输 --> 维持心跳 --> 数据传输 --> --> 关闭连接。 相当于自己要维护一个心跳来确保客户端和服务端没有断开。 短连接： 连接建立后，检测到通信交互完毕，就会关闭连接。下次需要通信时，需要再次建立连接。 通信的过...
强烈推荐|websocket 全双工通信协议详解
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
12-07 2314
一. 前言在开发中，我们经常会遇到这样一类需求：需要在网页上显示天气预报，股票数据或者实时排行榜单等实时变化的数据。对于此类需求，一种较为原始的做法就是让客户端每隔一段时间主动去轮询服务器。但这种做法有一个很大的弊端：如果客户端的数量很大，每隔一段时间就发消息给服务器的话，服务器的并发压力会非常巨大。而且访问的频度也很难精确把握，过于频繁地访问服务器，则压力太大；不频繁的话，数据更新可能又不及时。所以今天，耀哥将会给大家分享一个可以让服务器主动推送消息给客户端的技术--websocket！二. WebSoc
WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议是什么意思
03-03
WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议。它最初是为了在 Web 浏览器和 Web 服务器之间实现双向通信而设计的，但现在已经成为许多其他应用程序的基础协议。 WebSocket 协议通过在 HTTP 协议升级...
websocket
05-11
WebSocket是一种在单个TCP连接上进行全双工通信的协议。它使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，客户端和服务器只需要完成一次握手，两者之间就直接...
WebSocket全双工通信与消息推送
一个慢的博客
03-20 5572
B/S结构的软件项目中有时客户端需要实时的获得服务器消息，但默认HTTP协议只支持请求响应模式，这样做可以简化web服务器，减少服务器的负担，加快响应速度，因为服务器不需要与客户端长时间建立一个通信链接，但不容易直接完成实时的消息推送功能，如聊天室、后台信息提示、实时更新数据等功能，但通过polling、Long polling、长链接以及HTML5中定义的WebSocket能完成该功能需要。 ...
websocket全双工通信简介
12-02 2602
本文摘自百度百科和《Spring实战》： 简介 websocket protocol是html5的一种新的协议，它实现了浏览器和服务器的全双工通信（full-duplex），它能够实现web浏览器和服务器之间的异步通信。全双工通信意味着服务器可以发送消息给浏览器，浏览器也可以发送消息给服务器; 背景 在浏览器中通过http仅能实现单向的通信,comet（长链接）可以一定程度上模拟双
WebSocket全双工通信入门教程
XUXUEMING的博客
11-02 7138
WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。
全双工通信的 WebSocket
weixin_34256074的博客
05-21 427
一. WebSocket 是什么？ WebSocket 是一种网络通信协议。在 2009 年诞生，于 2011 年被 IETF 定为标准 RFC 6455 通信标准。并由 RFC7936 补充规范。WebSocket API 也被 W3C 定为标准。 WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工(full-duplex)通讯的协议。没有了 Request...
全双工的WebSocket
zhoxing
02-22 1703
WebSocket 概述 WebSocket 协议本质上是一个基于 TCP 的协议。为了建立一个 WebSocket 连接，客户端浏览器首先要向服务器发起一个 HTTP 请求，这个请求和通常的 HTTP 请求不同，包含了一些附加头信息，其中附加头信息”Upgrade: WebSocket”表明这是一个申请协议升级的 HTTP 请求，服务器端解析这些附加的头信息然后产生应答信息返回给客户端，客
websocket 全双工通信5分钟看懂
晴天有何特别
08-28 797
websocket 全双工通信如此简单 在接触websocket前，觉得这个东西很难，后面自己看了一下html5中的菜鸟教程，更懵了配置什么环境下python， 后面看了一位老哥的博客，恍然大悟，在前端应用中不需配置python，主要是后端需要配置相关环境，前端直接实例化WebSocket对象，上代码 <template> <view> <button @cl...
学习记录：springboot + websocket + spring-messaging实现服务器向浏览器广播式通信
程序员劝退中心
05-23 2144
http协议很好地解决了客户端向服务器通信的问题，虽然已经满足了大部分需求，但是难免会有服务器需要向客户端通信的情况，一般的解决方式就有ajax轮询、长轮询、socket。ajax轮询就是定时使用ajax访问服务器，询问是否有新的消息。长轮询则是访问服务器后，如果没有新消息，则服务器不做响应，直到请求超时或者有新消息，客户端再次发起请求。这两种方式都会增加服务器压力，而且感觉有点笨。最好的方式就是...
WebSocket的使用
chy-x 的博客
08-31 2506
目录WebSocket简介SpringBoot整合WebScoket依赖方式一方式二方式三（推荐）WebSocket的监听器WebSocket的拦截器   WebSocket简介 WebSocket是基于TCP的一种新的网络协议，实现了浏览器、服务器之间的全双工通信，允许服务器主动发送信息给客户端。 WebSocket只需要一次HTTP握手，整个通讯过程建立在一次连接状态中。   WebSocket常用于服务器推送实时数据给客户端，常见的应用场景如下 弹幕 网页聊天系统 公告 实时数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Bol5261

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

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

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

打赏作者

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

抵扣说明：

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

余额充值