以下内容，基于 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

具体的作用，可以参考 https://expressjs.com/en/4x/api.html#app.set 。

（上面这些值中，干嘛不放一个最基本的 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 requests
requests.post('http://localhost:8888', data={"a": '中文'})

如果你是整块扔的 json 的话：

# -*- coding: utf-8 -*-
import requests
import json
requests.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 ，额外的实现在 https://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 json
requests.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 json
res = 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: localhost
HTTP/1.1 200 OK
X-Powered-By: Express
Date: Thu, 20 Jun 2019 08:11:40 GMT
Connection: keep-alive
Transfer-Encoding: chunked
e
1561018300451
e
1561018301454
e
1561018302456
e
1561018303457
e
1561018304458
e
1561018305460
e
1561018306460

每行前面的一个字节的 e ，为 16 进制的 14 这个数字，也就是后面紧跟着的内容的长度，是 Chunk 格式的要求。具体可以参考 HTTP 的 RFC ， https://tools.ietf.org/html/rfc2616#page-2 。

Tornado 中的类似实现是：

# -*- coding: utf-8 -*-
import tornado.ioloop
import tornado.web
import tornado.gen
import time
class MainHandler(tornado.web.RequestHandler):
 @tornado.gen.coroutine
 def 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 了， https://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 模块， https://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());
 });
});

对应的一个客户端实现，来自： https://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_connect
class Client(object):
 def __init__(self, url, timeout):
 self.url = url
 self.timeout = timeout
 self.ioloop = IOLoop.instance()
 self.ws = None
 self.connect()
 PeriodicCallback(self.keep_alive, 2000).start()
 self.ioloop.start()
 @gen.coroutine
 def 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.coroutine
 def run(self):
 while True:
 msg = yield self.ws.read_message()
 print('read', msg)
 if msg is None:
 print("connection closed")
 self.ws = None
 break
 def 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)

其它

• 命令行解析， yargs ，https://github.com/yargs/yargs
• UUID， uuid ， https://github.com/kelektiv/node-uuid

作者：zephyr