以下内容,基于 Express 4.x 版本
Node.js 的 Express
Express 估计是那种你第一次接触,就会喜欢上用它的框架。因为它真的非常简单,直接。
在当前版本上,一共才这么几个文件:
lib/
├── application.js
├── express.js
├── middleware
│ ├── init.js
│ └── query.js
├── request.js
├── response.js
├── router
│ ├── index.js
│ ├── layer.js
│ └── route.js
├── utils.js
└── view.js
这种程度,说它是一个“框架”可能都有些过了,几乎都是工具性质的实现,只限于 Web 层。
当然,直接了当地实现了 Web 层的基本功能,是得益于 Node.js 本身的 API 中,就提供了 net 和 http 这两层, Express 对 http 的方法包装一下即可。
不过,本身功能简单的东西,在 package.json
中却有好长一串 dependencies 列表。
Hello World
在跑 Express 前,你可能需要初始化一个 npm 项目,然后再使用 npm 安装 Express:
mkdir p
cd p
npm init
npm install express --save
新建一个 app.js
:
const express = require('express');
const app = express();
app.all('/', (req, res) => res.send('hello') );
app.listen(8888);
调试信息是通过环境变量 DEBUG 控制的:
const process = require('process');
process.env['DEBUG'] = 'express:*';
这样就可以在终端看到带颜色的输出了,嗯,是的,带颜色控制字符,vim 中直接跑就 SB 了。
应用 Application
Application 是一个上层统筹的概念,整合“请求-响应”流程。 express()
的调用会返回一个 application ,一个项目中,有多个 app 是没问题的:
const express = require('express');const app = express();
app.all('/', (req, res) => res.send('hello'));
app.listen(8888);const app2 = express();
app2.all('/', (req, res) => res.send('hello2'));
app2.listen(8889);
多个 app 的另一个用法,是直接把某个 path 映射到整个 app :
const express = require('express');const app = express();app.all('/', (req, res) => {res.send('ok');
});const app2 = express();
app2.get('/xx', (req, res, next) => res.send('in app2') )
app.use('/2', app2)app.listen(8888);
这样,当访问 /2/xx
时,就会看到 in app2
的响应。
前面说了 app 实际上是一个上层调度的角色,在看后面的内容之前,先说一下 Express 的特点,整体上来说,它的结构基本上是“回调函数串行”,无论是 app ,或者 route, handle, middleware这些不同的概念,它们的形式,基本是一致的,就是 (res, req, next) => {}
,串行的流程依赖 next()
的显式调用。
我们把 app 的功能,分成五个部分来说。
路由 - Handler 映射
app.all('/', (req, res, next) => {});
app.get('/', (req, res, next) => {});
app.post('/', (req, res, next) => {});
app.put('/', (req, res, next) => {});
app.delete('/', (req, res, next) => {});
上面的代码就是基本的几个方法,路由的匹配是串行的,可以通过 next()
控制:
const express = require('express');const app = express();app.all('/', (req, res, next) => {res.send('1 ');console.log('here');next();
});app.get('/', (req, res, next) => {res.send('2 ');console.log('get');next();
});app.listen(8888);
对于上面的代码,因为重复调用 send()
会报错。
同样的功能,也可以使用 app.route()
来实现:
const express = require('express');const app = express();app.route('/').all( (req, res, next) => {console.log('all');next();
}).get( (req, res, next) => {res.send('get');next();
}).all( (req, res, next) => {console.log('tail');next();
});app.listen(8888);
app.route()
也是一种抽象通用逻辑的形式。
还有一个方法是 app.params
,它把“命名参数”的处理单独拆出来了(我个人不理解这玩意儿有什么用):
const express = require('express');const app = express();app.route('/:id').all( (req, res, next) => {console.log('all');next();
}).get( (req, res, next) => {res.send('get');next()
}).all( (req, res, next) => {console.log('tail');
});app.route('/').all( (req, res) => {res.send('ok')});app.param('id', (req, res, next, value) => {console.log('param', value);next();
});app.listen(8888);
app.params
中的对应函数会先行执行,并且,记得显式调用 next()
。
Middleware
其实前面讲了一些方法,要实现 Middleware 功能,只需要 app.all(/.*/, () => {})
就可以了, Express 还专门提供了 app.use()
做通用逻辑的定义:
const express = require('express');const app = express();app.all(/.*/, (req, res, next) => {console.log('reg');next();
});app.all('/', (req, res, next) => {console.log('pre');next();
});app.use((req, res, next) => {console.log('use');next();
});app.all('/', (req, res, next) => {console.log('all');res.send('/ here');next();
});app.use((req, res, next) => {console.log('use2');next();
});app.listen(8888);
注意 next()
的显式调用,同时,注意定义的顺序, use()
和 all()
顺序上是平等的。
Middleware 本身也是 (req, res, next) => {}
这种形式,自然也可以和 app 有对等的机制——接受路由过滤, Express 提供了 Router ,可以单独定义一组逻辑,然后这组逻辑可以跟 Middleware一样使用。
const express = require('express');
const app = express();
const router = express.Router();app.all('/', (req, res) => {res.send({a: '123'});
});router.all('/a', (req, res) => {res.send('hello');
});app.use('/route', router);app.listen(8888);
功能开关,变量容器
app.set()
和 app.get()
可以用来保存 app 级别的变量(对, app.get()
还和 GET 方法的实现名字上还冲突了):
const express = require('express');const app = express();app.all('/', (req, res) => {app.set('title', '标题123');res.send('ok');
});app.all('/t', (req, res) => {res.send(app.get('title'));
});app.listen(8888);
上面的代码,启动之后直接访问 /t
是没有内容的,先访问 /
再访问 /t
才可以看到内容。
对于变量名, Express 预置了一些,这些变量的值,可以叫 settings ,它们同时也影响整个应用的行为:
case sensitive routing
env
etag
jsonp callback name
json escape
json replacer
json spaces
query parser
strict routing
subdomain offset
trust proxy
views
view cache
view engine
x-powered-by
(上面这些值中,干嘛不放一个最基本的 debug 呢……)
除了基本的 set() / get()
,还有一组 enable() / disable() / enabled() / disabled()
的包装方法,其实就是 set(name, false)
这种。 set(name)
这种只传一个参数,也可以获取到值,等于 get(name)
。
模板引擎
Express 没有自带模板,所以模板引擎这块就被设计成一个基础的配置机制了。
const process = require('process');
const express = require('express');
const app = express();app.set('views', process.cwd() + '/template');app.engine('t2t', (path, options, callback) => {console.log(path, options);callback(false, '123');
});app.all('/', (req, res) => {res.render('demo.t2t', {title: "标题"}, (err, html) => {res.send(html)});
});app.listen(8888);
app.set('views', ...)
是配置模板在文件系统上的路径, app.engine()
是扩展名为标识,注册对应的处理函数,然后, res.render()
就可以渲染指定的模板了。 res.render('demo')
这样不写扩展名也可以,通过 app.set('view engine', 't2t')
可以配置默认的扩展名。
这里,注意一下 callback()
的形式,是 callback(err, html)
。
端口监听
app 功能的最后一部分, app.listen()
,它完成的形式是:
app.listen([port[, host[, backlog]]][, callback])
注意, host
是第二个参数。
backlog
是一个数字,配置可等待的最大连接数。这个值同时受操作系统的配置影响。默认是 512 。
请求 Request
这一块倒没有太多可以说的,一个请求你想知道的信息,都被包装到 req
的属性中的。除了,头。头的信息,需要使用 req.get(name)
来获取。
GET 参数
使用 req.query
可以获取 GET 参数:
const express = require('express');
const app = express();app.all('/', (req, res) => {console.log(req.query);res.send('ok');
});app.listen(8888);
请求:
# -*- coding: utf-8 -*-
import requests
requests.get('http://localhost:8888', params={"a": '中文'.encode('utf8')})
POST 参数
POST 参数的获取,使用 req.body
,但是,在此之前,需要专门挂一个 Middleware , req.body
才有值:
const express = require('express');
const app = express();app.use(express.urlencoded({ extended: true }));
app.all('/', (req, res) => {console.log(req.body);res.send('ok');
});app.listen(8888);
# -*- coding: utf-8 -*-import requestsrequests.post('http://localhost:8888', data={"a": '中文'})
如果你是整块扔的 json 的话:
# -*- coding: utf-8 -*-import requests
import jsonrequests.post('http://localhost:8888', data=json.dumps({"a": '中文'}),headers={'Content-Type': 'application/json'})
Express 中也有对应的 express.json()
来处理:
const express = require('express');
const app = express();app.use(express.json());
app.all('/', (req, res) => {console.log(req.body);res.send('ok');
});app.listen(8888);
Express 中处理 body
部分的逻辑,是单独放在 body-parser
这个 npm 模块中的。 Express 也没有提供方法,方便地获取原始 raw 的内容。另外,对于 POST 提交的编码数据, Express 只支持 UTF-8 编码。
如果你要处理文件上传,嗯, Express 没有现成的 Middleware ,额外的实现在 github.com/expressjs/multer 。( Node.js 天然没有“字节”类型,所以在字节级别的处理上,就会感觉很不顺啊)
Cookie
Cookie 的获取,也跟 POST 参数一样,需要外挂一个 cookie-parser
模块才行:
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser())
app.all('/', (req, res) => {console.log(req.cookies);res.send('ok');
});app.listen(8888);
请求:
# -*- coding: utf-8 -*-import requests
import jsonrequests.post('http://localhost:8888', data={'a': '中文'},headers={'Cookie': 'a=1'})
如果 Cookie 在响应时,是配置 res 做了签名的,则在 req 中可以通过 req.signedCookies
处理签名,并获取结果。
来源 IP
Express 对 X-Forwarded-For
头,做了特殊处理,你可以通过 req.ips
获取这个头的解析后的值,这个功能需要配置 trust proxy
这个 settings 来使用:
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser())
app.set('trust proxy', true);
app.all('/', (req, res) => {console.log(req.ips);console.log(req.ip);res.send('ok');
});app.listen(8888);
请求:
# -*- coding: utf-8 -*-import requests
import json#requests.get('http://localhost:8888', params={"a": '中文'.encode('utf8')})
requests.post('http://localhost:8888', data={'a': '中文'},headers={'X-Forwarded-For': 'a, b, c'})
如果 trust proxy
不是 true
,则 req.ip
会是一个 ipv4 或者 ipv6 的值。
响应 Response
Express 的响应,针对不同类型,本身就提供了几种包装了。
普通响应
使用 res.send
处理确定性的内容响应:
res.send({ some: 'json' });
res.send('<p>some html</p>');
res.status(404); res.end();
res.status(500); res.end();
res.send()
会自动 res.end()
,但是,如果只使用 res.status()
的话,记得加上 res.end()
。
模板渲染
模板需要预先配置,在 Request 那节已经介绍过了。
const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser())app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {callback(false, '<h1>Hello</h1>');
});app.all('/', (req, res) => {res.render('index', {}, (err, html) => {res.send(html);});
});app.listen(8888);
这里有一个坑点,就是必须在对应的目录下,有对应的文件存在,比如上面例子的 template/index.html
,那么 app.engine()
中的回调函数才会执行。都自定义回调函数了,这个限制没有任何意义, path, options
传入就好了,至于是不是要通过文件系统读取内容,怎么读取,又有什么关系呢。
Cookie
res.cookie
来处理 Cookie 头:
const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {callback(false, '<h1>Hello</h1>');
});
app.all('/', (req, res) => {res.render('index', {}, (err, html) => {console.log('cookie', req.signedCookies.a);res.cookie('a', '123', {signed: true});res.cookie('b', '123', {signed: true});res.clearCookie('b');res.send(html);});
});app.listen(8888);
请求:
# -*- coding: utf-8 -*-import requests
import jsonres = requests.post('http://localhost:8888', data={'a': '中文'},headers={'X-Forwarded-For': 'a, b, c','Cookie': 'a=s%3A123.p%2Fdzmx3FtOkisSJsn8vcg0mN7jdTgsruCP1SoT63z%2BI'})
print(res, res.text, res.headers)
注意三点:
app.use(cookieParser("key"))
这里必须要有一个字符串做 key ,才可以正确使用签名的 cookie 。clearCookie()
仍然是用“设置过期”的方式来达到删除目的,cookie()
和clearCookie()
并不会整合,会写两组b=xx
进头。res.send()
会在连接上完成一个响应,所以,与头相关的操作,都必须放在res.send()
前面。
头和其它
res.set()
可以设置指定的响应头, res.rediect(301, 'http://www.zouyesheng.com')
处理重定向, res.status(404); res.end()
处理非 20 响应。
const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {callback(false, '<h1>Hello</h1>');
});app.all('/', (req, res) => {res.render('index', {}, (err, html) => {res.set('X-ME', 'zys');//res.redirect('back');//res.redirect('http://www.zouyesheng.com');res.status(404);res.end();});
});app.listen(8888);
res.redirect('back')
会自动获取 referer
头作为 Location
的值,使用这个时,注意 referer
为空的情况,会造成循环重复重定向的后果。
Chunk 响应
Chunk 方式的响应,指连接建立之后,服务端的响应内容是不定长的,会加个头: Transfer-Encoding: chunked
,这种状态下,服务端可以不定时往连接中写入内容(不排除服务端的实现会有缓冲区机制,不过我看 Express 没有)。
const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {callback(false, '<h1>Hello</h1>');
});app.all('/', (req, res) => {const f = () => {const t = new Date().getTime() + '\n';res.write(t);console.log(t);setTimeout(f, 1000);}setTimeout(f, 1000);
});app.listen(8888);
上面的代码,访问之后,每过一秒,都会收到新的内容。
大概是 res
本身是 Node.js 中的 stream 类似对象,所以,它有一个 write()
方法。
要测试这个效果,比较方便的是直接 telet:
zys@zys-alibaba:/home/zys/temp >>> telnet localhost 8888
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
GET / HTTP/1.1
Host: localhostHTTP/1.1 200 OK
X-Powered-By: Express
Date: Thu, 20 Jun 2019 08:11:40 GMT
Connection: keep-alive
Transfer-Encoding: chunkede
1561018300451e
1561018301454e
1561018302456e
1561018303457e
1561018304458e
1561018305460e
1561018306460
每行前面的一个字节的 e
,为 16 进制的 14 这个数字,也就是后面紧跟着的内容的长度,是 Chunk 格式的要求。
Tornado 中的类似实现是:
# -*- coding: utf-8 -*-import tornado.ioloop
import tornado.web
import tornado.gen
import timeclass MainHandler(tornado.web.RequestHandler):@tornado.gen.coroutinedef get(self):while True:yield tornado.gen.sleep(1)s = time.time()self.write(str(s))print(s)yield self.flush()def make_app():return tornado.web.Application([(r"/", MainHandler),])if __name__ == "__main__":app = make_app()app.listen(8888)tornado.ioloop.IOLoop.current().start()
Express 中的实现,有个大坑,就是:
app.all('/', (req, res) => {const f = () => {const t = new Date().getTime() + '\n';res.write(t);console.log(t);setTimeout(f, 1000);}setTimeout(f, 1000);
});
这段逻辑,在连接已经断了的情况下,并不会停止,还是会永远执行下去。所以,你得自己处理好:
const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {callback(false, '<h1>Hello</h1>');
});app.all('/', (req, res) => {let close = false;const f = () => {const t = new Date().getTime() + '\n';res.write(t);console.log(t);if(!close){setTimeout(f, 1000);}}req.on('close', () => {close = true;});setTimeout(f, 1000);
});app.listen(8888);
req
挂了一些事件的,可以通过 close
事件来得到当前连接是否已经关闭了。
req
上直接挂连接事件,从 net
http
Express
这个层次结构上来说,也很,尴尬了。 Web 层不应该关心到网络连接这么底层的东西的。
我还是习惯这样:
app.all('/', (req, res) => {res.write('<h1>123</h1>');res.end();
});
不过 res.write()
是不能直接处理 json 对象的,还是老老实实 res.send()
吧。
我会怎么用 Express
先说一下,我自己,目前在 Express 运用方面,并没有太多的时间和复杂场景的积累。
即使这样,作为技术上相对传统的人,我会以我以往的 web 开发的套路,来使用 Express 。
我不喜欢日常用 app.all(path, callback)
这种形式去组织代码。
首先,这会使 path
定义散落在各处,方便了开发,麻烦了维护。
其次,把 path
和具体实现逻辑 callback
绑在一起,我觉得也是反思维的。至少,对于我个人来说,开发的过程,先是想如何实现一个 handler ,最后,再是考虑要把这个 handle 与哪些 path
绑定。
再次,单纯的 callback
缺乏层次感,用 app.use(path, callback)
这种来处理共用逻辑的方式,我觉得完全是扯谈。共用逻辑是代码之间本身实现上的关系,硬生生跟网络应用层 HTTP 协议的 path
概念抽上关系,何必呢。当然,对于 callback
的组织,用纯函数来串是可以的,不过我在这方面并没有太多经验,所以,我还是选择用类继承的方式来作层次化的实现。
我自己要用 Express ,大概会这样组件项目代码(不包括关系数据库的 Model 抽象如何组织这部分):
./
├── config.conf
├── config.js
├── handler
│ ├── base.js
│ └── index.js
├── middleware.js
├── server.js
└── url.js
config.conf
是 ini 格式的项目配置。config.js
处理配置,包括日志,数据库连接等。middleware.js
是针对整体流程的扩展机制,比如,给每个请求加一个 UUID ,每个请求都记录一条日志,日志内容有请求的细节及本次请求的处理时间。server.js
是主要的服务启动逻辑,整合各种资源,命令行参数 port 控制监听哪个端口。不需要考虑多进程问题,(正式部署时 nginx 反向代理到多个应用实例,多个实例及其它资源统一用 supervisor 管理)。url.js
定义路径与 handler 的映射关系。handler
,具体逻辑实现的地方,所有handler
都从BaseHandler
继承。
BaseHandler
的实现:
class BaseHandler {constructor(req, res, next){this.req = req;this.res = res;this._next = next;this._finised = false;}run(){this.prepare();if(!this._finised){if(this.req.method === 'GET'){this.get();return;}if(this.req.method === 'POST'){this.post();return;}throw Error(this.req.method + ' this method had not been implemented');}}prepare(){}get(){throw Error('this method had not been implemented');}post(){throw Error('this method had not been implemented');}render(template, values){this.res.render(template, values, (err, html) => {this.finish(html);});}write(content){if(Object.prototype.toString.call(content) === '[object Object]'){this.res.write(JSON.stringify(content));} else {this.res.write(content);}}finish(content){if(this._finised){throw Error('this handle was finished');}this.res.send(content);this._finised = true;if(this._next){ this._next() }}}module.exports = {BaseHandler};if(module === require.main){const express = require('express');const app = express();app.all('/', (req, res, next) => new BaseHandler(req, res, next).run() );app.listen(8888);
}
要用的话,比如 index.js
:
const BaseHandler = require('./base').BaseHandler;class IndexHandler extends BaseHandler {get(){this.finish({a: 'hello'});}
}module.exports = {IndexHandler};
url.js
中的样子:
const IndexHandler = require('./handler/index').IndexHandler;const Handlers = [];Handlers.push(['/', IndexHandler]);module.exports = {Handlers};
日志
后面这几部分,都不属于 Express 本身的内容了,只是我个人,随便想到的一些东西。
找一个日志模块的实现,功能上,就看这么几点:
- 标准的级别: DEBUG,INFO,WARN, ERROR 这些。
- 层级的多个 logger 。
- 可注册式的多种 Handler 实现,比如文件系统,操作系统的 rsyslog ,标准输出,等。
- 格式定义,一般都带上时间和代码位置。
Node.js 中,大概就是 log4js 了,github.com/log4js-node/log4js-node 。
const log4js = require('log4js');const layout = {type: 'pattern',pattern: '- * %p * %x{time} * %c * %f * %l * %m',tokens: {time: logEvent => {return new Date().toISOString().replace('T', ' ').split('.')[0];}}
};
log4js.configure({appenders: {file: { type: 'dateFile', layout: layout, filename: 'app.log', keepFileExt: true },stream: { type: 'stdout', layout: layout }},categories: {default: { appenders: [ 'stream' ], level: 'info', enableCallStack: false },app: { appenders: [ 'stream', 'file' ], level: 'info', enableCallStack: true }}
});const logger = log4js.getLogger('app');
logger.error('xxx');const l2 = log4js.getLogger('app.good');
l2.error('ii');
总的来说,还是很好用的,但是官网的文档不太好读,有些细节的东西没讲,好在源码还是比较简单。
说几点:
getLogger(name)
需要给一个名字,否则default
的规则都匹配不到。getLogger('parent.child')
中的名字,规则匹配上,可以通过.
作父子继承的。enableCallStack: true
加上,才能拿到文件名和行号。
ini 格式配置
json 作配置文件,功能上没问题,但是对人为修改是不友好的。所以,个人还是喜欢用 ini 格式作项目的环境配置文件。
Node.js 中,可以使用 ini 模块作解析:
const s = `
[database]
host = 127.0.0.1
port = 5432
user = dbuser
password = dbpassword
database = use_this_database[paths.default]
datadir = /var/lib/data
array[] = first value
array[] = second value
array[] = third value
`const fs = require('fs');
const ini = require('ini');const config = ini.parse(s);
console.log(config);
它扩展了 array[]
这种格式,但没有对类型作处理(除了 true
false
),比如,获取 port
,结果是 "5432"
。简单够用了。
WebSocket
Node.js 中的 WebSocket 实现,可以使用 ws 模块, github.com/websockets/ws 。
要把 ws 的 WebSocket Server 和 Express 的 app 整合,需要在 Express 的 Server 层面动手,实际上这里说的 Server 就是 Node.js 的 http 模块中的 http.createServer()
。
const express = require('express');
const ws = require('ws');const app = express();app.all('/', (req, res) => {console.log('/');res.send('hello');
});const server = app.listen(8888);const wss = new ws.Server({server, path: '/ws'});
wss.on('connection', conn => {conn.on('message', msg => {console.log(msg);conn.send(new Date().toISOString());});
});
对应的一个客户端实现,来自: github.com/ilkerkesen/tornado-websocket-client-example/blob/master/client.py
# -*- coding: utf-8 -*-import time
from tornado.ioloop import IOLoop, PeriodicCallback
from tornado import gen
from tornado.websocket import websocket_connectclass Client(object):def __init__(self, url, timeout):self.url = urlself.timeout = timeoutself.ioloop = IOLoop.instance()self.ws = Noneself.connect()PeriodicCallback(self.keep_alive, 2000).start()self.ioloop.start()@gen.coroutinedef connect(self):print("trying to connect")try:self.ws = yield websocket_connect(self.url)except Exception:print("connection error")else:print("connected")self.run()@gen.coroutinedef run(self):while True:msg = yield self.ws.read_message()print('read', msg)if msg is None:print("connection closed")self.ws = Nonebreakdef keep_alive(self):if self.ws is None:self.connect()else:self.ws.write_message(str(time.time()))if __name__ == "__main__":client = Client("ws://localhost:8888/ws", 5)
原文链接
本文为云栖社区原创内容,未经允许不得转载。