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