精华内容
下载资源
问答
  • java基于socket服务端向客户端推送信息,反向消息推送,登录上线提示。java基于socket服务端向客户端推送信息,反向消息推送,登录上线提示。
  • springboot+webSocket实现服务端向客户端推送消息(扫码登录) Java实现Websocket通常有两种方式: 1、创建WebSocketServer类,里面包含open、close、message、error等方法; 2、利用Springboot提供的webSocketHandler...

    springboot+webSocket实现服务端向客户端推送消息(扫码登录)

    Java实现Websocket通常有两种方式:
    1、创建WebSocketServer类,里面包含open、close、message、error等方法;
    2、利用Springboot提供的webSocketHandler类,创建其子类并重写方法。我们项目虽然使用Springboot框架,不过仍采用了第一种方法实现

    (1)websocket依赖

    <!--websocket支持包-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
    

    (2)创建配置类WebSocketConfig

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    @Configuration
    public class WebSocketConfig {
        /**
         * 如果使用Springboot默认内置的tomcat容器,则必须注入ServerEndpoint的bean;
         * 如果使用外置的web容器,则不需要提供ServerEndpointExporter,下面的注入可以注解掉
         */
        @Bean
        public ServerEndpointExporter serverEndpointExporter(){
            return new ServerEndpointExporter();
        }
    }
    

    (3)创建webocketServer

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    import javax.websocket.*;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import java.io.IOException;
    import java.util.concurrent.CopyOnWriteArraySet;
    
    /**
     * @ServerEndpoint 注解是一个类层次的注解,它的功能主要是将目前的类定义成一个websocket服务器端,
     * 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
     * @ServerEndpoint 可以把当前类变成websocket服务类
     */
    @Slf4j
    @ServerEndpoint("/websocket/{userName}/{deptId}")
    @Component
    public class WebSocketServer {
        //静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
        private static int onlineCount = 0;
    
        //concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。
        private static CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<WebSocketServer>();
    
        //与某个客户端的连接会话,需要通过它来给客户端发送数据
        private Session session;
    
        /**
         * 连接建立成功调用的方法
         */
        @OnOpen
        public void onOpen(Session session, @PathParam("userName")String userName,@PathParam("deptId")Integer deptId) throws IOException {
            this.session = session;
            //加入set中
            webSocketSet.add(this);
            //在线数加1
            addOnlineCount();
           ~~业务~~ 
            log.info("有新连接加入!当前在线人数为" + getOnlineCount());
        }
    
        /**
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose(@PathParam("userName")String userName,@PathParam("deptId")Integer deptId){
            //从set中删除
            webSocketSet.remove(this);
            //在线数减1
            subOnlineCount();
           ~~业务~~ 
            log.info("有一连接关闭!当前在线人数为" + getOnlineCount());
        }
    
        /**
         * 收到客户端消息后调用的方法
         * @param message 客户端发送过来的消息
         */
        @OnMessage
        public void onMessage(String message, Session session,@PathParam("userName")String userName,@PathParam("deptId")Integer deptId) {
            log.info("客户端发送的消息{},客户端连接个数,{}",message,onlineCount);
            ~~业务~~ 
        }
    
        /**
         * 发生错误时调用
         */
         @OnError
         public void onError(Session session, Throwable error) throws IOException {
             log.error("发生错误:{},SessionID: {}",error.getMessage(),session.getId());
             this.session.getBasicRemote().sendText("error");
             error.printStackTrace();
         }
    
        /**
         * 实现服务器主动推送
         */
         public void sendMessage(String message) throws IOException {
             try {
                 log.info("后台向前台发送数据:{}",message);
                 this.session.getBasicRemote().sendText(message);
             } catch (IOException e) {
                 log.error("发送消息出错:{}", e.getMessage());
                 e.printStackTrace();
             }
         }
    
    
        public static synchronized int getOnlineCount() {
            return onlineCount;
        }
    
        public static synchronized void addOnlineCount() {
            WebSocketServer.onlineCount++;
        }
    
        public static synchronized void subOnlineCount() {
            WebSocketServer.onlineCount--;
        }
    }
    
    
    

    (4)服务端提供接口进行消息推送

    import com.alibaba.fastjson.JSON;
    import com.breezedi.common.core.controller.BaseController;
    import com.breezedi.common.core.domain.AjaxResult;
    import com.breezedi.common.utils.DateUtils;
    import com.google.common.cache.Cache;
    import com.google.common.cache.CacheBuilder;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 二维码相关
     */
    @CrossOrigin
    @RestController
    @RequestMapping("/qrcode")
    @Slf4j
    public class QRCodeController extends BaseController {
    
        //需要验证的用户保存到这里
        public static Map<String,String> waitForUserValid  = new HashMap<>();
    
        //定时缓存用户数据==判斷60秒
        public static Cache<String, Object> numCache = CacheBuilder.newBuilder()
                .expireAfterWrite(1, TimeUnit.MINUTES)
                .build();
    
        //定时缓存用户数据
        public static Cache<String, Object> numCacheScan = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build();
    
        //验证
        public static Cache<String, Object> validation = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build();
    
        //用户扫码购买取消长连接
        public static Cache<String, Object> buyPkgValidation = CacheBuilder.newBuilder()
                .expireAfterWrite(1, TimeUnit.MINUTES)
                .build();
    
        /**
         * 门槛验证时通过手机扫码
         */
        @GetMapping(value = "/api/scan/{userName}/{deptId}/{cpId}/{userId}")
        public AjaxResult scanChooseCpUser(@PathVariable("userName")String userName, @PathVariable("deptId")Long deptId,@PathVariable("cpId")Long cpId,@PathVariable("userId")Long userId,@RequestParam(required = false) Long pkgId,@RequestParam(required = false) Long detailId){
             ~~业务~~ 
            ~~if (waitForUserValid.containsKey(userName+"-"+deptId)){
                waitForUserValid.put(userName+"-"+deptId,sb.toString());
            }
            numCacheScan.invalidate(userName+"-"+deptId);~~ 
            return AjaxResult.success();
        }
    
    }
    

    (5)客户端调用消息推送接口接受消息

    客户端调用发送消息的链接: wss://域名+路径/websocket/参数/参数

    <!DOCTYPE HTML>getOrderList
    <html>
    <head>
        <meta charset="utf-8">
        <title>菜鸟教程(runoob.com)</title>
        <script type="text/javascript">
            function clock(){
                console.log(1);
            }
            function WebSocketTest(){
                if ("WebSocket" in window){
                    alert("您的浏览器支持 WebSocket!");
                    // 打开一个 web socket
                    var ws = new WebSocket(`ws://localhost:9083/admin/websocket/aaaa/103`);
                    ws.onopen = function(){
                        // Web Socket 已连接上,使用 send() 方法发送数据
                        ws.send("发送数据");
                        alert("数据发送中...");
                        self.setInterval(function (){
                            ws.send("help");
                        },1000);
                    };
                    ws.onmessage = function (evt){
                        var received_msg = evt.data;
                        console.log("前台接收到后台推送的数据:"+received_msg);
                        ws.close();
                        alert("数据已接收...");
                    };
                    ws.onclose = function(){
                        // 关闭 websocket
                        alert("连接已关闭...");
                    };
                }
                else{
                    // 浏览器不支持 WebSocket
                    alert("您的浏览器不支持 WebSocket!");
                }
            }
        </script>
    </head>
    <body>
    <div id="sse">
        <a href="javascript:WebSocketTest()">运行 WebSocket</a>
    </div>
    </body>
    </html>
    

    (6)nginx配置wss访问

    	server {
    			listen       443 ssl;
    	        server_name  ~~xxxxxxxxxxxx~~ ;
    			ssl_certificate     ~~xxxxxxxxxxx~~ ;
    	        ssl_certificate_key  ~~xxxxxxxxxxxxxxx~~ ;
    			ssl_session_timeout 5m;
    	      
    			#websocket配置
    			location /admin/websocket {  #注意路径要写对
    				proxy_pass http://127.0.0.1:9083/admin/websocket;
    				
    				proxy_http_version 1.1;
    				proxy_connect_timeout 4s;
    				proxy_read_timeout 7200s;
    				proxy_send_timeout 12s;
    				proxy_set_header Upgrade $http_upgrade;
    				proxy_set_header Connection "upgrade";
    			}
    		  }
    
    展开全文
  • 下面是springBoot整合websocket,实现服务端推送消息到客户端的一个小demo,这里使用的是定时任务的方式来模拟这种推送,实际使用中,可以根据情况主动推送。 1.创建maven工程,添加如下依赖(使用的是springBoot ...

           Http只能由客户端发起请求,服务端返回请求,这就导致如果服务端有新的消息需要发送给客户端就比较麻烦,所以websocket就应运而生了。下面是springBoot整合websocket,实现服务端推送消息到客户端的一个小demo,这里使用的是定时任务的方式来模拟这种推送,实际使用中,可以根据情况主动推送。

    1.创建maven工程,添加如下依赖(使用的是springBoot  2.2.2.RELEASE):

    <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-websocket</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.44</version>
            </dependency>
            <!-- Hutool超级工具类 http://hutool.mydoc.io/ -->
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>4.3.2</version>
            </dependency>
        </dependencies>

    2.websocket服务端:

    @ServerEndpoint("/ws/{userId}")
    @Component
    public class WebSocketServer {
        /**concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。*/
        private static ConcurrentHashMap<String,WebSocketServer> webSocketMap = new ConcurrentHashMap<String,WebSocketServer>();
        /**与某个客户端的连接会话,需要通过它来给客户端发送数据*/
        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);
            }else{
                webSocketMap.put(userId,this);
            }
    
            System.out.println("当前连接用户:"+userId);
    
        }
    
        /**
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose() {
            if(webSocketMap.containsKey(userId)){
                webSocketMap.remove(userId);
            }
            System.out.println("用户 "+userId+" 退出:");
        }
    
        /**
         * 收到客户端消息后调用的方法
         *
         * @param message 客户端发送过来的消息*/
        @OnMessage
        public void onMessage(String message, Session session) {
            System.out.println("收到用户消息:"+userId+",报文:"+message);
            if(StrUtil.isNotBlank(message)){
                try {
                    //解析发送的报文
                    JSONObject jsonObject = JSON.parseObject(message);
                    //追加发送人(防止串改)
                    jsonObject.put("fromUserId",this.userId);
                    String toUserId=jsonObject.getString("toUserId");
                    //传送给对应toUserId用户的websocket
                    if(StrUtil.isNotBlank(toUserId) && webSocketMap.containsKey(toUserId)){
                        webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
                    }else{
                        webSocketMap.get(this.userId).sendMessage("请求的userId:"+toUserId+"不在该服务器上");
                        System.out.println("请求的userId:"+toUserId+"不在该服务器上");
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    
        /**
         *
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            System.out.println("用户错误:"+this.userId+",原因:"+error.getMessage());
            error.printStackTrace();
        }
        /**
         * 实现服务器主动推送
         */
        public void sendMessage(String message) throws IOException {
            this.session.getBasicRemote().sendText(message);
        }
    
    
        /**
         * 发送自定义消息
         * */
        public static void sendInfo(String message,String userId) throws IOException {
            System.out.println("发送消息到:"+userId+",报文:"+message);
            if(StrUtil.isNotBlank(userId) && webSocketMap.containsKey(userId)){
                webSocketMap.get(userId).sendMessage(message);
            }else{
                System.out.println("用户"+userId+",不在线!");
            }
        }
    
        public static ConcurrentHashMap<String, WebSocketServer> getWebSocketMap() {
            return webSocketMap;
        }
    
        public static void setWebSocketMap(ConcurrentHashMap<String, WebSocketServer> webSocketMap) {
            WebSocketServer.webSocketMap = webSocketMap;
        }
    }

    3.websocket客户端,在resources目录下,创建static目录,在创建一个文件test.html,其内容如下:

    <!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{
                if (!$("#fromUserId").val()){
                    alert("请输入用户名");
                    return;
                }
                console.log("您的浏览器支持WebSocket");
                //实现化WebSocket对象,指定要连接的服务器地址与端口  建立连接
                //等同于socket = new WebSocket("ws://localhost:8888/xxxx/im/25");
                //var socketUrl="${request.contextPath}/im/"+$("#userId").val();
                var socketUrl="http://localhost:8080/ws/"+$("#fromUserId").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已打开");
                    $("#allContent")
                        .append("<div>" + "收到消息:已建立连接,"+new Date() + "</div>");
                };
                //获得消息事件
                socket.onmessage = function(msg) {
                    $("#allContent")
                        .append("<div>" + "收到消息" +":"+msg.data + "</div>");
                    console.log(msg.data);
                };
                //关闭事件
                socket.onclose = function() {
                    $("#allContent")
                        .append("<div>" + "收到消息:websocket已关闭,"+new Date() + "</div>");
                    console.log("websocket已关闭");
                };
                //发生了错误事件
                socket.onerror = function() {
                    $("#allContent")
                        .append("<div>" + "收到消息:websocket连接发生了错误,"+new Date() + "</div>");
                    console.log("websocket发生了错误");
                }
            }
        }
        // 关闭连接
        function closeSocket() {
            if (socket){
                socket.disconnect();
            }
        }
        // 发送消息
        function sendMessage() {
            if(typeof(WebSocket) == "undefined") {
                console.log("您的浏览器不支持WebSocket");
            }else {
                // 判断是否已建立连接
                if (socket){
                    socket.send('{"toUserId":"'+$("#toUserId").val()+'","contentText":"'+$("#contentText").val()+'"}');
                }else {
                    alert("请先建立连接");
                }
    
            }
        }
    </script>
    <body>
    【请输入用户名】:<input id="fromUserId" name="fromUserId" type="text" value="admin"/>
    【目标用户名】:<input id="toUserId" name="toUserId" type="text" value="qxf"/>
    <button onclick="openSocket()"  style="color:red;">开启连接</button>
    <button onclick="closeSocket()"  style="color:red;">关闭连接</button>
    <button onclick="sendMessage()" style="color:blue;">发送消息</button>
     【内容】:<input id="contentText" name="contentText" type="text" value="hello websocket">
     <div id="allContent">
    
     </div>
    </body>
    
    </html>
    

    主要就是那几个监听事件,比如

    onmessage,表示收到消息时的回调
    

    4.定时任务模式主动推送:

    @Component
    public class SendMsgToClient {
    
        //从第10秒开始,每隔5秒发送一次
        @Scheduled(cron="10/5 * * * * ?")
        public void sendMsg() {
            try {
                ConcurrentHashMap<String, WebSocketServer> webSocketMap = WebSocketServer.getWebSocketMap();
                ConcurrentHashMap.KeySetView<String, WebSocketServer> userIds = webSocketMap.keySet();
                if (userIds.size() <= 0){
                    System.out.println("当前没有用户连接,不发送消息");
                    return;
                }
    
                String toUserId = null;
                int count = new Random(System.currentTimeMillis()).nextInt(userIds.size());
                //取一个发送消息
                for (int i = 0; i < userIds.size();i++){
                    Iterator<String> iterator = userIds.iterator();
                    if (iterator.hasNext()){
                        if (i == count){
                            toUserId = iterator.next();
                        }else {
                            iterator.next();
                        }
    
                    }
                }
                if (StrUtil.isNotBlank(toUserId)){
                    WebSocketServer.sendInfo("这是服务端主动推送的消息:"+new Date(),toUserId);
                }else {
                    System.out.println("当前没有用户连接,不发送消息");
                }
    
            }catch (IOException e){
                System.out.println("定时推送消息失败...");
            }
    
        }
    
    }

    5.启动类添加如下配置:

        @Bean
        public ServerEndpointExporter serverEndpointExporter(){
            return new ServerEndpointExporter();
        }

     

    展开全文
  • 它能够异步无刷新从服务器端加载最新的数据展示,但它无法满足传统桌面系统的服务器端需要向客户端主动发送消息的需求,并且加载的时间间隔是个老大难的问题,于是现在我们需要理解另一种服务器推送技术。...

    一、服务端推送技术

    网页邮箱新邮件提醒、网页聊天、微信签到墙这些应用场景应该都有遇到过,那么这种功能又是怎么实现的呢?最开始可能会想到Ajax,它能够异步无刷新从服务器端加载最新的数据展示,但它无法满足传统桌面系统的服务器端需要向客户端主动发送消息的需求,并且加载的时间间隔是个老大难的问题,于是现在我们需要理解另一种服务器推送技术。

    在Web的访问机制中,大多都是push数据的,它只允许Browser端主动发起请求向Server端请求数据。客户端得到通知的方式:定时刷新、Ajax轮询、comet长连接等。

    还有一种则是Dwr,那么什么是Dwr?Dwr是基于Ajax的框架,可以动态地把Java类生成为JavaScript,让客户端JavaScript通过Dwr访问Java程序。

    其运行原理:首先在服务器有个dwr.xml,在启动的时候会读取dwr.xml同时通过里面的配置生成JS(把Java类生成相应的JS),客户端通过JS来触发JS中的方法,触发后通过这个方法来调用服务器的某个类的方法也就是说web容器接收请求创建实例处理,调用方法获得数据后返回。

    在Dwr中有个很重要的概念:scriptSession,scriptSession在每次访问都会创建,具体内容在下面展示。

    二、项目

    1、配置Web.xml启用Dwr


    2、配置dwr.xml来配置JS和Java类的关系


    3、编写JSP页面


    4、编写Java代码


    展开全文
  • 因为要即时,所以,不能考客户端拉取数据,就需要使用服务器主动给客户端推送数据的。就需要客户端和服务器实时保持着联系,也就是长连接。这种情况下,我们应该使用哪种技术来实现呢?实现方式有很多种,这里我们就...

    websocket的介绍

    在讲解WebSocket前,我们先来看看下面这种场景,在HTTP协议下,怎么实现。

    需求:

    在网站中,要实现简单的聊天,这种情况怎么实现呢?如下图:

     

     

    当发送私信的时候,如果要求实时同步的话,可以先让消息入库,等对方登陆之后,查询显示即可。如下图:

     

     

    可是现在,需要实时消息,怎么办?

    最简单的一种方式,就是写个定时任务,轮询查询去。如下图:

     

     

    虽然这样可以实现,我们可以看到,每隔一定时间,就会去调用服务器接口,查询一次。这样很浪费系统资源的。我们来看看HTTP协议:

     

     

    如上图:

    客户端和服务器建立连接后,发送请求数据给服务器;

    服务器接收请求后,处理完成并更加请求返回响应的呼作为回应;

    客户端得到数据后,与服务器断开连接。

    这就是HTTP三次握手。是基于TCP/IP的

    从上图中,我们可以看到,http协议是典型的拉取方式,短链接的;是客户端向服务器拉取数据的。如果,客户端不发送请求,那么服务器的数据就不会主动给客户的的。

    我们的需求是要实现即时聊天的。因为要即时,所以,不能考客户端拉取数据,就需要使用服务器主动给客户端推送数据的。就需要客户端和服务器实时保持着联系,也就是长连接。这种情况下,我们应该使用哪种技术来实现呢?实现方式有很多种,这里我们就用websocket来实现。

    本文来源:凯哥Java(kaigejava)

    我们来看看WebSocket介绍:

    WebSocket 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助

    HTTP请求完成。 WebSocket是真正实现了全双工通信的服务器向客户端推的互联网技术。 它是一种在单个TCP连

    接上进行全双工通讯协议。Websocket通信协议与2011年倍IETF定为标准RFC 6455,Websocket API被W3C定为标准。

    什么是全双工?什么是单工?

    全双工(Full Duplex)是通讯传输的一个术语。通信允许数据在两个方向上同时传输,它在能力上相当

    于两个单工通信方式的结合。全双工指可以同时(瞬时)进行信号的双向传输(A→B且B→A)。指

    A→B的同时B→A,是瞬时同步的。

    单工、半双工(Half Duplex),所谓半双工就是指一个时间段内只有一个动作发生,举个简单例子,

    一条窄窄的马路,同时只能有一辆车通过,当目前有两辆车对开,这种情况下就只能一辆先过,等到头

    儿后另一辆再开,这个例子就形象的说明了半双工的原理。早期的对讲机、以及早期集线器等设备都是基于半双工的产品。随着技术的不断进步,半双工会逐渐退出。

    http与websocket的区别:

    http:

    通过上面讲解,我们知道http协议是短链接,因为请求之后,都会关闭连接,下次重新请求数据,需要再次打开链接。原理简图图下:

     

     

    websocket:

    webSocket协议是一种长连接,只需要通过一次请求来初始化链接,然后所有的请求和响应都是通过这个TCP链接

    进行通讯。简单原理图如下:

     

     

    各大浏览器对websocket支持情况:

     

     

    服务器要求:

    服务器支持情况:Tomcat 7.0.47+以上才支持。

    欢迎关注凯哥:图片查看-->www.kaigejava.com

    展开全文
  • //推送给前端的消息 session.getBasicRemote().sendText(result); } catch (Exception e) { session.getBasicRemote().sendText("{\"text\":\"暂时有点忙,请您稍后。\"}"); } } @OnOpen public ...
  • 代码规范清晰。非常适合学习。 wcf实现服务端主动向客户端推送消息
  • 3.evnetsource 实现简单的服务端向浏览器推送消息,不支持跨域https://www.cnblogs.com/accordion/p/7764460.html 4.webscoke 最好选择,实时性好,对服务器版本有要求 5.iframe 永久帧 ,会使页面一直处理loading...
  • wcf服务端主动向客户端推送消息、包含源码和可执行文件。
  • SocketIO(服务端有消息立刻推送):小弟,有人给你发了条消息,你收一下 Ajax(定时查询服务端是否有消息):老头,有消息吗?有消息的话你给我 参考文章: Flask-SocketIO笔记 官方示例文档(超干货)
  •  双向通道意味着在连接时,服务端随时可以发送消息给客户端,反之亦然,这在一些需要即时通讯的场景比如多人聊天室非常重要。  flask_socketio实现了对websocket的封装,它可以让运行flask应用的服务端客户端...
  • 首先,如果我们想在客户端获取服务端的日志,最容易想到的肯定是客户端浏览器发个get请求,后端收到后读取本地日志文件,然后返回给客户端,完成一次请求,但是因为日志是在不断更新写入的,如果用户想实时动态的...
  • 客户端连接融云的服务器需要一个token。  获取token的  官方文档: http://www.rongcloud.cn/docs/server.html#     /** * 获取融云token */ public function actionRongCloudToken() { $...
  • Springboot整合WebSocket,实现服务端主动向客户端推送数据 1.对于WebSocket、Socket、Http三者的理解 Socket(长连接,一直连接,资源耗费大): 所谓套接字(Socket),就是对网络中不同主机上的应用进程之间进行...
  • //这里一定是error作为键名(自定义错误号10086),和极光推送失败时的json格式保持一致 如 {"error": {"message": "Missing parameter", "code": 1002}} resultJson = string.Format("{{\"error\": {{\"message\...
  • 异步回调问题,使用了workerman的web-sender,其中需要引入大量文件开启三个端口,现阶段改进一下,原理利用swoole的websocket继承了Swoole\Http\Server,可以使用后者的onrequest接收其他页面后端页面的主动推送,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,172
精华内容 468
热门标签
关键字:

服务端向客户端推送