springbot websocket服务端、客户端实现

最新推荐文章于 2024-08-29 14:30:39 发布
最新推荐文章于 2024-08-29 14:30:39 发布
阅读量333 收藏
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengqifeng1997/article/details/119700327
版权

1、依赖

		<!--websocket 服务端-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!--websocket 客户端-->
        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>1.3.5</version>
        </dependency>

2、服务端配置

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

/**
 * @Author zengqifeng
 * @CreateTime 2021/8/13 14:28
 * @Description
 */
@Component
public class WebSocketConfig {

    /**
     * springboot内置Tomcat 需要配置该bean
     * 作用是会自动扫描@ServerEndpoint注解类作为一个websocket服务端 并纳入容器管理
     * @return
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

3、服务端业务处理逻辑

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author zengqifeng
 * @CreateTime 2021/8/13 14:35
 * @Description @ServerEndpoint注解标注一个类为websocket服务端
 */
@Slf4j
@Component
@ServerEndpoint(value = "/websocket")
public class WebSocketServer {

    /**
     * 线程安全容器、用于保存客户端session
     */
    private static ConcurrentHashMap<String, Session> clients = new ConcurrentHashMap<>();


    /**
     * 客户端连接
     * @param session
     */
    @OnOpen
    public void onOpen(Session session) {
        log.info("id = {}", session.getId());
        log.info("uri host = {}", session.getRequestURI().getHost());
        log.info("uri port = {}", session.getRequestURI().getPort());
        log.info("uri = {}", session.getRequestURI().toString());
        clients.put(session.getId(), session);
        log.info("客户端连接id= {}，当前客户端数 = {}", session.getId(), clients.size());
    }

    /**
     * 客户端关闭
     * @param session
     */
    @OnClose
    public void onClose(Session session) {
        clients.remove(session.getId());
        log.info("客户端断连id= {}， 当前客户端数 = {}", session.getId(), clients.size());
    }

    /**
     * 出错
     * @param session
     * @param throwable
     */
    @OnError
    public void onError(Session session, Throwable throwable) {

    }

    /**
     * 收到消息
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("接收客户端id= {}发来的消息 = {}", session.getId(), message);
    }


    /**
     * 点对点消息
     * @param session
     * @param message
     */
    public void sendDirectMessage(Session session, String message) {
        log.info("向客户端id = {}发送消息 = {}", session.getId(), message);
        session.getAsyncRemote().sendText(message);
    }

    /**
     * 群发消息
     * @param message
     */
    public void sendFanoutMessage(String message) {
        log.info("群发消息 = {}", message);
        clients.values().forEach(session -> session.getAsyncRemote().sendText(message));
    }

    /**
     * 群发消息  排除指定session
     * @param message
     * @param session
     */
    public void sendFanoutMessage(String message, Session session) {
        log.info("群发消息、排除指定客户，消息内容 = {}", session);
        for (Map.Entry<String, Session> entry : clients.entrySet()) {
            if (session == entry.getValue()) {
                continue;
            }
            session.getAsyncRemote().sendText(message);
        }
    }

    /**
     * 获取所有在线客户
     * @return
     */
    public static ConcurrentHashMap getClients() {
        return clients;
    }
}

4、客户端配置

import lombok.extern.slf4j.Slf4j;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft_6455;
import org.java_websocket.handshake.ServerHandshake;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.net.URI;

/**
 * @Author zengqifeng
 * @CreateTime 2021/8/13 16:11
 * @Description   创建客户端bean备用
 */
@Slf4j
@Component
public class WebSocketClientConfig {

        private static final String WEBSOCKET_URI = "ws://localhost:8080/websocket";

        @Bean(name = "client1")
        public WebSocketClient webSocketClient1() {
                try {
                        WebSocketClient webSocketClient = new WebSocketClient(new URI(WEBSOCKET_URI), new Draft_6455()) {
                                @Override
                                public void onOpen(ServerHandshake serverHandshake) {
                                        log.info("client1-客户端连接成功");
                                }

                                @Override
                                public void onMessage(String message) {
                                        log.info("client1-客户端收到消息：{}", message);
                                }

                                @Override
                                public void onClose(int i, String s, boolean b) {
                                        log.info("client1-关闭");
                                }

                                @Override
                                public void onError(Exception e) {
                                        log.info("client1-错误：{}", e);
                                }
                        };
                        webSocketClient.connect();
                        return webSocketClient;
                }catch (Exception e) {
                        log.info("创建websocket bean 异常，异常信息 = {}", e);
                }
                return  null;
        }


        @Bean(name = "client2")
        public WebSocketClient webSocketClient2() {
                try {
                        WebSocketClient webSocketClient = new WebSocketClient(new URI(WEBSOCKET_URI), new Draft_6455()) {
                                @Override
                                public void onOpen(ServerHandshake serverHandshake) {
                                        log.info("client2-客户端连接成功");
                                }

                                @Override
                                public void onMessage(String message) {
                                        log.info("client2-客户端收到消息：{}", message);
                                }

                                @Override
                                public void onClose(int i, String s, boolean b) {
                                        log.info("client2-关闭");
                                }

                                @Override
                                public void onError(Exception e) {
                                        log.info("client2-错误：{}", e);
                                }
                        };
                        webSocketClient.connect();
                        return webSocketClient;
                }catch (Exception e) {
                        log.info("创建websocket bean 异常，异常信息 = {}", e);
                }
                return  null;
        }
}

5、客户端业务逻辑

import com.example.demo.websocket.server.WebSocketServer;
import org.java_websocket.client.WebSocketClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.websocket.Session;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author zengqifeng
 * @CreateTime 2021/8/13 16:30
 * @Description
 */
@Service
public class WebSocketClientService {
    @Resource(name = "client1")
    private WebSocketClient webSocketClient1;

    @Resource(name = "client2")
    private WebSocketClient webSocketClient2;

    @Autowired
    private WebSocketServer webSocketServer;



    public void websocketServerSendMessage(String message) {
        webSocketServer.sendFanoutMessage("群发消息" + message);
    }

    public void websocketServerSendSignalMessage(String message) {
        ConcurrentHashMap clients = WebSocketServer.getClients();
        Session session = (Session) clients.get("0");
        webSocketServer.sendDirectMessage(session, "单发消息");
    }

    public void send1Message(String message) {
        webSocketClient1.send(message);
    }

    public void send2Message(String message) {
        webSocketClient2.send(message);
    }
}

6、controller测试

import com.example.demo.websocket.client.WebSocketClientService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 * websocket 前端控制器
 * </p>
 *
 * @author 曾奇峰
 * @since 2021-06-02
 */
@Api(tags = "websocket")
@RestController
@RequestMapping("/websocket")
public class WebSocketController {

    @Autowired
    private WebSocketClientService webSocketClientService;


    @ApiOperation("websocket客户端1发送消息测试")
    @GetMapping("/websocketClient1SendMessage")
    public Object websocketClient1SendMessage(@RequestParam String message) {
        webSocketClientService.send1Message(message);
        return "发送成功！";
    }

    @ApiOperation("websocket客户端2发送消息测试")
    @GetMapping("/websocketClient2SendMessage")
    public Object websocketClient2SendMessage(@RequestParam String message) {
        webSocketClientService.send2Message(message);
        return "发送成功！";
    }

    @ApiOperation("服务端单发消息")
    @GetMapping("/websocketServerSendSignalMessage")
    public Object websocketServerSendSignalMessage(@RequestParam String message) {
        webSocketClientService.websocketServerSendSignalMessage(message);
        return "单发成功！";
    }

    @ApiOperation("服务端群发消息")
    @GetMapping("/websocketServerSendMessage")
    public Object websocketServerSendMessage(@RequestParam String message) {
        webSocketClientService.websocketServerSendMessage(message);
        return "群发成功！";
    }


}
this is 小疯子
关注
专栏目录
springboot+websocket客户端和服务端
cheng_long111的博客
06-24 1401
springboot框架下整合websocket客户端和服务端
springboot集成websocket客户端
zsj777的专栏
03-30 593
1、pom文件 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 2、 package com.pojo.prj.config; import
基于springboot实现websocket客户端和服务端
04-29
环境配置 开发环境配置为： JDK 8 IntelliJ IDEA 2020.1.2 x64 Springboot集成的Websocket 使用Springboot集成的websocket需要使用到以下几个类/接口： WebSocketHandler：WebSocket消息以及生命周期事件的处理器。 WebSocketConfigurer：对WebSocket进行配置，包括配置拦截器、配置接口地址。 HttpSessionHandshakeInterceptor：拦截器，可以对Websocket通信过程中的请求进行拦截处理。 除了上述三个官方提供的类/接口之外，我们还需要实现一个WebSocket的包装类，用于为每一个WebSocket实例添加额外的信息，比如客户端的ID。在Spring内，WebSocket实例以WebSocketSession形式存在，每个session都代表了一个服务端与客户端的会话。
spring-websocket整合实现客户端和服务端聊天 亲测可用
01-11
可以实现服务端-客户端高效低功耗完美双向通信 可选择使用websocket或者sockJS连接服务器，观察方便，完美观察连接全过程。
Springboot 原理 及源码解析
最新发布
Yluciud的博客
08-29 1123
翻译分别为： 目标， 保留， 文档， 继承，可以用于大概猜测注解含义。加在方法或类上，指定该方法在什么条件下才会被注册到Bean的IOC容器中。
Spring Boot 入门
dawuafang
12-27 429
Spring Boot 入门 Spring Boot是Spring社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于Spring的应用程序和服务，让更多人的人更快的对Spring进行入门体验，让Java开发也能够实现Ruby on Rails那样的生产效率。为Spring生态系统提供了一种固定的、约定优于配置风格的框架。 Spring Boot具有如下特性： 为基于Spring...
Spring Boot WebSocket 客户端_springboot创建websocket客户端
2401_84254364的博客
04-12 1578
外链图片转存中…(img-MoMKOEeI-1712914457688)]
使用springboot 配置一个websocket客户端
wangming1473的博客
07-09 1319
客户端将被 Spring 管理，允许你注入任何需要的依赖，并支持向 WebSocket 服务器发送消息。首先，您需要在 Spring Boot 项目中添加 WebSocket 的依赖。如果您使用 Maven，可以在。要在 Spring Boot 应用程序中实现一个 WebSocket 客户端，您可以使用 Spring 的。若要从配置文件中获取 WebSocket 连接 URL，您可以在 Spring Boot 应用中使用。接着，使用 Spring 的。以上内容由gpt生成，经过验证可以使用。
springboot实现websocket服务端、websocket客户端
feicongcong的博客
07-28 2373
springboot实现websocket服务端、websocket客户端。
使用springboot实现websocket客户端
weixin_39770514的博客
09-28 2397
使用springboot实现websocket客户端引入pom依赖实现方式 引入pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 实现方式 我们在pom文件中引入websocket的依
SpringBoot集成websocket作为客户端和服务端的代码案例完整源码
03-21
SpringBoot集成websocket作为客户端和服务端的代码案例完整源码。 springboot + maven 多模块项目。 开箱即用，注意启动时先启动WebsocketServerApplication，再启动WebsocketClientApplication。
spring websocket做客户端 服务器
woaiqianzhige的博客
08-27 3708
&lt;dependency&gt;     &lt;groupId&gt;org.springframework&lt;/groupId&gt;     &lt;artifactId&gt;spring-websocket&lt;/artifactId&gt;     &lt;version&gt;5.0.8.RELEASE&lt;/version&gt; &lt;/dependenc
SpringBoot 基于注解实现的WebSocketServer
weixin_44089726的博客
12-10 2377
基于原生的WebSocket服务端 支持SpringBoot
SpringBoot集成WebSocket实现客户端与服务端通信
lizjf
01-17 2283
2、自定义WebSocket客户端，继承WebSocketClient类，实现发送、接收等功能。3、创建连接封装类，uri对应socket服务的ip和端口号。2、添加配置文件 WebSocketConfig。3、编写WebSocket服务端接收、发送功能。话不多说，直接上代码看效果！
SpringBoot集成websocket作为客户端和服务端的代码案例
hou_zi的博客
03-21 3493
Springboot整合websocket作为服务端和客户端案例
org.springframework.web.reactive.socket.client.WebSocketClient
Meditation_Crazy
06-08 2794
前言 错误信息 No qualifying bean of type 'org.springframework.web.reactive.socket.client.WebSocketClient' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {} 场景 springboot2.2.2 集成gateway，spring cloud版本：Hoxton.S.
spring boot websocket 客户端_Spring Boot 开发集成 WebSocket，实现私有即时通信系统
weixin_39598094的博客
11-26 76
###1/ 概述 利用Spring Boot作为基础框架，Spring Security作为安全框架，WebSocket作为通信框架，实现点对点聊天和群聊天。 ###2/ 所需依赖 Spring Boot 版本 1.5.3，使用MongoDB存储数据（非必须），Maven依赖如下： <properties> <java.version>1.8</java.ve...
springboot+websocket实现服务端、客户端
热门推荐
贱男
01-12 8万+
一、引言 小编最近一直在使用springboot框架开发项目，毕竟现在很多公司都在采用此框架，之后小编也会陆续写关于springboot开发常用功能的文章。 什么场景下会要使用到websocket的呢？ websocket主要功能就是实现网络通讯，比如说最经典的客服聊天窗口、您有新的消息通知，或者是项目与项目之间的通讯，都可以采用websocket来实现。 二、websocket介...
SpringBoot WebSocket做客户端
南城的博客
10-26 7813
常见的都是springboot应用做服务，前端页面做客户端，进行websocket通信进行数据传输交互。但其实springboot服务也能做客户端去连接别的webSocket服务提供者。刚好最近在项目中就使用到了，需求背景大概就是我们作为一个java段应用需要和一个C语言应用进行通信。在项目需求及环境等多方面的考量之下，最后放了使用http协议和C程序进行通信转而使用webSocket，然后在C侧开发人员的要求下，由他们做服务端，我们做客户端。
使用springboot实现WebSocket服务端和网页客户端
09-22
在使用Spring Boot实现WebSocket服务端和网页客户端时，需要进行以下步骤： 1. 首先，创建一个Spring Boot项目，并在pom.xml文件中添加相关的依赖项，包括Spring Web和Spring WebSocket依赖。 2. 创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值