Express 的使用

锺离珂
2023-12-01

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

其它

作者:zephyr

原文链接

本文为云栖社区原创内容,未经允许不得转载。

转载于:https://my.oschina.net/yunqi/blog/3066306

 类似资料: