websocket 订阅
WebSocket 展开全文
WebSocket
信息
操作系统
跨平台
开发语言
JavaHTML/CSS查看源码 »
开源协议
未知
WebSocket
WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。 WebSocket通信协议于2011年被IETF定为标准 RFC 6455 ,WebSocketAPI 被 W3C 定为标准。 在 WebSocket API 中,浏览器和服务器只需要要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。 现在,很多网站为了实现即时通讯(real-time),所用的技术都是轮询(polling)。轮询是在特定的的时间间隔(time interval)(如每1秒),由浏览器对服务器发出HTTP request,然后由服务器返回最新的数据给客服端的浏览器。这种传统的HTTP request d的模式带来很明显的缺点 – 浏览器需要不断的向服务器发出请求(request),然而HTTP request 的header是非常长的,里面包含的数据可能只是一个很小的值,这样会占用很多的带宽。 而最比较新的技术去做轮询的效果是Comet – 用了AJAX。但这种技术虽然可达到全双工通信,但依然需要发出请求(reuqest)。 在 WebSocket API,浏览器和服务器只需要要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。在此WebSocket 协议中,为我们实现即使服务带来了两大好处: 1. Header 互相沟通的Header是很小的-大概只有 2 Bytes 2. Server Push 服务器可以主动传送数据给客户端
收起全文
精华内容
下载资源
问答
  • SpringBoot2.0集成WebSocket,实现后台向前端推送信息

    万次阅读 多人点赞 2018-05-10 22:54:29
    什么是WebSocket? - 初次接触 WebSocket 的人,都会问同样的问题:我们已经有了 HTTP 协议,为什么还需要另一个协议?它能带来什么好处? - 答案很简单,因为 HTTP 协议有一个缺陷:***通信只能由客户端发起***,...

    什么是WebSocket?

    这里写图片描述
    WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。

    为什么需要 WebSocket?

    初次接触 WebSocket 的人,都会问同样的问题:我们已经有了 HTTP 协议,为什么还需要另一个协议?它能带来什么好处?

    • 答案很简单,因为 HTTP 协议有一个缺陷:通信只能由客户端发起,HTTP 协议做不到服务器主动向客户端推送信息。
      这里写图片描述
      举例来说,我们想要查询当前的排队情况,只能是页面轮询向服务器发出请求,服务器返回查询结果。轮询的效率低,非常浪费资源(因为必须不停连接,或者 HTTP 连接始终打开)。因此WebSocket 就是这样发明的。

    前言

    2020-10-20 教程补充:

    • 补充关于@Component@ServerEndpoint关于是否单例模式等的解答,感谢大家热心提问和研究。
    • Vue版本的websocket连接方法

    2020-01-05 教程补充:

    感谢大家的支持和留言,14W访问量是满满的动力!接下来还会有websocket+redis集群优化篇针对多ws服务器做简单优化处理,敬请期待!

    话不多说,马上进入干货时刻。

    maven依赖

    SpringBoot2.0对WebSocket的支持简直太棒了,直接就有包可以引入

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

    WebSocketConfig

    启用WebSocket的支持也是很简单,几句代码搞定

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    /**
     * 开启WebSocket支持
     * @author zhengkai.blog.csdn.net
     */
    @Configuration  
    public class WebSocketConfig {  
    	
        @Bean  
        public ServerEndpointExporter serverEndpointExporter() {  
            return new ServerEndpointExporter();  
        }  
      
    } 
    

    WebSocketServer

    这就是重点了,核心都在这里。

    1. 因为WebSocket是类似客户端服务端的形式(采用ws协议),那么这里的WebSocketServer其实就相当于一个ws协议的Controller

    2. 直接@ServerEndpoint("/imserver/{userId}")@Component启用即可,然后在里面实现@OnOpen开启连接,@onClose关闭连接,@onMessage接收消息等方法。

    3. 新建一个ConcurrentHashMap webSocketMap 用于接收当前userId的WebSocket,方便IM之间对userId进行推送消息。单机版实现到这里就可以。

    4. 集群版(多个ws节点)还需要借助mysql或者redis等进行处理,改造对应的sendMessage方法即可。

    package com.softdev.system.demo.config;
    
    import java.io.IOException;
    import java.util.concurrent.ConcurrentHashMap;
    import javax.websocket.OnClose;
    import javax.websocket.OnError;
    import javax.websocket.OnMessage;
    import javax.websocket.OnOpen;
    import javax.websocket.Session;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.stereotype.Component;
    import cn.hutool.log.Log;
    import cn.hutool.log.LogFactory;
    
    
    /**
     * @author zhengkai.blog.csdn.net
     */
    @ServerEndpoint("/imserver/{userId}")
    @Component
    public class WebSocketServer {
    
        static Log log=LogFactory.get(WebSocketServer.class);
        /**静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。*/
        private static int onlineCount = 0;
        /**concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。*/
        private static ConcurrentHashMap<String,WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
        /**与某个客户端的连接会话,需要通过它来给客户端发送数据*/
        private Session session;
        /**接收userId*/
        private String userId="";
    
        /**
         * 连接建立成功调用的方法*/
        @OnOpen
        public void onOpen(Session session,@PathParam("userId") String userId) {
            this.session = session;
            this.userId=userId;
            if(webSocketMap.containsKey(userId)){
                webSocketMap.remove(userId);
                webSocketMap.put(userId,this);
                //加入set中
            }else{
                webSocketMap.put(userId,this);
                //加入set中
                addOnlineCount();
                //在线数加1
            }
    
            log.info("用户连接:"+userId+",当前在线人数为:" + getOnlineCount());
    
            try {
                sendMessage("连接成功");
            } catch (IOException e) {
                log.error("用户:"+userId+",网络异常!!!!!!");
            }
        }
    
        /**
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose() {
            if(webSocketMap.containsKey(userId)){
                webSocketMap.remove(userId);
                //从set中删除
                subOnlineCount();
            }
            log.info("用户退出:"+userId+",当前在线人数为:" + getOnlineCount());
        }
    
        /**
         * 收到客户端消息后调用的方法
         *
         * @param message 客户端发送过来的消息*/
        @OnMessage
        public void onMessage(String message, Session session) {
            log.info("用户消息:"+userId+",报文:"+message);
            //可以群发消息
            //消息保存到数据库、redis
            if(StringUtils.isNotBlank(message)){
                try {
                    //解析发送的报文
                    JSONObject jsonObject = JSON.parseObject(message);
                    //追加发送人(防止串改)
                    jsonObject.put("fromUserId",this.userId);
                    String toUserId=jsonObject.getString("toUserId");
                    //传送给对应toUserId用户的websocket
                    if(StringUtils.isNotBlank(toUserId)&&webSocketMap.containsKey(toUserId)){
                        webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
                    }else{
                        log.error("请求的userId:"+toUserId+"不在该服务器上");
                        //否则不在这个服务器上,发送到mysql或者redis
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    
        /**
         *
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            log.error("用户错误:"+this.userId+",原因:"+error.getMessage());
            error.printStackTrace();
        }
        /**
         * 实现服务器主动推送
         */
        public void sendMessage(String message) throws IOException {
            this.session.getBasicRemote().sendText(message);
        }
    
    
        /**
         * 发送自定义消息
         * */
        public static void sendInfo(String message,@PathParam("userId") String userId) throws IOException {
            log.info("发送消息到:"+userId+",报文:"+message);
            if(StringUtils.isNotBlank(userId)&&webSocketMap.containsKey(userId)){
                webSocketMap.get(userId).sendMessage(message);
            }else{
                log.error("用户"+userId+",不在线!");
            }
        }
    
        public static synchronized int getOnlineCount() {
            return onlineCount;
        }
    
        public static synchronized void addOnlineCount() {
            WebSocketServer.onlineCount++;
        }
    
        public static synchronized void subOnlineCount() {
            WebSocketServer.onlineCount--;
        }
    }
    

    消息推送

    至于推送新信息,可以再自己的Controller写个方法调用WebSocketServer.sendInfo();即可

    
    import com.softdev.system.demo.config.WebSocketServer;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.servlet.ModelAndView;
    import java.io.IOException;
    
    /**
     * WebSocketController
     * @author zhengkai.blog.csdn.net
     */
    @RestController
    public class DemoController {
    
        @GetMapping("index")
        public ResponseEntity<String> index(){
            return ResponseEntity.ok("请求成功");
        }
    
        @GetMapping("page")
        public ModelAndView page(){
            return new ModelAndView("websocket");
        }
    
        @RequestMapping("/push/{toUserId}")
        public ResponseEntity<String> pushToWeb(String message, @PathVariable String toUserId) throws IOException {
            WebSocketServer.sendInfo(message,toUserId);
            return ResponseEntity.ok("MSG SEND SUCCESS");
        }
    }
    
    

    页面发起

    页面用js代码调用websocket,当然,太古老的浏览器是不行的,一般新的浏览器或者谷歌浏览器是没问题的。还有一点,记得协议是ws的,如果使用了一些路径类,可以replace(“http”,“ws”)来替换协议。

    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <title>websocket通讯</title>
    </head>
    <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>
    <script>
        var socket;
        function openSocket() {
            if(typeof(WebSocket) == "undefined") {
                console.log("您的浏览器不支持WebSocket");
            }else{
                console.log("您的浏览器支持WebSocket");
                //实现化WebSocket对象,指定要连接的服务器地址与端口  建立连接
                //等同于socket = new WebSocket("ws://localhost:8888/xxxx/im/25");
                //var socketUrl="${request.contextPath}/im/"+$("#userId").val();
                var socketUrl="http://localhost:9999/demo/imserver/"+$("#userId").val();
                socketUrl=socketUrl.replace("https","ws").replace("http","ws");
                console.log(socketUrl);
                if(socket!=null){
                    socket.close();
                    socket=null;
                }
                socket = new WebSocket(socketUrl);
                //打开事件
                socket.onopen = function() {
                    console.log("websocket已打开");
                    //socket.send("这是来自客户端的消息" + location.href + new Date());
                };
                //获得消息事件
                socket.onmessage = function(msg) {
                    console.log(msg.data);
                    //发现消息进入    开始处理前端触发逻辑
                };
                //关闭事件
                socket.onclose = function() {
                    console.log("websocket已关闭");
                };
                //发生了错误事件
                socket.onerror = function() {
                    console.log("websocket发生了错误");
                }
            }
        }
        function sendMessage() {
            if(typeof(WebSocket) == "undefined") {
                console.log("您的浏览器不支持WebSocket");
            }else {
                console.log("您的浏览器支持WebSocket");
                console.log('{"toUserId":"'+$("#toUserId").val()+'","contentText":"'+$("#contentText").val()+'"}');
                socket.send('{"toUserId":"'+$("#toUserId").val()+'","contentText":"'+$("#contentText").val()+'"}');
            }
        }
    </script>
    <body>
    <p>【userId】:<div><input id="userId" name="userId" type="text" value="10"></div>
    <p>【toUserId】:<div><input id="toUserId" name="toUserId" type="text" value="20"></div>
    <p>【toUserId】:<div><input id="contentText" name="contentText" type="text" value="hello websocket"></div>
    <p>【操作】:<div><a onclick="openSocket()">开启socket</a></div>
    <p>【操作】:<div><a onclick="sendMessage()">发送消息</a></div>
    </body>
    
    </html>
    

    运行效果

    • v20200105,加入开源项目spring-cloud-study-websocket,更新运行效果,更方便理解。
    • v1.1的效果,刚刚修复了日志,并且支持指定监听某个端口,代码已经全部更新,现在是这样的效果
    1. 打开两个页面,按F12调出控控制台查看测试效果:
    页面 参数
    http://localhost:9999/demo/page fromUserId=10,toUserId=20
    http://localhost:9999/demo/page fromUserId=20,toUserId=10

    分别开启socket,再发送消息
    在这里插入图片描述
    在这里插入图片描述
    2. 向前端推送数据:

    • http://localhost:9999/demo/push/10?message=123123

    在这里插入图片描述
    通过调用push api,可以向指定的userId推送信息,当然报文这里乱写,建议规定好格式。

    后续

    针对简单IM的业务场景,进行了一些优化,可以看后续的文章SpringBoot2+WebSocket之聊天应用实战(优化版本)(v20201005已整合)

    主要变动是CopyOnWriteArraySet改为ConcurrentHashMap,保证多线程安全同时方便利用map.get(userId)进行推送到指定端口。

    相比之前的Set,Set遍历是费事且麻烦的事情,而Map的get是简单便捷的,当WebSocket数量大的时候,这个小小的消耗就会聚少成多,影响体验,所以需要优化。在IM的场景下,指定userId进行推送消息更加方便。

    Websocker注入Bean问题

    关于这个问题,可以看最新发表的这篇文章,在参考和研究了网上一些攻略后,项目已经通过该方法注入成功,大家可以参考。
    关于controller调用controller/service调用service/util调用service/websocket中autowired的解决方法

    netty-websocket-spring-boot-starter

    Springboot2构建基于Netty的高性能Websocket服务器(netty-websocket-spring-boot-starter)
    只需要换个starter即可实现高性能websocket,赶紧使用吧

    Springboot2+Netty+Websocket

    Springboot2+Netty实现Websocket,使用官方的netty-all的包,比原生的websocket更加稳定更加高性能,同等配置情况下可以handle更多的连接。

    代码样式全部已经更正,也支持websocket连接url带参数功能,另外也感谢大家的阅读和评论,一起进步,谢谢!~~

    ServerEndpointExporter错误

    org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘serverEndpointExporter’ defined in class path resource [com/xxx/WebSocketConfig.class]: Invocation of init method failed; nested exception is java.lang.IllegalStateException: javax.websocket.server.ServerContainer not available

    感谢@来了老弟儿 的反馈:

    如果tomcat部署一直报这个错,请移除 WebSocketConfig@Bean ServerEndpointExporter 的注入 。

    ServerEndpointExporter 是由Spring官方提供的标准实现,用于扫描ServerEndpointConfig配置类和@ServerEndpoint注解实例。使用规则也很简单:

    1. 如果使用默认的嵌入式容器 比如Tomcat 则必须手工在上下文提供ServerEndpointExporter
    2. 如果使用外部容器部署war包,则不需要提供提供ServerEndpointExporter,因为此时SpringBoot默认将扫描服务端的行为交给外部容器处理,所以线上部署的时候要把WebSocketConfig中这段注入bean的代码注掉。

    正式项目的前端WebSocket框架 GoEasy

    感谢kkatrina的补充,正式的项目中,一般是用第三方websocket框架来做,稳定性、实时性有保证的多,也会包括一些心跳、重连机制。

    GoEasy专注于服务器与浏览器,浏览器与浏览器之间消息推送,完美兼容世界上的绝大多数浏览器,包括IE6, IE7之类的非常古老的浏览器。支持Uniapp,各种小程序,react,vue等所有主流Web前端技术。
    GoEasy采用 发布/订阅 的消息模式,帮助您非常轻松的实现一对一,一对多的通信。
    https://www.goeasy.io/cn/doc/

    @Component@ServerEndpoint关于是否单例模式,能否使用static Map等一些问题的解答

    看到大家都在热心的讨论关于是否单例模式这个问题,请大家相信自己的直接,如果websocket是单例模式,还怎么服务这么多session呢。

    1. websocket是原型模式@ServerEndpoint每次建立双向通信的时候都会创建一个实例,区别于spring的单例模式。
    2. Spring的@Component默认是单例模式,请注意,默认 而已,是可以被改变的。
    3. 这里的@Component仅仅为了支持@Autowired依赖注入使用,如果不加则不能注入任何东西,为了方便。
    4. 什么是prototype 原型模式? 基本就是你需要从A的实例得到一份与A内容相同,但是又互不干扰的实例B的话,就需要使用原型模式。
    5. 关于在原型模式下使用static 的webSocketMap,请注意这是ConcurrentHashMap ,也就是线程安全/线程同步的,而且已经是静态变量作为全局调用,这种情况下是ok的,或者大家如果有顾虑或者更好的想法的化,可以进行改进。 例如使用一个中间类来接收和存放session。
    6. 为什么每次都@OnOpen都要检查webSocketMap.containsKey(userId) ,首先了为了代码强壮性考虑,假设代码以及机制没有问题,那么肯定这个逻辑是废的对吧。但是实际使用的时候发现偶尔会出现重连失败或者其他原因导致之前的session还存在,这里就做了一个清除旧session,迎接新session的功能。

    Vue版本的websocket连接

    感谢**@GzrStudy**的贡献,供大家参考。

    <script>
    export default {
        data() {
            return {
                socket:null,
                userId:localStorage.getItem("ms_uuid"),
                toUserId:'2',
                content:'3'
            }
        },
      methods: {
        openSocket() {
          if (typeof WebSocket == "undefined") {
            console.log("您的浏览器不支持WebSocket");
          } else {
            console.log("您的浏览器支持WebSocket");
            //实现化WebSocket对象,指定要连接的服务器地址与端口  建立连接
            //等同于socket = new WebSocket("ws://localhost:8888/xxxx/im/25");
            //var socketUrl="${request.contextPath}/im/"+$("#userId").val();
            var socketUrl =
              "http://localhost:8081/imserver/" + this.userId;
            socketUrl = socketUrl.replace("https", "ws").replace("http", "ws");
            console.log(socketUrl);
            if (this.socket != null) {
              this.socket.close();
              this.socket = null;
            }
            this.socket = new WebSocket(socketUrl);
            //打开事件
            this.socket = new WebSocket(socketUrl);
            //打开事件
            this.socket.onopen = function() {
              console.log("websocket已打开");
              //socket.send("这是来自客户端的消息" + location.href + new Date());
            };
            //获得消息事件
            this.socket.onmessage = function(msg) {
              console.log(msg.data);
              //发现消息进入    开始处理前端触发逻辑
            };
            //关闭事件
            this.socket.onclose = function() {
              console.log("websocket已关闭");
            };
            //发生了错误事件
            this.socket.onerror = function() {
              console.log("websocket发生了错误");
            };
          }
        },
        sendMessage() {
          if (typeof WebSocket == "undefined") {
            console.log("您的浏览器不支持WebSocket");
          } else {
            console.log("您的浏览器支持WebSocket");
            console.log(
              '{"toUserId":"' +
                 this.toUserId +
                '","contentText":"' +
                 this.content +
                '"}'
            );
            this.socket.send(
              '{"toUserId":"' +
                 this.toUserId +
                '","contentText":"' +
                 this.content +
                '"}'
             );
        
        }
    }
    
    展开全文
  • WebSocket

    千次阅读 2015-08-03 17:25:24
    WebSocket的主要作用是,允许服务器端与客户端进行全双工(full-duplex)的通信。举例来说,HTTP协议有点像发电子邮件,发出后必须等待对方回信;WebSocket则是像打电话,服务器端和客户端可以同时向对方发送数据,...

    一、概述

    HTTP协议是一种无状态协议,服务器端本身不具有识别客户端的能力,必须借助外部机制,比如session和cookie,才能与特定客户端保持对话。

    WebSocket的主要作用是,允许服务器端与客户端进行全双工(full-duplex)的通信。举例来说,HTTP协议有点像发电子邮件,发出后必须等待对方回信;WebSocket则是像打电话,服务器端和客户端可以同时向对方发送数据,它们之间存着一条持续打开的数据通道。

    WebSocket协议完全可以取代Ajax方法,用来向服务器端发送文本和二进制数据,而且还没有“同域限制”。
    WebSocket不使用HTTP协议,而是使用自己的协议。WebSocket与http协议一样都是基于TCP的,属于应用层的协议,所以他们都是可靠的协议。WebSocket在建立握手连接时,数据是通过http协议传输的,但是在建立连接之后,真正的数据传输阶段是不需要http协议参与的。

    请求:
    GET / HTTP/1.1
    Connection: Upgrade		//表示浏览器通知服务器,如果可以,就升级到webSocket协议
    Upgrade: websocket 		//表示将通信协议从HTTP/1.1转向该项所指定的协议
    Host: example.com
    Origin: null			//验证浏览器域名是否在服务器许可的范围内
    Sec-WebSocket-Key: sN9cRrP/n9NdMgdcy2VJFQ==	//握手协议的密钥,是base64编码的16字节随机字符串
    Sec-WebSocket-Version: 13
    响应:
    HTTP/1.1 101 Switching Protocols
    Connection: Upgrade
    Upgrade: websocket
    Sec-WebSocket-Accept: fFBooB7FAkLlXgRSz0BT3v4hq5s=
    Sec-WebSocket-Origin: null
    Sec-WebSocket-Location: ws://example.com/	//表示进行通信的WebSocket网址
    注意:WebSocket协议用ws表示。此外,还有wss协议,表示加密的WebSocket协议,对应HTTPS协议。

    二、客户端

    1. 建立连接和断开连接、发送数据和接收数据、处理错误。
    2. WebSocket实例对象有一个readyState属性,表示目前的状态,可取4个值:
    【0:正在连接;1:连接成功;2:正在关闭;3:连接关闭】
    3. 客户端建立WebSocket流程:
    (0)检测浏览器是否支持WebSocket
    (1)握手协议成功以后,readyState就从0变为1,并触发open事件
    (2)关闭WebSocket连接,会触发close事件
    (3)客户端收到服务器发送的数据,会触发message事件
    (4)连接建立后,客户端通过send方法向服务器端发送数据
    if(window.WebSocket != undefined) {
    	var ws = new WebSocket("ws://localhost:10010");
    	ws.onopen = function(){
    		console.log("Opened!");
    		ws.send("I'm client,call server!!!");
    	};
    	ws.onclose = function(){
    		console.log("over!!!");
    	};
    	ws.onmessage = function(event){
    		console.log(event.data);
    	};
    	ws.onerror = function(error){
    		console.log("Error: "+ err);
    	}
    }

    三、服务器端

    使用ws(https://www.npmjs.com/package/ws)模块部署简单的服务器。
    var WebSocketServer = require('ws').Server;
    var wss = new WebSocketServer({port: 10010});
    wss.on('connection', function(conn) {
        //console.log(conn);
        conn.on('message', function(message) {
            console.log('received: %s', message);
            conn.send("I'm server,received your infomation!!!");
        });
    });
    [转载请标明出处:http://blog.csdn.net/ligang2585116]

    展开全文
  • webSocket

    2016-10-17 15:21:49
    WebSocket概述 WebSocket是基于H5规范的,WebSocket 类用于发送和接收数据。 在 H5 规范中,定义了客户端和服务器通讯的 WebSocket 方式,在得到浏览器支持以后,WebSocket 将会取代 Comet成为服务器推送的方法。...

    WebSocket概述

    WebSocket是基于H5规范的,WebSocket 类用于发送和接收数据。 在 H5 规范中,定义了客户端和服务器通讯的 WebSocket 方式,在得到浏览器支持以后,WebSocket 将会取代 Comet成为服务器推送的方法。 目前 Chrome、Firefox、Opera、Safari 等主流版本均支持,Internet Explorer从10开始支持。 WebSocket 标准在很大程度上简化了复杂的双向网络沟通和连接管理。

    下图显示了一个基于 WebSocket 的基本结构,在这种结构中,浏览器使用全双工的WebSocket连接,直接与远程主机通信:

    Egret 的 WebSocket 即为 H5 的 WebSocket 封装。

    用WebSocket进行通讯的基本过程

    确保项目支持WebSocket

    Egret 以官方扩展模块的形式支持 WebSocket。在现有的 Egret 项目中,修改 egretProperties.json 中的 modules 字段,在字段的最后添加 socket 模块:

    1. "name": "socket"

    在项目所在目录内执行一次引擎编译:

    1. egret build -e

    本步骤已经完成,现在项目中既可以使用WebSocket相关的API了。

    WebSocket对象

    所有的通讯都是基于一个WebSocket实例,首先创建WebSocket对象:

    1. var sock:egret.WebSocket = new egret.WebSocket();

    侦听事件

    WebSocket对象主要有两个事件,一个是连接服务器成功,另一个是收到服务器数据:

    1. sock.addEventListener( egret.ProgressEvent.SOCKET_DATA, onReceiveMessage, this );
    2. sock.addEventListener( egret.Event.CONNECT, onSocketOpen, this );

    连接服务器

    加入侦听事件后,即可连接服务器。注意像所有的通讯协议一样,服务器需要支持WebSocket协议,为便于测试,WebSocket官方提供了一个专用于测试的服务器echo.websocket.org,连接其80端口即可测试:

    1. sock.connect("echo.websocket.org", 80);

    发送消息

    连接成功后,即可发送消息,在前述的onSocketOpen处理函数中加入发送消息代码:

    1. var cmd = '{"cmd":"uzwan_login","gameId":"0","from":"guzwan","userId":"3565526"}';
    2. sock.writeUTF(cmd);

    消息的具体格式都是根据情况自己定义的,通常是json格式,便于解析。当然可以自定义其他的字符串格式。

    接收消息

    服务器根据约定的格式返回消息,则会触发SOCKET_DATA事件,在其事件处理函数onReceiveMessage中即可读取消息:

    1. var msg = sock.readUTF();

    读取到字符串后,即可根据约定的格式解析。

    使用示例

    将上一节所述的各部分用法连接起来:

    1. private webSocket:egret.WebSocket;
    2. private createGameScene():void {
    3. this.webSocket = new egret.WebSocket();
    4. this.webSocket.addEventListener(egret.ProgressEvent.SOCKET_DATA, this.onReceiveMessage, this);
    5. this.webSocket.addEventListener(egret.Event.CONNECT, this.onSocketOpen, this);
    6. this.webSocket.connect("echo.websocket.org", 80);
    7. }
    8. private onSocketOpen():void {
    9. var cmd = "Hello Egret WebSocket";
    10. console.log("连接成功,发送数据:" + cmd);
    11. this.webSocket.writeUTF(cmd);
    12. }
    13. private onReceiveMessage(e:egret.Event):void {
    14. var msg = this.webSocket.readUTF();
    15. console.log("收到数据:" + msg);
    16. }
    展开全文
  • websocket

    千次阅读 2013-12-04 11:02:51
    http://www.iis.net/learn/get-started/whats-new-in-iis-8/iis-80-websocket-protocol-support ...WebSocket API 在本文中 实现 WebSocket WebSocket 编程 API 参考 IEBlog 文章 规范 相关主题 Internet Explo
    
    

    IIS 8.0 WebSocket Protocol Support

    By Microsoft

    November 28, 2012

    Compatibility

    Version Notes
    IIS 8.0 The WebSocket Protocol was introduced in IIS 8.0.
    IIS 7.5 The WebSocket Protocol was not supported in IIS 7.5.
    IIS 7.0 The WebSocket Protocol was not supported in IIS 7.0.

    Contents

    Problem

    One of the limitations to HTTP is that it was designed as a one-directional method of communication. However, many modern web-based applications require more real-time, two-way communications in order to function optimally.

    Solution

    With the release of Windows Server 2012 and Windows 8, Internet Information Services (IIS) 8.0 has added support for the WebSocket Protocol.

    The WebSocket Protocol is an open standard that is defined in RFC 6455, and developers can use this functionality to create applications that implement two-way communications over the Internet between a client and server. For more information about the WebSocket Protocol, see the following articles:

    Step by Step Instructions

    To enable support for the WebSocket Protocol on Windows Server 2012, use the following steps:

    1. Open Server Manager.
    2. Under the Manage menu, click Add Roles and Features.
    3. Select Role-based or Feature-based Installation, and then click Next.
    4. Select the appropriate server, (your local server is selected by default), and then click Next.
    5. Expand Web Server (IIS) in the Roles tree, then expand Web Server, and then expand Application Development.
    6. Select WebSocket Protocol, and then click Next.
    7. If no additional features are needed, click Next.
    8. Click Install.
    9. When the installation completes, click Close to exit the wizard.

    Summary

    IIS 8.0 has added support for WebSocket Protocol, which enables dynamic, two-way communications over the Internet. Additional information can be found on the following URLs:

     
    WebSocket API

    Internet Explorer 10 和使用 JavaScript 的 Windows 应用商店应用引入了对 WebSocket API 的支持,其定义位于万维网联盟 (W3C) 的 WebSocket API 规范中。WebSockets 技术为通过 Internet 进行的双向通信提供了一个新的 W3C JavaScript API 和协议。这个新协议更便于直接处理固定数据格式,它会绕过速度较慢的基于文档的 HTTP 协议。

    当前的 HTTP 标准协议很慢,因为它必须从服务器请求文档而且必须等待该文档发送,才能显示网页。使用 WebSocket,你可以使用文本、二进制数组或 BLOB 立即发送和接收你的数据。

    WebSocket API 非常简单,它只需非常少的代码。你可以方便地利用低延迟双向数据交换,从而有助于快速创建在线游戏、即时社交网络通知、实时显示股市和天气信息,以及其他实时数据。

    实现 WebSocket

    如果你按照下列步骤进行操作,则实现此数据交换新技术将非常简单:

    1. 使用一个客户端浏览器来实现 WebSocket 协议。
    2. 在网页中编写代码来创建客户端 Websocket。
    3. 在 Web 服务器上编写代码来通过 Websocket 响应客户端请求。

    使用 WebSocket 客户端

    Internet Explorer 10 实现 WebSocket 协议,如同其他主流浏览器的行为。你可在 caniuse.com 网站上看到浏览器支持的当前状态。

    IETF 工具网站中指定的 WebSocket 协议使用以下新的 URL 方案。

    1. ws://
    2. wss://

    编写 WebSocket 客户端代码

    你的网页代码必须执行以下操作:

    1. 初始化 websocket 并连接到服务器。
    2. 测试以查看它是否成功。
    3. 发送和接收数据。

    以下代码显示了指定 websocket URL 的典型代码:

    1. var host = 'ws://example.microsoft.com';

    以下代码显示了如何连接到 websocket 并测试以查看它是否成功。

    1.  var host = "ws://sample-host/echo";
    2.  try {
    3.     socket = new WebSocket(host);
    4.  
    5.     socket.onopen = function (openEvent) {
    6.        document.getElementById("serverStatus").innerHTML = 
    7.           'WebSocket Status:: Socket Open';
    8.     };
    9.  
    10.  socket.onmessage = function (messageEvent) {
    11.  
    12.     if (messageEvent.data instanceof Blob) {
    13.     var destinationCanvas = document.getElementById('destination');
    14.     var destinationContext = destinationCanvas.getContext('2d');
    15.     var image = new Image();
    16.     image.onload = function () {
    17.        destinationContext.clearRect(00
    18.           destinationCanvas.width, destinationCanvas.height);
    19.        destinationContext.drawImage(image, 00);
    20.     }
    21.     image.src = URL.createObjectURL(messageEvent.data);
    22.  } else {
    23.     document.getElementById("serverResponse").innerHTML = 
    24.        'Server Reply:: ' + messageEvent.data;
    25.     }
    26.  };
    27.  
    28.  socket.onerror = function (errorEvent) {
    29.     document.getElementById("serverStatus").innerHTML = 
    30.       'WebSocket Status:: Error was reported';
    31.     };
    32.  
    33.  socket.onclose = function (closeEvent) {
    34.     document.getElementById("serverStatus").innerHTML = 
    35.       'WebSocket Status:: Socket Closed';
    36.     };
    37.  }
    38.   catch (exception) { if (window.console) console.log(exception); }
    39.  }
    40.  
    41.  function sendTextMessage() {
    42.  
    43.     if (socket.readyState != WebSocket.OPEN) return;
    44.  
    45.     var e = document.getElementById("textmessage");
    46.     socket.send(e.value);
    47.  }
    48.  
    49.  function sendBinaryMessage() {
    50.     if (socket.readyState != WebSocket.OPEN) return;
    51.  
    52.     var sourceCanvas = document.getElementById('source');
    53.  
    54.     socket.send(sourceCanvas.msToBlob());
    55.  }    

    前面的代码假设你有 serverStatus、destination、serverResponse、textmessage 和 serverData作为你的网页中带 ID 的元素。如果 F12 开发人员工具正在运行,捕获结果将显示在控制台窗口中。要发送文本消息数据,请使用以下类型的代码。

    1. var e = document.getElementById("msgText");
    2. socket.send(e.value);

    上面的代码示例假设你有要使用网页中带 ID 的 msgText 元素发送的消息文本。同样,你可以使用 onmessage 事件检测新消息或使用 send 方法发送消息到服务器。send 方法可用于发送文本、二进制数组或 Blob 数据。

    编写 WebSocket 服务器代码

    处理套接字的服务器代码能够以任何服务器语言编写。无论你选择哪种语言,都必须编写代码以接受 WebSocket 请求并相应地处理它们。

    WebSocket 编程

    WebSocket 提供一组可用于 WebSocket 编程的对象、方法和属性。

    名称 类型 描述
    WebSocket 对象 提供到远程主机的双向通道。
    close 方法 关闭 websocket。
    send 方法 使用 websocket 发送数据到服务器。
    binaryType 属性 onmessage 接收的二进制数据格式。
    bufferedAmount 属性 使用 send 的已排队的数据字节数。
    extensions 属性 报告服务器所选中的扩展名。
    onclose 属性 当套接字关闭时调用的事件处理程序。
    onerror 属性 当出现错误时调用的事件处理程序。
    onmessage 属性 通知接收到消息的事件处理程序。
    onopen 属性 当 websocket 已连接时调用的事件处理程序。
    protocol 属性 报告服务器所选中的协议。
    readyState 属性 报告 websocket 连接的状态。
    url 属性 报告套接字的当前 URL。

     

    API 参考

    WebSocket API

    IEBlog 文章

    Windows Consumer Preview 中的 WebSocket
    支持站点的 WebSocket

    规范

    WebSocket API

    相关主题

    使用 HTML5 WebSocket 构建实时 Web 应用
    通过使用 IIS、ASP.NET 和 WCF 的 WebSocket 构建实时 Web 应用
    构建 Windows 运行时套接字应用
    Windows 8 中的 WebSocket 入门
    了解 System.Net.WebSocket:简单的 ASP.NET 回显服务器
    WebSocket:稳定可靠,随时可供开发人员使用

    WebSockets: Stable and Ready for Developers

    By Brian Raymor

    WebSockets are stable and ready for developers to start creating innovative applications and services. This tutorial provides a simple introduction to the W3CWebSocket API and its underlyingWebSocket protocol. The updatedFlipbook demo uses the latest version of the API and protocol.

    Working groups have made significant progress and the WebSocket API is a W3C Candidate Recommendation. Internet Explorer 10 implements this version of the spec.  You can learn about the evolution of the spechere

    WebSockets enable Web applications to deliver real-time notifications and updates in the browser. Developers have faced problems in working around the limitations in the browser’s original HTTP request-response model, which was not designed for real-time scenarios. WebSockets enable browsers to open a bidirectional, full-duplex communication channel with services. Each side can then use this channel to immediately send data to the other. Now, sites from social networking and games to financial sites can deliver better real-time scenarios, ideally using same markup across different browsers.

    Introduction to the WebSocket API Using an Echo Example

    The code snippets below use a simple echo server created with ASP.NET’s System.Web.WebSockets namespace to echo back text and binary messages that are sent from the application. The application allows the user to type in text to be sent and echoed back as a text message or draw a picture that can be sent and echoed back as a binary message.

    For a more complex example that allows you to experiment with latency and performance differences between WebSockets and HTTP polling, see theFlipbook demo.

    Details of Connecting to a WebSocket Server

    This simple explanation is based on a direct connection between the application and the server. If a proxy is configured, then IE10 starts the process by sending a HTTP CONNECT request to the proxy.

    When a WebSocket object is created, a handshake is exchanged between the client and the server to establish the WebSocket connection.

    IE10 starts the process by sending a HTTP request to the server:

    1. GET /echo HTTP/1.1
    2. Host: example.microsoft.com
    3. Upgrade: websocket
    4. Connection: Upgrade
    5. Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
    6. Origin: http://microsoft.com
    7. Sec-WebSocket-Version: 13

    Let’s look at each part of this request.

    The connection process starts with a standard HTTP GET request which allows the request to traverse firewalls, proxies, and other intermediaries:

    1. GET /echo HTTP/1.1
    2. Host: example.microsoft.com

    The HTTP Upgrade header requests that the server switch the application-layer protocol from HTTP to the WebSocket protocol.

    1. Upgrade: websocket
    2. Connection: Upgrade

    The server transforms the value in the Sec-WebSocket-Key header in its response to demonstrate that it understands the WebSocket protocol:

    1. Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==

    The Origin header is set by IE10 to allow the server to enforce origin-based security.

    1. Origin: http://microsoft.com

    The Sec-WebSocket-Version header identifies the requested protocol version. Version 13 is the final version in the IETF proposed standard:

    1. Sec-WebSocket-Version: 13

    If the server accepts the request to upgrade the application-layer protocol, it returns aHTTP 101 Switching Protocols response:

    HTTP/1.1 101 Switching Protocols
    Upgrade: websocket
    Connection: Upgrade

    To demonstrate that it understands the WebSocket Protocol, the server performs a standardized transformation on the Sec-WebSocket-Key from the client request and returns the results in the Sec-WebSocket-Accept header:

    1. Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

    IE10 then compares Sec-WebSocket-Key with Sec-WebSocket-Accept to validate that the server is a WebSocket server and not a HTTP server with delusions of grandeur.

    The client handshake established a HTTP-on-TCP connection between IE10 and server. After the server returns its 101 response, the application-layer protocol switches from HTTP to WebSockets which uses the previously established TCP connection.

    HTTP is completely out of the picture at this point. Using the lightweight WebSocket wire protocol, messages can now be sent or received by either endpoint at any time.

    Programming Connecting to a WebSocket Server

    The WebSocket protocol defines two new URI schemes which are similar to the HTTP schemes.

    • "ws:" "//" host [ ":" port ] path [ "?" query ] is modeled on the “http:” scheme. Its default port is 80. It is used for unsecure (unencrypted) connections.
    • "wss:" "//" host [ ":" port ] path [ "?" query ] is modeled on the “https:” scheme. Its default port is 443. It is used for secure connections tunneled overTransport Layer Security.

    When proxies or network intermediaries are present, there is a higher probability that secure connections will be successful, as intermediaries are less inclined to attempt to transform secure traffic.

    The following code snippet establishes a WebSocket connection:

    1. var host = "ws://example.microsoft.com";
    2. var socket = new WebSocket(host);

    ReadyState – Ready … Set … Go …

    The WebSocket.readyState attribute represents the state of the connection: CONNECTING, OPEN, CLOSING, or CLOSED. When the WebSocket is first created, the readyState is set to CONNECTING. When the connection is established, the readyState is set to OPEN. If the connection fails to be established, then the readyState is set to CLOSED.

    Registering for Open Events

    To receive notifications when the connection has been created, the application must register for open events.

    1. socket.onopen = function (openEvent) {
    2. document.getElementById("serverStatus").innerHTML = 'Web Socket State::' + 'OPEN';
    3. };

    Details Behind Sending and Receiving Messages

    After a successful handshake, the application and the Websocket server may exchange WebSocket messages. A message is composed as a sequence of one or more message fragments or data “frames.”

    Each frame includes information such as:

    • Frame length
    • Type of message (binary or text) in the first frame in the message
    • A flag (FIN) indicating whether this is the last frame in the message

    IE10 reassembles the frames into a complete message before passing it to the script.

    Programming Sending and Receiving Messages

    The send API allows applications to send messages to a Websocket server as UTF-8 text,ArrayBuffers, or Blobs.

    For example, this snippet retrieves the text entered by the user and sends it to the server as a UTF-8 text message to be echoed back. It verifies that the Websocket is in an OPEN readyState:

    1. function sendTextMessage() {
    2. if (socket.readyState != WebSocket.OPEN)
    3. return;
    4. var e = document.getElementById("textmessage");
    5. socket.send(e.value);
    6. }

    This snippet retrieves the image drawn by the user in a canvas and sends it to the server as a binary message:

    1. function sendBinaryMessage() {
    2. if (socket.readyState != WebSocket.OPEN)
    3. return;
    4. var sourceCanvas = document.getElementById('source');
    5. // msToBlob returns a blob object from a canvas image or drawing
    6. socket.send(sourceCanvas.msToBlob());
    7. // ...
    8. }

    Registering for Message Events

    To receive messages, the application must register for message events. The event handler receives a MessageEvent which contains the data in MessageEvent.data. Data can be received as text or binary messages.

    When a binary message is received, the WebSocket.binaryType attribute controls whether the message data is returned as a Blob or an ArrayBuffer datatype. The attribute can be set to either “blob” or “arraybuffer.”

    The examples below use the default value which is “blob.”

    This snippet receives the echoed image or text from the websocket server. If the data is a Blob, then an image was returned and is drawn in the destination canvas; otherwise, a UTF-8 text message was returned and is displayed in a text field.

    1. socket.onmessage = function (messageEvent) {
    2. if (messageEvent.data instanceof Blob) {
    3. var destinationCanvas = document.getElementById('destination');
    4. var destinationContext = destinationCanvas.getContext('2d');
    5. var image = new Image();
    6. image.onload = function () {
    7. destinationContext.clearRect(0, 0, destinationCanvas.width, destinationCanvas.height);
    8. destinationContext.drawImage(image, 0, 0);
    9. }
    10. image.src = URL.createObjectURL(messageEvent.data);
    11. } else {
    12. document.getElementById("textresponse").value = messageEvent.data;
    13. }
    14. };

    Details of Closing a WebSocket Connection

    Similar to the opening handshake, there is a closing handshake. Either endpoint (the application or the server) can initiate this handshake.

    A special kind of frame – a close frame – is sent to the other endpoint. The close frame may contain an optional status code and reason for the close. The protocol defines a set of appropriatevalues for the status code. The sender of the close frame must not send further application data after the close frame.

    When the other endpoint receives the close frame, it responds with its own close frame in response. It may send pending messages prior to responding with the close frame.

    Programming Closing a WebSocket and Registering for Close Events

    The application initiates the close handshake on an open connection with the close API:

    socket.close(1000, "normal close");

    To receive notifications when the connection has been closed, the application must register for close events.

    1. socket.onclose = function (closeEvent) {
    2. document.getElementById("serverStatus").innerHTML = 'Web Socket State::' + 'CLOSED';
    3. };

    The close API accepts two optional parameters: a status code as defined by the protocol and a description. The status code must be either 1000 or in the range 3000 to 4999. When close is executed, the readyState attribute is set to CLOSING. After IE10 receives the close response from the server, the readyState attribute is set to CLOSED and a close event is fired.

    Using Fiddler to See WebSockets Traffic

    Fiddler is a popular HTTP debugging proxy. There is some support in the latest versions for the WebSocket protocol. You can inspect the headers exchanged in the WebSocket handshake:

    All the WebSocket messages are also logged. In the screenshot below, you can see that “spiral” was sent to the server as a UTF-8 text message and echoed back:

    Conclusion

    If you want to learn more about WebSockets, you may watch these sessions from the Microsoft //Build/ conference from September 2011:

    If you’re curious about using Microsoft technologies to create a WebSocket service, these posts are good introductions:

    Start developing with WebSockets today!

    About the Author

    Brian Raymor is a Senior Program Manager in the Windows Networking group at Microsoft.

     

    展开全文
  • 看完让你彻底搞懂Websocket原理

    万次阅读 多人点赞 2016-03-11 15:46:38
    偶然在知乎上看到一篇回帖,瞬间觉得之前看的那么多资料都不及这一篇回帖让我对websocket的认识深刻有木有。所以转到我博客里,分享一下。比较喜欢看这种博客,读起来很轻松,不枯燥,没有布道师的阵仗,纯粹为分享...
  • 网络协议、socket、webSocket

    万次阅读 多人点赞 2019-07-31 19:20:28
    一、网络协议 网络协议为计算机网络中进行数据交换而建立的规则、标准或约定的集合。 1、OSI七层协议 OSI是一个开放性的通信系统互连参考模型,他是一个定义得非常好的协议规范。OSI模型有7层结构,从上到下分别...
  • 最近在做的两个系统中都用到了webSocket,一个是实时转译系统,该系统就是通过收集端收音,然后实时将录音转换成文字显示到页面上,第二个是智能客服系统。由于之前用webSocket比较少,一直以为在创建连接的时候,不...
  • WebSocket解析

    千次阅读 2019-10-21 15:56:39
    websocket
  • websocket最伟大之处在于服务器和客户端可以在给定的时间范围内的任意时刻,相互推送信息。 浏览器和服务器只需要要做一个握手的动作,在建立连接之后,服务器可以主动传送数据给客户端,客户端也可以随时向服务器...
  • 基于Tomcat7、Java、Ext、WebSocket的聊天室

    千次下载 热门讨论 2013-08-01 21:41:11
    项目可以直接导入,一个基于Tomcat7、Java、Ext、WebSocket的聊天室,分数是3分,目的不是为了赚分,是为了大家能够评论,提出意见。
  • springboot+websocket实现服务端、客户端

    万次阅读 多人点赞 2019-01-12 12:54:43
    一、引言 小编最近一直在使用springboot框架...websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。 二、websocket介...
  • websocket之参数传递和依赖注入

    万次阅读 2017-03-14 10:39:00
    我在通过websocket实现这个功能的过程中遇到了2个问题:websocket建立连接时需要传递参数(例如服务器ip,项目名称,日志文件位置等)进去;需要注入service 层的类,以便在onOpen()方法中进行数据查询和业务处理...
  • websocket协议初探

    万次阅读 2020-05-13 17:17:40
    1 什么是websocket协议? WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。 相对于以前的http协议,websocket协议能够实现浏览器与...
  • JMeter测试WebSocket的经验总结

    万次阅读 多人点赞 2018-08-03 10:06:29
    最近有一个微信聊天系统的项目需要性能测试,既然是测试微信聊天,肯定绕不开websocket接口的测试,首选工具是Jmeter,网上能搜到现成的方法,但是网上提供的jar包往往不是最新的,既然是用最新版本的Jmeter4.0,...
  • Java WebSocket客户端java WebSocketClient

    万次阅读 热门讨论 2018-01-09 17:52:31
    一、java客户端实现代码   package ggmes.websocket.client; import java.net.URI; import java.net.URISyntaxException;...import org.java_websocket.client.WebSocketClient; import org.ja...
  • http/https与websocket的ws/wss的关系

    万次阅读 多人点赞 2018-08-14 21:06:19
    今天在域名升级到HTTPS的时候遇到websocket的链接问题,之前在http下使用的是new WebSocket('ws://xxx');但是在切换到HTTPS后这个链接部分浏览器报错甚至代码整体抛出异常走不下去了,之前没有注意过websocket在两个...
  • WebSocket WebSocket的简单用法 WebSocket的使用
  • websocket 爬虫

    千次阅读 2018-08-08 13:05:28
    有些网站为了追求数据的实时更新,很多时候会采用 websocket 的方式,例如股票交易数据、数据货币交易平台等。关于websocket的机制,网上不乏相关资料。但关于websocket的爬虫文章,还是比较少的。所以特地写此文章...
  • [C#] WebSocket 客户端+服务端 轻松实现

    万次阅读 2017-07-05 14:40:59
     随着HTML5 WebSocket技术的日益成熟与普及,我们可以借助WebSocket来更加方便地打通BS与CS -- 因为B/S中的WebSocket可以直接连接到C/S的服务端,并进行双向通信。如下图所示:   一.对Socket Server的要求
  • 在Spring Boot框架下使用WebSocket实现消息推送

    万次阅读 多人点赞 2016-12-23 16:48:37
    Spring Boot的学习持续进行中。前面两篇博客我们介绍了如何使用Spring Boot容器搭建Web项目(使用Spring Boot开发Web项目)以及怎样为我们的Project添加HTTPS的支持(使用Spring Boot开发Web项目(二)之...什么是WebSocket
  • C# ASP.NET MVC WebSocket

    千次下载 热门讨论 2012-10-20 18:03:30
    用ASP.NET MVC C#语言实现WebSocket
  • java实现websocket client

    千次下载 热门讨论 2013-11-08 17:47:12
    java_websocket.jar最新jar包 可用java实现websocket客户端,使用demo: https://github.com/TooTallNate/Java-WebSocket/blob/master/src/main/example/ExampleClient.java
  • JAVA+WebSocket聊天室(WebSocket示例)

    千次下载 热门讨论 2012-11-18 16:27:39
    3 lib下的catalina.jar 和 tomcat-coyote.jar取自TOMCAT7.0.32,所以如果部署在TOMCAT7.0.32上就重复了,那么删除WebSocketDemo1/WebRoot/WEB-INF/lib/*.jar 如果部署在其它版本的TOMCAT可以保留(未试过)。
  • websocket-sharp.clone, Version=1.0.2.39869 WebSocket由方法调用事件改为实例化委托调用,两种构造 1.构造函数 第一种 1 // 2 // 摘要: 3 // Initializes a new instance of the WebSocketSharp....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,089
精华内容 26,035
关键字:

websocket