使用Node.js实现一个简单的FastCGI服务器实例

本文是我最近对Node.js学习过程中产生的一个想法,提出来和大家一起探讨。

Node.js的HTTP服务器

使用Node.js可以非常容易的实现一个http服务,最简的例子如官方网站的示例:


复制代码 代码如下:

var http = require('http');
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
}).listen(1337, '127.0.0.1');

这样就快速的搭建了一个监听在1337端口所有http请求的web服务。
但是,在真正的生产环境中,我们一般很少直接使用Node.js作为面向用户的最前端web服务器,原因主要有以下几种:

1.基于Node.js单线程特性的原因,其健壮性的保证对开发人员要求比较高。
2.服务器上可能已有其他http服务已占用80端口,而非80端口的web服务对用户显然不够友好。
3.Node.js对文件IO处理并没太大优势,如作为常规网站可能需同时响应图片等文件资源。
4.分布式负载场景也是一个挑战。

所以,使用Node.js作为web服务更多可能是作为游戏服务器接口等类似场景,大多是处理不需用户直接访问且仅作数据交换的服务。

基于Nginx作为前端机的Node.js web服务

基于上述原因,如果是使用Node.js搭建的网站形的产品,常规的使用方式是在Node.js的web服务前端放置另一个成熟的http服务器,如最常使用的是Nginx。
然后使用Nginx作为反向代理访问基于Node.js的web服务。如:

复制代码 代码如下:

server{
    listen 80;
    server_name yekai.me;
    root /home/andy/wwwroot/yekai;

location / {
        proxy_pass http://127.0.0.1:1337;
    }

location ~ \.(gif|jpg|png|swf|ico|css|js)$ {
        root /home/andy/wwwroot/yekai/static;
    }
}

这样就比较好的解决了上面提出的几个问题。

使用FastCGI协议通讯

不过,上述代理的方式也有一些不是很好的地方。
一个是有可能的场景是需要控制后面的Node.js的web服务的直接http访问。不过,要解决的话也可以使用自身的服务或者依靠防火墙阻挡。
另外一个是因为代理的方式毕竟是网络应用层上的方案,也不是很方便直接获取和处理与客户端http交互的数据,比如对keep-alive、trunk甚至cookie等的处理。当然这也与代理服务器自身的能力和功能完善程度相关。
所以,我在想尝试另外一种处理方式,首先想到的就是现在在php web应用上普遍使用的FastCGI的方式。

什么是FastCGI

快速通用网关接口(Fast Common Gateway Interface/FastCGI)是一种让交互程序与Web服务器通信的协议。

FastCGI产生的背景是用来作为cgi web应用的替代方案,一个最明显的特点是一个FastCGI服务进程可以用来处理一连串的请求,web服务器会把环境变量和这个页面请求通过一个socket比如FastCGI进程与web服务器连接起来,连接可用Unix Domain Socket或是一个TCP/IP连接。关于更多的背景知识可以参考Wikipedia的词条。

Node.js的FastCGI实现

那么理论上我们只需要使用Node.js创建一个FastCGI进程,再指定Nginx的监听请求发送到这个进程就行了。由于Nginx和Node.js都是基于事件驱动的服务模型,“理论”上应该是天作地合的解决方案。下面我们就亲自实现一下。
在Node.js中net模块刚好可用来建立一个socket服务,为了方便我们就选用unix socket的方式。
在Nginx端的配置稍微修改下:


复制代码 代码如下:

...
location / {
    fastcgi_pass   unix:/tmp/node_fcgi.sock;
}
...

新建一个文件node_fcgi.js,内容如下:


复制代码 代码如下:

var net = require('net');

var server = net.createServer();
server.listen('/tmp/node_fcgi.sock');

server.on('connection', function(sock){
    console.log('connection');

sock.on('data', function(data){
        console.log(data);
    });
});

然后运行(因为权限的原因,请保证Nginx和node脚本使用同一用户或有相互权限的帐号运行,不然读写sock文件会遇到权限问题):

node node_fcgi.js

在浏览器访问,我们看到运行node脚本的终端正常的接收到了数据内容,比如这样:


复制代码 代码如下:

connection
< Buffer 01 01 00 01 00 08 00 00 00 01 00 00 00 00 00 00 01 04 00 01 01 87 01...>

这就证明我们的理论基础已经实现了第一步,接下来只需要搞清楚这个buffer的内容如何解析就行了。

FastCGI协议基础

FastCGI记录由一个定长前缀后跟可变数量的内容和填充字节组成。记录结构如下:


复制代码 代码如下:

typedef struct {
    unsigned char version;
    unsigned char type;
    unsigned char requestIdB1;
    unsigned char requestIdB0;
    unsigned char contentLengthB1;
    unsigned char contentLengthB0;
    unsigned char paddingLength;
    unsigned char reserved;
    unsigned char contentData[contentLength];
    unsigned char paddingData[paddingLength];
} FCGI_Record;

version :FastCGI协议版本,现在默认就用1就好
type :记录类型,其实可以当做是不同状态,后面具体说
requestId :请求id,返回时需对应,如果不是多路复用并发的情况,这里直接用1就好
contentLength :内容长度,这里最大长度是65535
paddingLength :填充长度,作用就是长数据填充为满8字节的整数倍,主要是用来更有效地处理保持对齐的数据,主要是性能考虑
reserved :保留字节,为了后续扩展
contentData :真正的内容数据,一会具体说
paddingData :填充数据,反正都是0,直接忽略就好。

具体的结构和说明请参考官网文档(http://www.fastcgi.com/devkit/doc/fcgi-spec.html#S3.3)。

请求部分

似乎好像很简单,就是这样解析一次拿到数据就行了。不过,这里有一个坑,那就是这里定义的是数据单元(记录)的结构,并不是整个buffer的结构,整个buffer由一个记录一个记录这样的组成。一开始可能对于我们习惯了前端开发的同学不大好理解,但是这是理解FastCGI协议的基础,后面还会看到更多例子。
所以,我们需要将一个记录一个记录单独解析出来,根据前面拿到的type来区分记录。这里是一个简单的获取所有记录的函数:

复制代码 代码如下:

function getRcds(data, cb){
    var rcds = [],
        start = 0,
        length = data.length;
    return function (){
        if(start >= length){
            cb && cb(rcds);
            rcds = null;
            return;
        }
        var end = start + 8,
            header = data.slice(start, end),
            version = header[0],
            type    = header[1],
            requestId = (header[2] << 8) + header[3],
            contentLength = (header[4] << 8) + header[5],
            paddingLength = header[6];
        start = end + contentLength + paddingLength;

var body = contentLength ? data.slice(end, contentLength) : null;
        rcds.push([type, body, requestId]);

return arguments.callee();
    }
}
//使用
sock.on('data', function(data){
    getRcds(data, function(rcds){
    })();
}

注意这里只是简单处理,如果有上传文件等复杂情况这个函数不适应,为了最简演示就先简便处理了。同时,也忽略了requestId参数,如果是多路复用的情况下不能忽略,并且处理会需要复杂得多。
接下来就可以根据type来对不同的记录进行处理了。type的定义如下:


复制代码 代码如下:

#define FCGI_BEGIN_REQUEST       1
#define FCGI_ABORT_REQUEST       2
#define FCGI_END_REQUEST         3
#define FCGI_PARAMS              4
#define FCGI_STDIN               5
#define FCGI_STDOUT              6
#define FCGI_STDERR              7
#define FCGI_DATA                8
#define FCGI_GET_VALUES          9
#define FCGI_GET_VALUES_RESULT  10
#define FCGI_UNKNOWN_TYPE       11
#define FCGI_MAXTYPE (FCGI_UNKNOWN_TYPE)

接下来就可以根据记录的type来解析拿到真正的数据,下面我只拿最常用的FCGI_PARAMS、FCGI_GET_VALUES、FCGI_GET_VALUES_RESULT来说明,好在他们的解析方式是一致的。其他type记录的解析有自己不同的规则,可以参考规范的定义实现,我这里就不细说了。
FCGI_PARAMS、FCGI_GET_VALUES、FCGI_GET_VALUES_RESULT都是“编码名-值”类型数据,标准格式为:以名字长度,后跟值的长度,后跟名字,后跟值的形式传送,其中127字节或更少的长度能在一字节中编码,而更长的长度总是在四字节中编码。长度的第一字节的高位指示长度的编码方式。高位为0意味着一个字节的编码方式,1意味着四字节的编码方式。看个综合的例子,比如长名短值的情况:

复制代码 代码如下:

typedef struct {
    unsigned char nameLengthB3;  /* nameLengthB3  >> 7 == 1 */
    unsigned char nameLengthB2;
    unsigned char nameLengthB1;
    unsigned char nameLengthB0;
    unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
    unsigned char nameData[nameLength
            ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
    unsigned char valueData[valueLength];
} FCGI_NameValuePair41;

对应的实现js方法示例:

复制代码 代码如下:

function parseParams(body){
    var j = 0,
        params = {},
        length = body.length;
    while(j < length){
        var name,
            value,
            nameLength,
            valueLength;
        if(body[j] >> 7 == 1){
            nameLength = ((body[j++] & 0x7f) << 24) + (body[j++] << 16) + (body[j++] << 8) + body[j++];
        } else {
            nameLength = body[j++];
        }

if(body[j] >> 7 == 1){
            valueLength = ((body[j++] & 0x7f) << 24) + (body[j++] << 16) + (body[j++] << 8) + body[j++];
        } else {
            valueLength = body[j++];
        }

var ret = body.asciiSlice(j, j + nameLength + valueLength);
        name = ret.substring(0, nameLength);
        value = ret.substring(nameLength);
        params[name] = value;

j += (nameLength + valueLength);
    }
    return params;
}

这样就实现了一个简单可获取各种参数和环境变量的方法。完善前面的代码,演示我们如何获取客户端ip:


复制代码 代码如下:

sock.on('data', function(data){
    getRcds(data, function(rcds){
        for(var i = 0, l = rcds.length; i < l; i++){
            var bodyData = rcds[i],
                type = bodyData[0],
                body = bodyData[1];
            if(body && (type === TYPES.FCGI_PARAMS || type === TYPES.FCGI_GET_VALUES || type === TYPES.FCGI_GET_VALUES_RESULT)){
                    var params = parseParams(body);
                    console.log(params.REMOTE_ADDR);
                }
        }
    })();
}

到现在我们已经了解了FastCGI请求部分的基础,下面接着将响应部分的实现,并最终完成一个简单的echo应答服务。

响应部分

响应部分相对比较简单,最简单的情况只需要发送两个记录就行了,那就是FCGI_STDOUT和FCGI_END_REQUEST。
具体记录实体的内容就不冗述了,直接看代码吧:

复制代码 代码如下:

var res = (function(){
    var MaxLength = Math.pow(2, 16);

function buffer0(len){
        return new Buffer((new Array(len + 1)).join('\u0000'));
    };

function writeStdout(data){
        var rcdStdoutHd = new Buffer(8),
            contendLength = data.length,
            paddingLength = 8 - contendLength % 8;

rcdStdoutHd[0] = 1;
        rcdStdoutHd[1] = TYPES.FCGI_STDOUT;
        rcdStdoutHd[2] = 0;
        rcdStdoutHd[3] = 1;
        rcdStdoutHd[4] = contendLength >> 8;
        rcdStdoutHd[5] = contendLength;
        rcdStdoutHd[6] = paddingLength;
        rcdStdoutHd[7] = 0;

return Buffer.concat([rcdStdoutHd, data, buffer0(paddingLength)]);
    };

function writeHttpHead(){
        return writeStdout(new Buffer("HTTP/1.1 200 OK\r\nContent-Type:text/html; charset=utf-8\r\nConnection: close\r\n\r\n"));
    }

function writeHttpBody(bodyStr){
        var bodyBuffer = [],
            body = new Buffer(bodyStr);
        for(var i = 0, l = body.length; i < l; i += MaxLength + 1){
            bodyBuffer.push(writeStdout(body.slice(i, i + MaxLength)));
        }
        return Buffer.concat(bodyBuffer);
    }

function writeEnd(){
        var rcdEndHd = new Buffer(8);
        rcdEndHd[0] = 1;
        rcdEndHd[1] = TYPES.FCGI_END_REQUEST;
        rcdEndHd[2] = 0;
        rcdEndHd[3] = 1;
        rcdEndHd[4] = 0;
        rcdEndHd[5] = 8;
        rcdEndHd[6] = 0;
        rcdEndHd[7] = 0;
        return Buffer.concat([rcdEndHd, buffer0(8)]);
    }

return function(data){
        return Buffer.concat([writeHttpHead(), writeHttpBody(data), writeEnd()]);
    };
})();

在最简单的情况下,这样就可以发送一个完整的响应了。把我们最终的代码修改一下:


复制代码 代码如下:

var visitors = 0;
server.on('connection', function(sock){
    visitors++;
    sock.on('data', function(data){
        ...
        var querys = querystring.parse(params.QUERY_STRING);
            var ret = res('欢迎你,' + (querys.name || '亲爱的朋友') + '!你是本站第' + visitors + '位用户哦~');
            sock.write(ret);
            ret = null;
            sock.end();
        ...
    });

打开浏览器访问:http://domain/?name=yekai,可看到类似“欢迎你,yekai!你是本站第7位用户哦~”。
至此,我们就成功的使用Node.js实现了一个最简单的FastCGI服务。如果需要作为真正的服务使用,接下来只需要对照协议规范完善我们的逻辑就行了。

对比测试

最后,我们需要考虑的问题是这个方案具体是否具有可行性?可能已经有同学看出了问题,我先把简单的压测结果放上来:


复制代码 代码如下:

//FastCGI方式:
500 clients, running 10 sec.
Speed=27678 pages/min, 63277 bytes/sec.
Requests: 3295 susceed, 1318 failed.

500 clients, running 20 sec.
Speed=22131 pages/min, 63359 bytes/sec.
Requests: 6523 susceed, 854 failed.

//proxy方式:
500 clients, running 10 sec.
Speed=28752 pages/min, 73191 bytes/sec.
Requests: 3724 susceed, 1068 failed.

500 clients, running 20 sec.
Speed=26508 pages/min, 66267 bytes/sec.
Requests: 6716 susceed, 2120 failed.

//直接访问Node.js服务方式:
500 clients, running 10 sec.
Speed=101154 pages/min, 264247 bytes/sec.
Requests: 15729 susceed, 1130 failed.

500 clients, running 20 sec.
Speed=43791 pages/min, 115962 bytes/sec.
Requests: 13898 susceed, 699 failed.

为什么proxy方式反而会优于FastCGI方式呢?那是因为在proxy方案下后端服务是直接由Node.js原生模块跑的,而FastCGI方案是我们自己使用JavaScrip实现的。不过,也可以看出两者方案效率上并没有很大的差距(当然,这里对比的只是简单的情况,如果在真正的业务场景下,差距应该会更大),并且如果Node.js原生支持FastCGI服务,那么效率上应该会更优。

后记

如果有兴趣继续玩的同学可以查看我本文实现的例子源码,这两天研究下了协议规范,其实不难。
同时,回头准备再玩玩uWSGI,不过官方说v8已经在准备直接支持了。
玩得很浅,如有错误欢迎指正交流。

时间: 2014-06-06

教你如何使用node.js制作代理服务器

下面代码实现的功能是这样的: 首先创建一个HTTP服务器,当服务器接收到客户端的请求后,向"www.taobao.com"网站请求数据,当从该网站接受到的响应数据后,将响应数据发送给客户端. 复制代码 代码如下: var http=require("http"); var url=require("url"); var server=http.createServer(function(sreq,sres){     var url_parts=

Node.js 服务器端应用开发框架 -- Hapi.js

Hapi.js 是一个用来构建基于 Node.js 的应用和服务的富框架,使得开发者把重点放在便携可重用的应用逻辑而不是构建架构.内建输入验证.缓存.认证和其他 Web 应用开发常用的功能. 示例代码: var Hapi = require('hapi'); // Create a server with a host and port var server = new Hapi.Server('localhost', 8000); // Add the route server.route({

Node.js实战 建立简单的Web服务器

前面一章,我们介绍了Node.js这个面向互联网服务的JavaScript服务器平台,同时Node.js的运行环境已经搭建起来,并通过两段HelloWorld程序验证了Node.js的基本功能.本章我们同样通过实战的演练,利用Node.js建立一个简单的Web服务器. 如果你熟悉.NET或其他类似平台的Web开发,你可能会像,建立一个Web服务器有什么,在Visual Studio中建立一个Web工程,点击运行即可.事实的确是这样,但请不要忘记,这样的代价是,比如果说,你是用.NET开发Web应

Node.js实现简单聊天服务器

使用Nodejs是如此简单的实现了一个简单的聊天服务器 实现代码如下: var net = require('net'); var chatServer = net.createServer(),clientList = []; chatServer.on("connection",function(client){ client.name = client.remoteAddress + ":" + client.remotePort; client.write(

利用node.js本地搭建HTTP服务器

我们的目的比较简单,利用node.js在本地搭建HTTP服务器,实现hello word. 系统环境: win7 64bitIP:127.0.0.1Node.js:v6.10.2Npm:3.10.10Git:2.12.2.2-64-bit 基本安装: 1.Node.js安装包及源码下载地址为:https://nodejs.org/en/download/ Git下载地址为:https://git-scm.com/download/win. 2.按照安装提示操作即可,选择安装路径.npm. 3.环

Node.js:Windows7下搭建的Node.js服务(来玩玩服务器端的javascript吧,这可不是前端js插件)

这里只是纯粹的搭建,连环境都没有,还玩什么服务器端js,一切都成了浮云,让我们先搭建一个环境,输入一个"hello world"的页面. 对的,windows7下的搭建,你只需一步一步跟着我做,就ok了,不用去了解过多的细节,那不是我们现在要关心的,我们现在首要目的是把环境搭建好,要不然就没有下一步了. Step 1. 下载node.js在windows下是要安装在Cygwin下的,去Cygwin网站下载Cygwin安装程序. Cygwin网站:http://cygwin.com/ 直

为Node.js程序配置使用Nginx服务器的简明教程

Node.js是一个基于Chrome JavaScript运行时建立的平台, 用于方便地搭建响应速度快.易于扩展的网络应用.Node.js 使用事件驱动, 非阻塞I/O 模型而得以轻量和高效,非常适合在分布式设备上运行的数据密集型的实时应用,如实时聊天等等.然而对于gzip编码,静态文件,HTTP缓存,SSL处理,负载平衡和反向代理等,都可以通过nginx来完成,从而减小node.js的负载,并通过nginx强大的缓存来节省网站的流量从而提高网站的加载速度. 流程图 nginx配置如下: htt

[将免费进行到底]在Amazon的一年免费服务器上安装Node.JS, NPM和OurJS博客

这里选用的操作系统是社区版Debian,Debian和Ubuntu的操作指令是一脉相承的,再加上之前玩过一段时间的Raspberry PI,个人比较熟悉,以下的安装过程其实同样适用于树霉派(安装node.js和NPM那一部分). 1) 注册并选型 在aws上注册并绑定信号卡后即可使用亚马逊的一年免费EC2主机,不过配置通常比较低,通常为0.612Mb(linux)和1G(Win)内存. http://aws.amazon.com/ 这里选用的是社区版Debian的版本是 Debian-squee

服务器端的JavaScript脚本 Node.js 使用入门

首先下载node.js,然后解压到E盘,改名为node,然后开始菜单输入cmd,用cd命令切换到nodejs的解压目录: 第一个例子:hello world. 在node目录下建立hello.js文件,然后在里面输入: 复制代码 代码如下: var sys = require("sys"); sys.puts("Hello world"); 然后我们在命名台中输入命令node hello.js,就能看到命名台输出结果Hello world. 第二个例子:hello

node.js+Ajax实现获取HTTP服务器返回数据

我们看一个HTML5页面中通过AJAX请求的方式获取HTTP服务器返回数据的代码示例.由于我们把服务器的端口指定为1337,并将从端口为80的网站中运行HTML5页面,因此这是一种跨域操作,需要在HTTP响应头部中添加Access_Control_Allow_Origin字段,并且将参数指定为允许向服务器请求数据额域名+端口号(省略端口号时允许该域名下的任何端口向服务器请求数据), 静态页面:index.html(注:一定要放在服务器环境下,如果是win7系统的话,可以开启IIS服务,并把页面考

node.js使用http模块创建服务器和客户端完整示例

本文实例讲述了node.js使用http模块创建服务器和客户端.分享给大家供大家参考,具体如下: node.js中的 http 模块提供了创建服务器和客户端的方法,http 全称是超文本传输协议,基于 tcp 之上,属于应用层协议. 一.创建http服务器 const http = require('http'); //创建一个http服务器 let server = http.createServer(); //监听端口 server.listen(8888, '0.0.0.0'); //设置

js+ajax实现获取文件大小的方法

本文实例讲述了js+ajax实现获取文件大小的方法.分享给大家供大家参考,具体如下: 顾名思义,通过JS和Ajax来获取上传文件的大小,在上传之前可以有个判断,对上传的文件有所控制,因为js控制文件大小(JS获取文件大小)有些问题,具体大家试下就知道了,在此整理了一下ajax的获取文件大小的方法,比较好用,再调试过程中,出现了c:/fakepath/ 的错误,也将解决方案罗列在下面,以供大家参考 废话少说,代码如下 JS如下: <script language="Jscript"

node.js使用net模块创建服务器和客户端示例【基于TCP协议】

本文实例讲述了node.js使用net模块创建服务器和客户端.分享给大家供大家参考,具体如下: node.js中net模块创建服务器和客户端 1.node.js中net模块创建服务器(net.createServer) // 将net模块 引入进来 var net = require("net"); // 创建一个net.Server用来监听,当连接进来的时候,就会调用我们的函数 // client_sock,就是我们的与客户端通讯建立连接配对的socket // client_soc

详解Nodejs get获取远程服务器接口数据

本文实例为大家分享了Nodejs get获取远程服务器接口数据的具体代码,供大家参考,具体内容如下 1.GET模块:_get.js /** * Created by jinx on 7/7/17. */ var http = require('http'); module.exports = { /** * 测试获取所有的区域 * / locations: function (cb) { http.get('http://wx.xx.com/locations', function (res)

使用node.js中的Buffer类处理二进制数据的方法

前言 在Node.js中,定义了一个Buffer类,该类用来创建一个专门存放二进制数据的缓存区.这篇文章就详细介绍了node.js中的Buffer类处理二进制数据的方法,下面话不多说,来看看详细的介绍. 创建Buffer对象 第一种:直接使用一个数组来初始化缓存区 var arr = [0,1,2] var buf = new Buffer(arr) console.log(buf) 执行效果: 第二种:直接使用一个字符串来初始化缓存区 var str = 'hello' var buf = n

ajax动态获取数据库中的数据方法

今天看到有人在问答上问怎样去动态取值附在option上,本来想解决的,但我发现....没有,我本来也笨,记不住,所以还是写一下,让大家可以看一下: 首先我这用的框架是SSM,代码就开始了: 这是写在前台的方法里一个点击事件进入方法里我就不写那么麻烦了直接ajax部分代码: $.ajax({//这就开始进入ajax了 type:"get",//这个我也忘了,好像是类似格式吧,基本是死的不需要改动 dataType:"json",//这个是将字符串转换成json格式 c

Node.js下向MySQL数据库插入批量数据的方法

项目(nodejs)中需要一次性插入多笔数据到数据库,数据库是mysql的,由于循环插入的性能太差,就像使用批量插入的方法提高数据的插入性能. 批量插入的数据库的表结构如下: 1.数据库连接 var mysql = require('mysql'); // 数据库信息 var connection = mysql.createConnection({ host : 'localhost', user : '数据库用户名', password : '数据库登录密码', database : '操作

详解Node.js access_token的获取、存储及更新

一.写在前面的话 上一篇文章中,我们使用 Node.js 成功的实现了接入微信公众平台功能.在这篇文章中,我们将实现微信公众平台一个非常重要的参数 access_token ,它是公众号的全局唯一接口调用凭据,公众号调用各接口时都需使用 access_token. 在开始之前,让我们先按捺住自己激动的心情.调整好呼吸,因为我们要将上一篇文章的代码重新整理一下.一个好的项目结构,更能有助于我们理清业务逻辑以及将来维护代码的便捷.OK? 二.整理项目结构 1.打开我们的项目,并在项目中添加文件夹,命

Node.js 实现简单的接口服务器的实例代码

通过Node.js来实现接口服务器的功能.主要特点为: 1) 增加接口不需要重启 2) 异步执行,但接口阅读的时候是同步的代码(从上而下),或者可以按需求并行,串行 这里只是抛出基本思路,所以使用GET,也没有加密之类的 首先启动监听端口,配置好访问规则.(通过识别特定URL ,动态执行相应的接口脚本) ----- |----HamstrerServlet | ------ command3G | ------ login.js //登录脚本(这里只是简单演示) | --- server.js