精华内容
下载资源
问答
  • websocket区分客户端
    千次阅读
    2022-07-27 14:12:33

    实现客户端的目的,是我为了把websocket服务端与业务层分离开单独做个服务。我还专门把客户端配置到common模块中。只要引用到了common模块的服务。默认都实现了客户端。but,需要做下配置才能实现客户端

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
    @Component
    @ClientEndpoint
    public class WebSocketClient {
    
        @Value("${websocket.server.url:127.0.0.1:8692/ws}")
        private String serverUrl;
    
        @Value("${websocket.server.user:system@1}")
        private String user;
    
        private Session session;
    
        @PostConstruct
        void init() {
            try {
                // 本机地址
                WebSocketContainer container = ContainerProvider.getWebSocketContainer();
                String wsUrl = "ws://" + serverUrl + "/" + user;
                URI uri = URI.create(wsUrl);
                session = container.connectToServer(WebSocketClient.class, uri);
            } catch (DeploymentException | IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 打开连接
         * @param session
         */
        @OnOpen
        public void onOpen(Session session) {
            System.out.println("打开");
            this.session = session;
        }
    
        /**
         * 接收消息
         * @param text
         */
        @OnMessage
        public void onMessage(String text) {
            System.out.println(text);
    
        }
    
        /**
         * 异常处理
         * @param throwable
         */
        @OnError
        public void onError(Throwable throwable) {
            throwable.printStackTrace();
        }
    
        /**
         * 关闭连接
         */
        @OnClose
        public void onClosing() throws IOException {
            System.out.println("关闭");
            session.close();
        }
    
        /**
         * 主动发送消息
         */
        public void send(String message) {
            this.session.getAsyncRemote().sendText(message);
        }
        public void close() throws IOException{
            if(this.session.isOpen()){
                this.session.close();
            }
        }
    
    
    }

    以上代码是实现客户端的关键。websocket.server.user配置。是我为了区分微服务中从哪个服务发出的。换句话说。比如我有库存服务。订单服务。那么websocket.server.user在application.yml中可以这样配置。websocket.server.user=storage@1。websocket.server.user=order@1。然后再服务端进行解析就知道。这个消息是从哪个服务发起的。

    这样把websocket单独做服务的主要目的是实现解耦,复用。让微服务划分更明确!

    更多相关内容
  • 在使用websocket来制作多人即时聊天工具的时候,难免会遇到一个问题,如何区分不同的客户端。想要解决这个问题就等于是要解决这样一个问题:如何把当前登录用户的userId传给服务端呢?因为不同的客户端代表着不同的...


    1 获取HttpSession值

    在使用websocket来制作多人即时聊天工具的时候,难免会遇到一个问题,如何区分不同的客户端。想要解决这个问题就等于是要解决这样一个问题:如何把当前登录用户的userId传给服务端呢?因为不同的客户端代表着不同的用户,做到了获取不同客户端的userId那么自然就把不同的客户端区分开来了。两种可行获取客户端userId的方法一种是通过在Server取HttpSession中的值获取当前用户,一种是直接在客户端建立连接时附带上用户的值。

    当我们在完成用户登录的功能时,用户登录成功,则将当前用户放入HttpSession中,这是一种很常见的做法,这一部分代码如下(框架是SpringMVC,不详细介绍,具体代码请以自己所用框架为准):

    if(Objects.equals(userDetail.getUserDetailPassword(), userPassword)){
    
    //如果当前用户登录成功,则将user对象放入httpSession的currentUser
                    httpSession.setAttribute("currentUser",user);
                    resoult = "success";
                }
    

    那么接下来问题的关键就来了,我们怎么在Server中获取在这里放入HttpSession中的User对象呢,直接获取肯定是不行的,不卖关子,直接放代码。
    注意,结构如图:

    新建一个GetHttpSessionConfigurator类,内容如下:

    import javax.servlet.http.HttpSession;
    import javax.websocket.HandshakeResponse;
    import javax.websocket.server.HandshakeRequest;
    import javax.websocket.server.ServerEndpointConfig;
    import javax.websocket.server.ServerEndpointConfig.Configurator;
    
    public class GetHttpSessionConfigurator extends Configurator{
        @Override
        public void modifyHandshake(ServerEndpointConfig sec,HandshakeRequest request, HandshakeResponse response) {
            HttpSession httpSession=(HttpSession) request.getHttpSession();
            sec.getUserProperties().put(HttpSession.class.getName(),httpSession);
        }
    }
    

    然后在Server里面注解的地方加上一句:

    @ServerEndpoint(value="/server/",configurator=GetHttpSessionConfigurator.class)
    

    此时,我们就已经可以用

    @OnOpen
            public void onOpen(Session session, EndpointConfig config){
                HttpSession httpSession = (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
                }
    

    来获取httpSession对象了,然后直接取出currentUser存储的用户对象就可以了。

    但是,在这里我产生了一个问题:原则上来讲我在server获取的httpsession中取出来的用户对象就是现在正和服务端建立连接的对象,因为这种情况的操作肯定是先登录,然后直接建立连接,可是在实际中多用户同时登录时就不一定是这样子了。因为登录是客户端发起的操作,建立连接也是客户端发起的操作,且不说在客户端这两个操作是否是紧密相连,就算是紧密相连,从服务器验证成功(此时已经放入currentUser对象)返回登录结果给客户端到客户端向服务端发起连接这中间因为网络原因也是会消耗一定时间的。那么这时候一件尴尬的事情就发生了:此时,另一个用户也在登录,并且在之前用户两个操作期间完成了登录验证操作,那么第一个用户连接建立之后取出的use对象就不是这个用户的而是第二个用户的,这就乱套了。这种方法相当于是 ,用户A先对服务器说,记住了,我叫A,然后过了一会儿来说,我要建立连接,我是刚刚告诉你名字那个人。那如果B在A离开那会儿也告诉了服务器我叫B,那么服务器就会把A当成B了。
    当前,上面我所说的我没办法去验证,如果我对HttpSession理解错误那就另当别论了。(应该没理解错吧)如果理解有误还请大神指正。
    所以,感觉上来讲还是第二种方法靠谱一点。

    2 @PathParam获取用户对象

    这种方法是在建立连接时把userId放在建立连接的申请之中,这样的话就不会乱掉了:因为用户A登录成功之后我就把用户A的user对象传回去了,然后用户A拿着自己的userId来对客户端说我要建立连接我是A,服务端自然不会搞错。实现方法如下:
    服务端注解地方如下:

    @ServerEndpoint(value="/server/{userId}")
    

    方法参数如下:

    @OnOpen
            public void onOpen(@PathParam("userId")String userId,Session session)
    

    服务端在建立连接请求时路径如下(cp是jsp中的:)

    <c:set var="cp" value="${pageContext.request.contextPath}" />
    

    currentUser就是我们之前登录成功时放入httpSession的值,这个值即便别的用户登录也不会被刷新因为它是被保存在自己的浏览器之中的。

    ws = "ws://localhost:8080" + "${cp}" + "/server"+"/${currentUser.userId}";
    

    这样的话,服务端就获取到了当前建立连接的用户了。

    3 区分不同客户端

    能够获取不同用户userId之后,我们就可以在服务端进行如下操作来区分用户了,具体见注释。(为了突出要点,代码做了精简,仅仅用于示范区分不同的用户)

        public class Server {
         //存放每个客户端对应的Server对象,可以考虑使用Map来代替,key作为用户标识
         private static CopyOnWriteArraySet<Server> server = new CopyOnWriteArraySet<Server>();
         //表示与某个用户的连接会话,通过它给客户端发送数据
         @SuppressWarnings("unused")
         private Session session;
         //用户id
         private String userId;
         //用户id和websocket的session绑定的路由表
         @SuppressWarnings("rawtypes")
         private static Map routeTable = new HashMap<>();
         /**
             * 连接建立成功调用的方法
             * @param session  可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
             */
            @SuppressWarnings("unchecked")
            @OnOpen
            public void onOpen(@PathParam("userId")String userIds,Session session){
                this.session = session;
                //获取当前登录用户的id
                this.userId=userIds;
                //将用户id和session绑定到路由表
                //绑定之后就可以在其它地方根据id来获取session,这时两个用户私聊就可以实现了
                routeTable.put(userId, session);
            }
            //其它部分代码就不放了
    
    展开全文
  • WebSocket区分不同客户端两种方法(HttpSession和@PathParam)
  • swoole学习之websocket服务端和客户端websocket 服务端websocket 客户端websocket设置参数 websocket 服务端 websocketService.php <?php //实例化 websocket 服务 $server = new Swoole\WebSocket\Server("0.0....

    websocket 服务端

    websocketService.php

    <?php
    //实例化 websocket 服务
    $server = new Swoole\WebSocket\Server("0.0.0.0", 9502);
    //监听websocket链接打开事件
    $server->on('open', function (Swoole\WebSocket\Server $server, $request) {
        echo "<ore>";
        print_r($request);
        echo "server: handshake success with fd{$request->fd}\n";
    });
    
    //监听websocket消息事件
    $server->on('message', function (Swoole\WebSocket\Server $server, $frame) {
    
        echo "<ore>";
        print_r($frame);
    
        echo "receive from {$frame->fd}:{$frame->data},opcode:{$frame->opcode},fin:{$frame->finish}\n";
        //向websocket链接的客户端推送数据
        $server->push($frame->fd, "this is websocket server");
    });
    
    //关闭事件
    $server->on('close', function ($ser, $fd) {
        echo "client {$fd} closed\n";
    });
    
    //开启服务
    $server->start();
    ?>
    

    客户端向服务器端发送信息时,服务器端触发 onMessage 事件回调
    服务器端可以调用 $server->push() 向某个客户端(使用 $fd 标识符)发送消息

    先启动httpServer服务

    php server/httpService.php
    

    再启动websocketserver服务

    php server/websocketService.php
    

    websocket 客户端

    websocket.html

    <!DOCTYPE html>
    <html lang="zh-CN">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="content-type" content="text/html; charset=utf-8">
        <title>swoole学习之websocket_server服务器代码_徊忆羽菲的博客-CSDN博客</title>
    </head>
    <body>
    <h1>websocket服务器测试</h1>
    
    <script type="application/javascript">
        //定义一个websocket服务器的路径
        var wsUrl = 'ws://20.20.24.131:9502';
    
        var ws_server = new WebSocket(wsUrl);
    
        //实例化open属性 判断是否链接websocket成功
        ws_server.onopen = function (evt) {
    
            //发送数据
            ws_server.send('hello websocket!');
            console.log('connect-swoole-websocket-success');
        }
    
        //实例化onmessage
        ws_server.onmessage = function (evt) {
            console.log('connect-swoole-websocket-message', evt.data);
        }
        //实例化close
        ws_server.onclose = function (evt) {
            console.log('connect-swoole-websocket-close');
        }
        //实例化close
        ws_server.onerror = function (evt, e) {
            console.log('connect-swoole-websocket-error', e.errorCode);
        }
    </script>
    </body>
    </html>
    

    在浏览器中访问

    http://20.20.24.131:9501/websocket.html

    可以看到console.log打印的日志信息
    在这里插入图片描述消息头中返回的响应信息
    在这里插入图片描述

    websocket设置参数

    在websocketService.php 中配置参数

    <?php
    //实例化 websocket 服务
    $server = new Swoole\WebSocket\Server("0.0.0.0", 9502);
    
    //配置参数
    $server->set([
        'enable_static_handler' => true,
        'document_root' => '/data/web/swoole_mooc/static'
    ]);
    

    保存,重新启动websocket服务器,可以关闭http服务器, 无需启动http服务器,在浏览器中访问:

    http://20.20.24.131:9502/websocket.html

    注意:域名端口号需要更换成websocket服务器的端口号,而不是之前的9501

    在这里插入图片描述
    在这里插入图片描述
    查看websocket服务端返回数据

    在这里插入图片描述

    websocket封装基础类

    创建 websocket.Class.php

    <?php
    /*优化websocket基础类
     *
     * */
    
    class Ws
    {
    
        //定义host
        const HOST = '0.0.0.0';
        //定义端口号
        const PORT = 9502;
        //定义变量
        public $ws = '';
    
        //构造函数
        public function __construct()
        {
            $this->ws = new Swoole\WebSocket\Server(self::HOST, self::PORT);
            //定义方法
            $this->ws->on('open', [$this, 'onOpen']);
            $this->ws->on('message', [$this, 'onMessage']);
            $this->ws->on('close', [$this, 'onClose']);
            //启动服务
            $this->ws->start();
        }
    
        //定义链接websocket服务事件的方法
        public function onOpen($ws, $request)
        {
            echo "<pre>";
            print_r($request);
        }
    
    
        //定义websocket服务消息事件的方法
        public function onMessage($ws, $frame)
        {
            echo "frame<pre>";
            print_r($frame);
            echo '获取到客户端发送过来的数据' . $frame->data;
            //给客户端回应,发送内容
            $ws->push($frame->fd, 'wesocketServe-push-data:www.qipa250.com');
        }
    
        //定义关闭websocket服务的方法
        public function onClose($ws, $fd)
        {
            echo '客户端:' . $fd . '断开了websocket服务!';
        }
    
    }
    
    //实例化
    
    $ws = new Ws();
    
    ?>
    

    以上代码,仍然依赖httpserver,所以需要启动httpserver

    php server/httpService.php

    再启动websocket服务

    php server/websocket.Class.php

    websocket客户端 代码
    websocket.html

    <!DOCTYPE html>
    <html lang="zh-CN">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="content-type" content="text/html; charset=utf-8">
        <title>swoole学习之websocket_server服务器代码_徊忆羽菲的博客-CSDN博客</title>
    </head>
    <body>
    <h1>websocket服务器基础类测试</h1>
    
    <script type="application/javascript">
        //定义一个websocket服务器的路径
        var wsUrl = 'ws://20.20.24.131:9502';
    
        var ws_server = new WebSocket(wsUrl);
    
        //实例化open属性 判断是否链接websocket成功
        ws_server.onopen = function (evt) {
    
            //发送数据
            ws_server.send('hello websocket!');
            console.log('connect-swoole-websocket-success');
        }
    
        //实例化onmessage
        ws_server.onmessage = function (evt) {
            console.log('connect-swoole-websocket-message', evt.data);
        }
    
        //实例化close
        ws_server.onclose = function (evt) {
            console.log('connect-swoole-websocket-close');
        }
    
        //实例化close
        ws_server.onerror = function (evt, e) {
            console.log('connect-swoole-websocket-error', e.errorCode);
        }
    
    </script>
    
    </body>
    </html>
    

    在浏览器中预览效果

    http://20.20.24.131:9501/websocket.html

    在这里插入图片描述
    可以看到,连接websocket成功,且接收到了来自服务端的数据信息

    展开全文
  • springboot+websocket实现服务端、客户端

    千次阅读 2022-02-25 21:37:03
    websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。 二、websocket介绍 百度百科介绍:WebSokcet 在公司实际使用...

    一、引言

    小编最近一直在使用springboot框架开发项目,毕竟现在很多公司都在采用此框架,之后小编也会陆续写关于springboot开发常用功能的文章。

    什么场景下会要使用到websocket的呢?

    websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。

    二、websocket介绍

    百度百科介绍:WebSokcet

    在公司实际使用websocket开发,一般来都是这样的架构,首先websocket服务端是一个单独的项目,其他需要通讯的项目都是以客户端来连接,由服务端控制消息的发送方式(群发、指定发送)。 但是也会有服务端、客户端在同一个项目当中,具体看项目怎么使用。

    本文呢,采用的是服务端与客户端分离来实现,包括使用springboot搭建websokcet服务端、html5客户端、springboot后台客户端, 具体看下面代码。

    三、服务端实现

    步骤一: springboot底层帮我们自动配置了websokcet,引入maven依赖

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

    步骤二:如果是你采用springboot内置容器启动项目的,则需要配置一个Bean。如果是采用外部的容器,则可以不需要配置。

    /**
     * @Description: 配置类
     */
    @Component
    public class WebSocketConfig {
     
        /**
         * ServerEndpointExporter 作用
         *
         * 这个Bean会自动注册使用@ServerEndpoint注解声明的websocket endpoint
         *
         * @return
         */
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    }
    

    步骤三:最后一步当然是编写服务端核心代码了,其实小编不是特别想贴代码出来,贴很多代码影响文章可读性。

    package com.example.socket.code;
     
    import lombok.extern.slf4j.Slf4j;
    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.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import java.util.concurrent.ConcurrentHashMap;
     
    /**
     * @Description: websocket 服务类
     */
     
    /**
     *
     * @ServerEndpoint 这个注解有什么作用?
     *
     * 这个注解用于标识作用在类上,它的主要功能是把当前类标识成一个WebSocket的服务端
     * 注解的值用户客户端连接访问的URL地址
     *
     */
     
    @Slf4j
    @Component
    @ServerEndpoint("/websocket/{name}")
    public class WebSocket {
     
        /**
         *  与某个客户端的连接对话,需要通过它来给客户端发送消息
         */
        private Session session;
     
         /**
         * 标识当前连接客户端的用户名
         */
        private String name;
     
        /**
         *  用于存所有的连接服务的客户端,这个对象存储是安全的
         */
        private static ConcurrentHashMap<String,WebSocket> webSocketSet = new ConcurrentHashMap<>();
     
     
        @OnOpen
        public void OnOpen(Session session, @PathParam(value = "name") String name){
            this.session = session;
            this.name = name;
            // name是用来表示唯一客户端,如果需要指定发送,需要指定发送通过name来区分
            webSocketSet.put(name,this);
            log.info("[WebSocket] 连接成功,当前连接人数为:={}",webSocketSet.size());
        }
     
     
        @OnClose
        public void OnClose(){
            webSocketSet.remove(this.name);
            log.info("[WebSocket] 退出成功,当前连接人数为:={}",webSocketSet.size());
        }
     
        @OnMessage
        public void OnMessage(String message){
            log.info("[WebSocket] 收到消息:{}",message);
            //判断是否需要指定发送,具体规则自定义
            if(message.indexOf("TOUSER") == 0){
                String name = message.substring(message.indexOf("TOUSER")+6,message.indexOf(";"));
                AppointSending(name,message.substring(message.indexOf(";")+1,message.length()));
            }else{
                GroupSending(message);
            }
     
        }
     
        /**
         * 群发
         * @param message
         */
        public void GroupSending(String message){
            for (String name : webSocketSet.keySet()){
                try {
                    webSocketSet.get(name).session.getBasicRemote().sendText(message);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
     
        /**
         * 指定发送
         * @param name
         * @param message
         */
        public void AppointSending(String name,String message){
            try {
                webSocketSet.get(name).session.getBasicRemote().sendText(message);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    

    四、客户端实现

    HTML5实现:以下就是核心代码了,其实其他博客有很多,小编就不多说了。

     var websocket = null;
        if('WebSocket' in window){
            websocket = new WebSocket("ws://192.168.2.107:8085/websocket/testname");
        }
     
        websocket.onopen = function(){
            console.log("连接成功");
        }
     
        websocket.onclose = function(){
            console.log("退出连接");
        }
     
        websocket.onmessage = function (event){
            console.log("收到消息"+event.data);
        }
     
        websocket.onerror = function(){
            console.log("连接出错");
        }
     
        window.onbeforeunload = function () {
            websocket.close(num);
        }
    

    SpringBoot后台实现:小编发现多数博客都是采用js来实现客户端,很少有用后台来实现,所以小编也就写了写,大神请勿喷?。很多时候,项目与项目之间通讯也需要后台作为客户端来连接。

    步骤一:首先我们要导入后台连接websocket的客户端依赖

    <!--websocket作为客户端-->
    <dependency>
        <groupId>org.java-websocket</groupId>
        <artifactId>Java-WebSocket</artifactId>
        <version>1.3.5</version>
    </dependency>
    

    步骤二:把客户端需要配置到springboot容器里面去,以便程序调用。**

    package com.example.socket.config;
     
    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;
     
    /**
     * @Description: 配置websocket后台客户端
     */
    @Slf4j
    @Component
    public class WebSocketConfig {
     
        @Bean
        public WebSocketClient webSocketClient() {
            try {
                WebSocketClient webSocketClient = new WebSocketClient(new URI("ws://localhost:8085/websocket/test"),new Draft_6455()) {
                    @Override
                    public void onOpen(ServerHandshake handshakedata) {
                        log.info("[websocket] 连接成功");
                    }
     
                    @Override
                    public void onMessage(String message) {
                        log.info("[websocket] 收到消息={}",message);
     
                    }
     
                    @Override
                    public void onClose(int code, String reason, boolean remote) {
                        log.info("[websocket] 退出连接");
                    }
     
                    @Override
                    public void onError(Exception ex) {
                        log.info("[websocket] 连接错误={}",ex.getMessage());
                    }
                };
                webSocketClient.connect();
                return webSocketClient;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
     
    }
    

    步骤三:使用后台客户端发送消息

    1、首先小编写了一个接口,里面有指定发送和群发消息两个方法。

    2、实现发送的接口,区分指定发送和群发由服务端来决定(小编在服务端写了,如果带有TOUSER标识的,则代表需要指定发送给某个websocket客户端)

    3、最后采用get方式用浏览器请求,也能正常发送消息

    package com.example.socket.code;
     
    /**
     * @Description: websocket 接口
     */
    public interface WebSocketService {
     
        /**
         * 群发
         * @param message
         */
         void groupSending(String message);
     
        /**
         * 指定发送
         * @param name
         * @param message
         */
         void appointSending(String name,String message);
    }
    

    五、最后

    其实,贴了这么多大一片的代码,感觉上影响了博客的美观,也不便于浏览,如果没看懂小伙伴,可以下载源码看下。

    里面一共两个项目,服务端、客户端(html5客户端、后台客户端),是一个网页群聊的小案例。

    https://download.csdn.net/download/weixin_38111957/10912384

    扩展 :小伙伴提出的疑点进行解答

    看了小伙伴提出的疑问,小编也是非常认可的,如果是单例的情况下,这个对象的值都会被修改。

    小编就抽了时间Debug了一下,经过下图也可以反映出,能够看出,webSokcetSet中存在三个成员,并且vlaue值都是不同的,所以在这里没有出现对象改变而把之前对象改变的现象。

    服务端这样写是没问题的。

    img

    紧接着,小编写了一个测试类,代码如下,经过测试输出的结果和小伙伴提出的疑点是一致的。

    最后总结:这位小伙伴提出的观点确实是正确的,但是在实际WebSocket服务端案例中为什么没有出现这种情况,当WebSokcet这个类标识为服务端的时候,每当有新的连接请求,这个类都是不同的对象,并非单例。

    import com.alibaba.fastjson.JSON;
     
    import java.util.concurrent.ConcurrentHashMap;
     
    /**
     * @Description:
     */
    public class TestMain {
     
        /**
         * 用于存所有的连接服务的客户端,这个对象存储是安全的
         */
        private static ConcurrentHashMap<String, Student> webSocketSet = new ConcurrentHashMap<>();
     
        public static void main(String[] args) {
            Student student = Student.getStudent();
            student.name = "张三";
            webSocketSet.put("1", student);
     
            Student students = Student.getStudent();
            students.name = "李四";
            webSocketSet.put("2", students);
     
            System.out.println(JSON.toJSON(webSocketSet));
        }
    }
     
    /**
     * 提供一个单例类
     */
    class Student {
     
        public String name;
     
        private Student() {
        }
     
        private static final Student student = new Student();
     
        public static Student getStudent() {
            return student;
     
        }
    }
    

    img

    展开全文
  • 需要用到的包: github.com/gorilla/websocket 服务端代码: package main import ( "github.com/gin-gonic/gin" "github.com/gorilla/websocket" ...var upGrader = websocket.Upgrader{ ...//webSocket.
  • PHP利用websocket实现客户端请求ws协议功能

    万次阅读 热门讨论 2018-12-07 16:15:05
    最近项目需要,利用websocket实现PHP对ws协议的请求,这里PHP是作为一个客户端通过ws协议请求服务,而不是作为服务端,这个首先要区分下。 ws协议是websocket的东西,现在也有很多东西可以实现,如workerman、swoole...
  • 有人用过websocketd搭建C语言后台的websocket服务器吗,现在有个问题,后台如何区分来自前端不同的请求去传输数据呢,就类似HTTP中解析url上的请求参数然后回复。
  • 本篇教程介绍了Node.js Websocket如何区分不同的用户,希望阅读本篇文章以后大家有所收获,帮助大家对Node.js的理解更加深入。<通过param1,param2来管理不同的ws回话,以便实现群发和指定用户的消息推送...
  • 使用 WebSocket 客户端连接 MQTT 服务器

    千次阅读 2021-01-30 15:05:08
    我们可以使用emq自带的Dashboard插件,进行websocket调试,打开谷歌浏览器输入网址,其中192.168.83.128是emq所在的IP地址: http://192.168.83.128:18083/#/websocket 用户名:admin,密码:public WebS.
  • 2、实现发送的接口,区分指定发送和群发由服务端来决定(小编在服务端写了,如果带有TOUSER标识的,则代表需要指定发送给某个websocket客户端) 3、最后采用get方式用浏览器请求,也能正常发送消息 package ...
  • C/C++ 实现的websocket客户端

    万次阅读 多人点赞 2019-01-17 17:39:29
    源代码见websocket client 使用过标准的libwebsockets服务端库测试过,主要是短小精悍,相对于libwebsockets不需要依赖zlib和openssl 以及其他库,直接make就可以使用了,linux跟windows都可以使用。 测试用例: ...
  • 集成 WebSocket 发送消息到客户端

    千次阅读 2022-07-18 14:24:17
    } 4、WebSocket服务类和转码工具 需要标注注解 @ServerEndpoint,该注解声明并创建了 WebSocket 端点, 并且指明了请求路径: userName 为客户端请求时携带的参数,用于服务端区分客户端使用。 该类还有几个方法:...
  • Websocket 客户端 +服务端 (服务——TCP连接) 服务端 pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</...
  • <!... <... <head> ...meta charset="UTF-8">...webSocket小Demo</title> </head> <body> <div class="container"> <div> <input type="text" id="msg"> <
  • 我们知道websocket协议与http协议有些不同,websocket有自带的Session,但是跟http的Session是不一样的,而我们做有些web项目的时候,又需要知道当前是哪个用户,用以处理该用户的业务逻辑,或者是对该用户进行授权...
  • WebSocket通信,多客户端数据同时发送 目标:当一个客户端改变了某项数据后,其他的客户端都可以通过 WebSocket方式 看到新的数据。 单浏览器推送 需要用到的pom坐标: <dependency> <groupId>javax.websocket...
  • springboot框架下整合websocket客户端和服务端

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,547
精华内容 3,418
关键字:

websocket区分客户端