精华内容
下载资源
问答
  • SocketIo

    2019-07-16 14:07:31
    服务端配置SocketIo与客户端实现通信 业务需求:Android设备 与后端 实现实时信息通讯,服务器推送实时信息到Android设备 技术选型:springBoot netty-Socketio netty-Socketio netty-socketio 是基于netty的java版...

    服务端配置SocketIo与客户端实现通信

    业务需求:Android设备 与后端 实现实时信息通讯,服务器推送实时信息到Android设备
    技术选型:springBoot netty-Socketio

    netty-Socketio

    netty-socketio 是基于netty的java版的即时消息推送项目。通过netty-socketio ,我们可以轻松的实现服务端主动向客户端推送消息的场景,例如:股票价格变动、k线图、消息提醒等。它和webSocket有相同的作用,只不过netty-socketio可以支持所有的浏览器。

    首先在yml文件中配置socketIo参数

      socketIo:
      win: 0.0.0.0
      linxu: 0.0.0.0
      port: 9090
      maxFramePayloadLength: 1048576
      maxHttpContentLength: 1048576
      allowCustomRequests: true
      upgradeTimeout: 10000
      pingTimeout: 60000
      pingInterval: 25000  
    

    添加NettySocketConfig文件

    import com.corundumstudio.socketio.SocketIOServer;
    import com.corundumstudio.socketio.annotation.SpringAnnotationScanner;
    import com.firstdream.customer.util.YmlUtil;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    
    @Configuration
    public class NettySocketConfig {
    
        private String ipWin;
        private String ipLinxu;
        private int port;
        private int maxFramePayloadLength;
        private int maxHttpContentLength;
        private boolean allowCustomRequests;
        private int upgradeTimeout;
        private int pingTimeout;
        private int pingInterval;
        
        @Bean
        public SocketIOServer socketIOServer() throws Exception{
        ipWin = (String) YmlUtil.getValue("socketIo.win");
        ipLinxu = (String)YmlUtil.getValue("socketIo.linxu");
        port = (Integer) YmlUtil.getValue("socketIo.port");
        maxFramePayloadLength=(Integer) YmlUtil.getValue("socketIo.maxFramePayloadLength");
        maxHttpContentLength=(Integer) YmlUtil.getValue("socketIo.maxHttpContentLength");
        allowCustomRequests=(Boolean) YmlUtil.getValue("socketIo.allowCustomRequests");
        upgradeTimeout=(Integer) YmlUtil.getValue("socketIo.upgradeTimeout");
        pingTimeout=(Integer) YmlUtil.getValue("socketIo.pingTimeout");
        pingInterval=(Integer) YmlUtil.getValue("socketIo.pingInterval");
        com.corundumstudio.socketio.Configuration config = new com.corundumstudio.socketio.Configuration();
        String os = System.getProperty("os.name");
        if(os.toLowerCase().startsWith("win")){
        //在本地window环境测试时用localhost
        config.setHostname(ipWin);
        } else {
        //部署到你的远程服务器正式发布环境时用服务器公网ip
        config.setHostname(ipLinxu);
        }
        // 端口,任意
        config.setPort(port);
        config.setMaxFramePayloadLength(maxFramePayloadLength);
        config.setMaxHttpContentLength(maxHttpContentLength);
        config.setAllowCustomRequests(allowCustomRequests);
        config.setUpgradeTimeout(upgradeTimeout);
        config.setPingTimeout(pingTimeout);
        config.setPingInterval(pingInterval);
        //该处进行身份验证h
        config.setAuthorizationListener(handshakeData -> {
        //http://localhost:8081?username=test&password=test
        //例如果使用上面的链接进行connect,可以使用如下代码获取用户密码信息
        //String username = data.getSingleUrlParam("username");
        //String password = data.getSingleUrlParam("password");
        return true;
        });
        final SocketIOServer server = new SocketIOServer(config);
        return server;
        }
        
        @Bean
        public SpringAnnotationScanner springAnnotationScanner(SocketIOServer socketServer) {
        return new SpringAnnotationScanner(socketServer);
        }
    }
    

    配置SocketIoServerMapUtil,进行socketIo连接缓存

    import com.corundumstudio.socketio.SocketIOClient;
    
    import java.util.Collection;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    
    public class SocketIoServerMapUtil {
    
    	public static ConcurrentMap<String, SocketIOClient> webSocketMap = new ConcurrentHashMap<>();
    	
    	public static void put(String key, SocketIOClient SocketIOClient) {
    	webSocketMap.put(key, SocketIOClient);
    	}
    	
    	public static SocketIOClient get(String key) {
    	return webSocketMap.get(key);
    	}
    	
    	public static void remove(String key) {
    	webSocketMap.remove(key);
    	}
    	
    	public static Collection<SocketIOClient> getValues() {
    	return webSocketMap.values();
    	}
    	
    	public static ConcurrentMap<String, SocketIOClient> getWebSocketMap() {
    	return webSocketMap;
    	}
    
    }
    

    添加socketIoServer用来处理服务器与安卓设备进行交互

    @Component
    public class SocketIoServer {
    
        public static SocketIOServer socketIoServer;
        
        
        @Autowired
        public SocketIoServer(SocketIOServer server) {
        this.socketIoServer = server;
        }
        
        @OnConnect
        public void onConnect(SocketIOClient client) {
        		String sa = client.getRemoteAddress().toString();
        		String clientIp = sa.substring(1, sa.indexOf(":"));// 获取设备ip
        		Map<String, List<String>> params = client.getHandshakeData().getUrlParams();
        		System.out.println(clientIp + "------------clientIsOnline-------------" );
        		SocketIoServerMapUtil.put(clientIp, client);
        }
        
        @OnDisconnect
        public void onDisconnect(SocketIOClient client) {
        	String sa = client.getRemoteAddress().toString();
        	String clientIp = sa.substring(1, sa.indexOf(":"));// 获取设备ip
        	SocketIoServerMapUtil.remove(clientIp);
        	System.out.println(clientIp + "------------clientIsOffline-------------" );
        }
        
        @OnEvent(value = "login")
        public void onEvent(SocketIOClient client, AckRequest ackRequest, JSONObject data) {
        	// 客户端推送advert_info事件时,onData接受数据,这里是string类型的json数据,还可以为Byte[],object其他类型
        	String sa = client.getRemoteAddress().toString();
        	String clientIp = sa.substring(1, sa.indexOf(":"));// 获取客户端连接的ip
        	Map<String, List<String>> params = client.getHandshakeData().getUrlParams();// 获取客户端url参数
        	System.out.println(clientIp + ":client:************" + data);
        //进行一些业务逻辑处理
        }
    
      }
    

    至此,服务器与安卓设备的socket交互就完成了

    展开全文
  • socketIO

    千次阅读 2018-09-21 16:20:26
    socketIO={ #socket.io详细解答 {  "express": "^4.16.3",  "socket.io": "^2.1.1",  "mongoose": "^4.9.2" } #至少pack里面要有这些,...

    socketIO={

    #socket.io详细解答

    {

        "express": "^4.16.3",

        "socket.io": "^2.1.1",

        "mongoose": "^4.9.2"

    }

    #至少pack里面要有这些,这里用mongoose工具来新建数据库

    #以上这些都是放在单独的一个目录,比如websocker目录

    #运行时linux那边一定要按照NODE

    #并且node index.js,但这个只是暂时的

    #如果要永久执行的话,那就要安装PM2

    PM2={

      #pm2

    1.使用pm2启动node :#  pm2 start /home/wwwroot/web.js --watch

    2.dump这些进程列表:# pm2 save

    3.生成自启动脚本:# pm2 startup centos

    4.赋予权限:# chmod +x /etc/init.d/pm2-init.sh

    5,添加服务:#  chkconfig --add pm2-init.sh

     

    通过这些步骤后,重启服务器,node.js是正常自启动了。这个时候再reboot,就发现以后都不能自启动了

     

    lsof -i 查看进程

    kill -9 [PID]删除进程

     

    pm2 start /home/work/websocket/index.js --watch#永久执行

     

    npm install pm2 -g    #全局安装pm2

    pm2 start bin/www     #启动服务器

    pm2 list              #查看运行状态

    pm2 logs              #查看日志

    pm2 restart www       #重启应用

    pm2 stop www          #停止应用


     

    pm2 restart /mnt/www/adminMongo/app.js  重启程序

    pm2 stop /mnt/www/adminMongo/app.js

    }


     

    #websocker目录里有个index.js文件,这个是主文件,里面写入socket流程

    #index,js

    {

    var app = require('express')();

    var http = require('http').Server(app);

    var io = require('socket.io')(http);#这里估计就是前台引入那个方法的医生

     

    var gudduser = [];

    var mongoose = require('mongoose');#引入mongoose

    mongoose.Promise = global.Promise//node warm

    /**

     * 连接

     */

    mongoose.connect('mongodb://localhost:27017/sockets', { useMongoClient: true });#链接mongodb,sockets表示是那个数据库

    var db = mongoose.connection;

    db.on('error', console.error.bind(console, 'connection error:'))

    db.once('open', function () {

      console.log('connect db')

    })

     

    app.get('/', function (req, res) {

      res.send('<h1>Welcome Realtime Server</h1>');

    });#这里是有人直接点连接,或出现这个

     

    io.on('connection', function (socket) {#io.connect表明有人执行了这个方法var socket = io.connect('ws://sk.qingtianvip.com:8306');

      socket.on('login', function (data) { #监听用户加入

    io.emit('historyres', data);#全部发送

    socket.broadcast.to(user.skid).emit('youkemessage', doc);#只发送给单个人

      }

     

      #监听用户退出,socket自带

      socket.on('disconnect', function () {

     

      }

    }

    #socket里的 socket.id 是用户发信息的唯一标识

    #我们业务的话可以在前台传他的id保存到数据库,跟socket.id无关

    }

    #

    1:在项目主页面引入<script src="http://sk.qingtianvip.com:8306/socket.io/socket.io.js"></script>

    2:<script>

        var socket = io.connect('ws://sk.qingtianvip.com:8306');#连接socket

      </script>

    3:

    socket.emit('login', { nickname: 'admin', id: '10000', recid: 0, identity: 1 });#发送自己登陆的消息

     

    socket.on('login', function (o) {

      console.log('有人登陆'); #监听新用户登录

    });

    #这里是固定写法

     

    ##############################mongoose用法:

    var LoginusersSchema = mongoose.Schema({#这里是定义一个模型

    nickname: String,

    id: String,//唯一id

    recid: String,//接收方id,0为暂时无对接人 其他为单聊对接人

    skid: String,//会话的唯一标识符,来自底层Client。

    identity: String,//用户身份,'0':游客,'1':客服

    dqcid: String,//目前接入人

    info: Array,//用户基本信息

    }, {

      collection: "Loginusers"

    });

    var Loginuser = mongoose.model('Loginusers', LoginusersSchema)#绑定这个模型,此时还未建表

     

    #下面这一步是new 一个模型,把需要加的数据加在里面

    var newLoginusers = new Loginuser({ nickname: data.nickname, id: data.id, recid: data.recid, skid: socket.id, identity: data.identity, dqcid: 0, info: data })

      newLoginusers.save(function (err, docc) {

           #此时就是新增数据

      })

     

      #删除

      Loginuser.remove({}, function (err) {##删除所有

        if (err) return handleError(err);

      })

      #查

      Loginuser.find({ 'identity': '1' }, function (err, doc) {#查找一条数据

      if (err) {

                return console.error(err);

              }

              #如果没找到,doc为null

     

      })

      #更多条件查,$or或者,第一个是条件,第二个是field,第三个是排序

        Message.find({ "$or": [{ "user_id": data.id }, { "from_id": data.id }] }, null, { sort: { addtime: 1 } }, function (err, doccc) {

        })

        Message.find({ "$or": [{ 'user_id': data.userid, "from_id": data.fromid }, { 'user_id': data.fromid, "from_id": data.userid }] }, null, { sort: { addtime: 1 } }, function (err, doccc) {

        })

     

      #数量统计

      Loginuser.count({}, function (err, rescount) {#这里是总数量,因为第一个没传条件,没找到为null

      })

      #改

      Loginuser.update({ id: data.fromid }, { dqcid: data.userid }, { multi: true }, function (err, docs) {

      })

    #注意,在循环的时候尽量用自带的,因为有时候经常遇到异步问题

    #比如users是用find查出来的,这时候就要循环

    users.forEach(function (user, index) {#直接这样就行了

    #查询都写在这里面 这时候都可以用user.XX

    })

    #在查找数据加属性问题

    toObject

    mo.name = 'kk';#直接这样加属性,是没用的

    Users.find(id, function (err, users) {

      var data = users.map(function (user, id) {

        var mo = user.toObject();#注意:toObject()这方法只能在这个函数内使用,如果里面还有查询,则失效

        mo.name = 'kk';

        return mo;

      });

      console.log(data); #添加了name属性

    });

    }


     

    展开全文
  • socketio

    2017-06-05 15:42:11
    1.写一个程序到其他网站抓数据,拿到后放到Redis消息队列。 2.我们的web端连接到自己的socketio的服务端 3.自己的服务端从redis队列获取到数据后,直接广播给所有的web端。

    1.写一个程序到其他网站抓数据,拿到后放到Redis消息队列。

    2.我们的web端连接到自己的socketio的服务端

    3.自己的服务端从redis队列获取到数据后,直接广播给所有的web端。

    展开全文
  • SocketIO

    千次阅读 2019-02-28 16:51:57
    因此说,WebSocket是SocketIO的一个子集。 阻塞IO、非阻塞IO、多路复用IO、异步IO四种IO模型 阻塞I/O模型图: 在调用recv()/recvfrom()函数时,发生在内核中等待数据和复制数据的过程。 非阻塞IO模型 ...

    1、WebSocket是什么?

    WebScoket是一种让客户端和服务器之间能进行双向实时通信的技术。它是HTML最新标准HTML5的一个协议规范,本质上是个基于TCP的协议,它通过HTTP/HTTPS协议发送一条特殊的请求进行握手后创建了一个TCP连接,此后浏览器/客户端和服务器之间便可以通过此连接来进行双向实时通信。

    2、为什么要用WebSocket?

    1)一直以来,HTTP协议是无状态、单向通信的,即客户端请求一次,服务器回复一次。如果想让服务器消息及时下发到客户端,需要采用类似于轮询的机制,即客户端定时频繁的向服务器发出请求,这样效率很低,而且HTTP数据包头本身的字节量较大,浪费了大量带宽和服务器资源;

    2)为提高效率,出现了AJAX/Comet技术,它实现了双向通信且节省了一定带宽,但仍然需要发出请求,本质上仍然是轮询;

    3)新一代HTML标准HTML5推出了WebSocket技术,它使客户端和服务器之间能通过HTTP协议建立TCP连接,之后便可以随时随地进行双向通信,且交换的数据包头信息量很小;

    3、如何使用WebSocket?

    在支持WebSocket的浏览器中,创建Socket之后,通过onopen、onmessage、onclose、onerror四个事件的实现来处理Socket的响应;

    4、WebSocket与HTTP、TCP的关系

    WebSocket和HTTP都属于应用层协议,且都是基于TCP的,它们的send函数最终也是通过TCP系统接口来做数据传输。那么WebSocket和HTTP的关系呢?WebSocket在建立握手连接时,数据是通过HTTP协议传输的,但是在连接建立后,真正的数据传输阶段则不需要HTTP协议的参与。它们之间的关系如下图:

    5、什么情况下使用WebSocket?

    如果游戏需要同时支持手机端、Web端,那毫无疑问应该使用WebSocket,现在各个平台都提供了相应的WebSocket实现。如果游戏不需要支持Web端,且对实时性要求比较高,如多人射击、MMORPG之类,那么使用TCP/UDP结合的原生Socket会比较好。

    6、I/O ? 或者输入/输出 ?

    指的是计算机与外部世界或者一个程序与计算机的其余部分的之间的接口。它对于任何计算机系统都非常关键,因而所有 I/O 的主体实际上是内置在操作系统中的。单独的程序一般是让系统为它们完成大部分的工作。
    在 Java 编程中,直到最近一直使用 流 的方式完成 I/O。所有 I/O 都被视为单个的字节的移动,通过一个称为 Stream 的对象一次移动一个字节。流 I/O 用于与外部世界接触。它也在内部使用,用于将对象转换为字节,然后再转换回对象。
    传统流IO的好处是使用简单,将底层的机制都抽象成流,但缺点就是性能不足。而且IO的各种流是阻塞的。这意味着,当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。
    以socket.read()为例子:
    传统的BIO里面socket.read(),如果TCP RecvBuffer里没有数据,函数会一直阻塞,直到收到数据,返回读到的数据。

    7、SocketIO

    WebSocket是HTML5最新提出的规范,虽然主流浏览器都已经支持,但仍然可能有不兼容的情况,为了兼容所有浏览器,给程序员提供一致的编程体验,SocketIO将WebSocket、AJAX和其它的通信方式全部封装成了统一的通信接口,也就是说,我们在使用SocketIO时,不用担心兼容问题,底层会自动选用最佳的通信方式。因此说,WebSocket是SocketIO的一个子集。

    阻塞IO、非阻塞IO、多路复用IO、异步IO四种IO模型

    阻塞I/O模型图:在调用recv()/recvfrom()函数时,发生在内核中等待数据和复制数据的过程。

    非阻塞IO模型 :非阻塞IO通过进程反复调用IO函数(多次系统调用,并马上返回);在数据拷贝的过程中,进程是阻塞的;我们把一个SOCKET接口设置为非阻塞就是告诉内核,当所请求的I/O操作无法完成时,不要将进程睡眠,而是返回一个错误。这样我们的I/O操作函数将不断的测试数据是否已经准备好,如果没有准备好,继续测试,直到数据准备好为止。在这个不断测试的过程中,会大量的占用CPU的时间。

    IO复用模型:主要是select和epoll;对一个IO端口,两次调用,两次返回,比阻塞IO并没有什么优越性;关键是能实现同时对多个IO端口进行监听;

    信号驱动IO:两次调用,两次返回;首先我们允许套接口进行信号驱动I/O,并安装一个信号处理函数,进程继续运行并不阻塞。当数据准备好时,进程会收到一个SIGIO信号,可以在信号处理函数中调用I/O操作函数处理数据。

    异步IO模型:  数据拷贝的时候进程无需阻塞。当一个异步过程调用发出后,调用者不能立刻得到结果。实际处理这个调用的部件在完成后,通过状态、通知和回调来通知调用者的输入输出操作

     

    5个I/O模型的比较:

    同步IO和异步IO的区别就在于:数据访问的时候进程是否阻塞!

    阻塞IO和非阻塞IO的区别就在于:应用程序的调用是否立即返回!

    NIO

    为什么要使用 NIO?

    NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统,因而可以极大地提高速度。

    流与块的比较

    原来的 I/O 库(在 java.io.*中) 与 NIO 最重要的区别是数据打包和传输的方式。正如前面提到的,原来的 I/O 以流的方式处理数据,而 NIO 以块的方式处理数据。
           面向流 的 I/O 系统一次一个字节地处理数据。一个输入流产生一个字节的数据,一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器,以便每个过滤器只负责单个复杂处理机制的一部分,这样也是相对简单的。不利的一面是,面向流的 I/O 通常相当慢。
          面向块 的 I/O 系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。

    NIO的buffer机制

    NIO性能的优势就来源于缓冲的机制,不管是读或者写都需要以块的形式写入到缓冲区中。NIO实际上让我们对IO的操作更接近于操作系统的实际过程。
    所有的系统I/O都分为两个阶段:等待就绪和操作。举例来说,读函数,分为等待系统可读和真正的读;同理,写函数分为等待网卡可以写和真正的写。
    以socket为例:
    先从应用层获取数据到内核的缓冲区,然后再从内核的缓冲区复制到进程的缓冲区。所以实际上底层的机制也是不断利用缓冲区来读写数据的。即使传统IO抽象成了从流直接读取数据,但本质上也依然是利用缓冲区来读取和写入数据。
    所以,为了更好的理解nio,我们就需要知道IO的底层机制,这样对我们将来理解channel和buffer就打下了基础。这里简单提一下,我们可以把bufffer就理解为内核缓冲区,所以不论读写,自然都要经过这个区域,读的话,先从设备读取数据到内核,再读到进程缓冲区,写的话,先从进程缓冲区写到内核,再从内核写回设备。

    NIO的非阻塞机制

    NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取。而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。

     

    以socket.read()为例子:

    传统的BIO里面socket.read(),如果TCP RecvBuffer里没有数据,函数会一直阻塞,直到收到数据,返回读到的数据。

    对于NIO,如果TCP RecvBuffer有数据,就把数据从网卡读到内存,并且返回给用户;反之则直接返回0,永远不会阻塞。所以我们可以NIO实现同时监听多个IO通道,然后不断的轮询寻找可以读写的设备。

    NIO的IO模型可以理解为是IO多路复用模型和非阻塞模型,同时还有事件驱动模型。
    这里需要知道一点,就是IO多路复用是一定需要实现非阻塞的。

    NIO相对于IO流的优势:

    • 非阻塞
    • buffer机制
    • 流替代块


     

    展开全文
  • SOCKETIO-源码

    2021-03-16 15:11:16
    SOCKETIO
  • socketio_examples socketio的使用案例,包含python-socketio
  • socketIO 示例

    2018-04-11 17:42:48
    socketIO 示例。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • react(typescript),nextjs,socket.io $ git clone https://github.com/ziponia/nextjs-socketio.git $ cd nextjs-socketio $ yarn $ yarn dev 连接
  • netty-socketio

    2018-09-03 17:33:39
    netty-socketio 前端web可以使用socketio.js ,下载包里面包含
  • 前端socketio工程,是用JavaScript语言实现的WebSocket框架,简单易用,稳定可靠。上传的代码中只测试了client文件夹,即客户端js工程代码,服务端代码参考我自己在2021.04.13的博客。
  • 插座 使用会话存储的 Socketio 授权
  • React-with-SocketIO:React usando SocketIO演示
  • socketio-传输 建立在 gevent-socketio 和 gearman 之上的 SocketIO 传输作为任务队列 安装 所有需求都包含在 requirements/production.txt 文件中,可以通过以下方式安装 pip install -r 要求/production.txt 跑步 ...
  • socketio信号器 用于 WebRTC PeerConnections 的 SocketIO 信令服务器
  • 插座活球 SocketIO实况球
  • AD03SocketIO Android 聊天服务器 SocketIO 项目使用以下库: volley vitamio Android 聊天应用程序,由 socketIO NodeJs 库构建的聊天服务器,用于将客户端 android 连接到 sv: :
  • 聊天socketio-源码

    2021-02-15 08:54:15
    聊天socketio
  • socketio依赖包

    2018-03-30 09:38:48
    socketio开发jar包集合socketio开发jar包集合socketio开发jar包集合
  • socketio.js

    2019-01-21 18:11:41
    netty-socketio 消息推送 前端web可以使用的socketio.js
  • MIKUDOS SOCKETIO门 mikudos-socketio-gate。 例子 用法 npm install mikudos-socketio-app --save 导入mikudos-socketio-app模块: import { Application , Authentication , AuthenticationRequest , ...
  • socketio.jar

    2017-09-08 09:48:34
    socketio.jar的包,在使用socket开发,websocket时候,用到的包。 socketio.jar的包,在使用socket开发,websocket时候,用到的包。
  • python-socketio 是 Socket.IO 服务器的 Python 实现
  • Demo-Flask-SocketIO 花了一些时间从探索Flask-SocketIO 在此处查找博客文章: 在此过程中,我了解了可以使用Javascript,Python和Flask-SocketIO进行的一些轻松的操作。 烧瓶是一个 如果您想了解更多,可以在...
  • 聊天socketio 使用socketio和boneerjs的示例聊天应用程序 SitePoint上“的源代码。
  • Flask-SocketIO Socket.IO integration for Flask applications. Installation You can install this package as usual with pip: pip install flask-socketio Example from flask import Flask, render_...
  • nodejs+socketio

    2016-07-07 23:07:57
    使用express创建服务器,通过socketio来创建多人聊天,稍后会增加redis
  • flask_socketio
  • socketio-spring-boot-starter 组件简介 基于 开源项目实现的Socket项目整合 使用说明 1、Spring Boot 项目添加 Maven 依赖 <groupId>com.github.hiwepy</groupId> <artifactId>socketio-spring-boot-starter ${...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,094
精华内容 2,837
关键字:

socketio