Node.js RESTful API

什么是 REST？
REST即表述性状态传递（英文：Representational State Transfer，简称REST）是Roy Fielding博士在2000年他的博士论文中提出来的一种软件架构风格。

表述性状态转移是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。需要注意的是，REST是设计风格而不是标准。REST通常基于使用HTTP，URI，和XML（标准通用标记语言下的一个子集）以及HTML（标准通用标记语言下的一个应用）这些现有的广泛流行的协议和标准。REST 通常使用 JSON 数据格式。

HTTP 方法
以下为 REST 基本架构的四个方法：
GET - 用于获取数据。

PUT - 用于更新或添加数据。

DELETE - 用于删除数据。

POST - 用于添加数据。

RESTful Web Services
Web service是一个平台独立的，低耦合的，自包含的、基于可编程的web的应用程序，可使用开放的XML（标准通用标记语言下的一个子集）标准来描述、发布、发现、协调和配置这些应用程序，用于开发分布式的互操作的应用程序。

基于 REST 架构的 Web Services 即是 RESTful。

由于轻量级以及通过 HTTP 直接传输数据的特性，Web 服务的 RESTful 方法已经成为最常见的替代方法。可以使用各种语言（比如 Java 程序、Perl、Ruby、Python、PHP 和 Javascript[包括 Ajax]）实现客户端。

RESTful Web 服务通常可以通过自动客户端或代表用户的应用程序访问。但是，这种服务的简便性让用户能够与之直接交互，使用它们的 Web 浏览器构建一个 GET URL 并读取返回的内容。

更多介绍，可以查看：RESTful 架构详解

创建 RESTful
首先，创建一个 json 数据资源文件 users.json，内容如下：

{
“user1” : {
“name” : “mahesh”,
“password” : “password1”,
“profession” : “teacher”,
“id”: 1
},
“user2” : {
“name” : “suresh”,
“password” : “password2”,
“profession” : “librarian”,
“id”: 2
},
“user3” : {
“name” : “ramesh”,
“password” : “password3”,
“profession” : “clerk”,
“id”: 3
}
}
基于以上数据，我们创建以下 RESTful API：

序号 URI HTTP 方法 发送内容 结果
1 listUsers GET 空 显示所有用户列表
2 addUser POST JSON 字符串 添加新用户
3 deleteUser DELETE JSON 字符串 删除用户
4 :id GET 空 显示用户详细信息
获取用户列表：
以下代码，我们创建了 RESTful API listUsers，用于读取用户的信息列表， server.js 文件代码如下所示：

var express = require(‘express’);
var app = express();
var fs = require(“fs”);

app.get(‘/listUsers’, function (req, res) {
fs.readFile( __dirname + “/” + “users.json”, ‘utf8’, function (err, data) {
console.log( data );
res.end( data );
});
})

var server = app.listen(8081, function () {

var host = server.address().address
var port = server.address().port

console.log(“应用实例，访问地址为 http://%s:%s”, host, port)

})
接下来执行以下命令：

$ node server.js
应用实例，访问地址为 http://0.0.0.0:8081
在浏览器中访问 http://127.0.0.1:8081/listUsers，结果如下所示：

{
“user1” : {
“name” : “mahesh”,
“password” : “password1”,
“profession” : “teacher”,
“id”: 1
},
“user2” : {
“name” : “suresh”,
“password” : “password2”,
“profession” : “librarian”,
“id”: 2
},
“user3” : {
“name” : “ramesh”,
“password” : “password3”,
“profession” : “clerk”,
“id”: 3
}
}
添加用户
以下代码，我们创建了 RESTful API addUser， 用于添加新的用户数据，server.js 文件代码如下所示：

var express = require(‘express’);
var app = express();
var fs = require(“fs”);

//添加的新用户数据
var user = {
“user4” : {
“name” : “mohit”,
“password” : “password4”,
“profession” : “teacher”,
“id”: 4
}
}

app.get(‘/addUser’, function (req, res) {
// 读取已存在的数据
fs.readFile( __dirname + “/” + “users.json”, ‘utf8’, function (err, data) {
data = JSON.parse( data );
data[“user4”] = user[“user4”];
console.log( data );
res.end( JSON.stringify(data));
});
})

var server = app.listen(8081, function () {

var host = server.address().address
var port = server.address().port
console.log(“应用实例，访问地址为 http://%s:%s”, host, port)

})
接下来执行以下命令：

$ node server.js
应用实例，访问地址为 http://0.0.0.0:8081
在浏览器中访问 http://127.0.0.1:8081/addUser，结果如下所示：

{ user1:
{ name: ‘mahesh’,
password: ‘password1’,
profession: ‘teacher’,
id: 1 },
user2:
{ name: ‘suresh’,
password: ‘password2’,
profession: ‘librarian’,
id: 2 },
user3:
{ name: ‘ramesh’,
password: ‘password3’,
profession: ‘clerk’,
id: 3 },
user4:
{ name: ‘mohit’,
password: ‘password4’,
profession: ‘teacher’,
id: 4 }
}
显示用户详情
以下代码，我们创建了 RESTful API :id（用户id）， 用于读取指定用户的详细信息，server.js 文件代码如下所示：

var express = require(‘express’);
var app = express();
var fs = require(“fs”);

app.get(‘/:id’, function (req, res) {
// 首先我们读取已存在的用户
fs.readFile( __dirname + “/” + “users.json”, ‘utf8’, function (err, data) {
data = JSON.parse( data );
var user = data[“user” + req.params.id]
console.log( user );
res.end( JSON.stringify(user));
});
})

var server = app.listen(8081, function () {

var host = server.address().address
var port = server.address().port
console.log(“应用实例，访问地址为 http://%s:%s”, host, port)

})
接下来执行以下命令：

$ node server.js
应用实例，访问地址为 http://0.0.0.0:8081
在浏览器中访问 http://127.0.0.1:8081/2，结果如下所示：

{
“name”:”suresh”,
“password”:”password2”,
“profession”:”librarian”,
“id”:2
}
删除用户
以下代码，我们创建了 RESTful API deleteUser， 用于删除指定用户的详细信息，以下实例中，用户 id 为 2，server.js 文件代码如下所示：

var express = require(‘express’);
var app = express();
var fs = require(“fs”);

var id = 2;

app.get(‘/deleteUser’, function (req, res) {

// First read existing users.
fs.readFile( __dirname + “/” + “users.json”, ‘utf8’, function (err, data) {
data = JSON.parse( data );
delete data[“user” + id];

   console.log( data );

   res.end( JSON.stringify(data));    }); })

var server = app.listen(8081, function () {

var host = server.address().address
var port = server.address().port
console.log(“应用实例，访问地址为 http://%s:%s”, host, port)

})
接下来执行以下命令：

$ node server.js
应用实例，访问地址为 http://0.0.0.0:8081
在浏览器中访问 http://127.0.0.1:8081/deleteUser，结果如下所示：

{ user1:
{ name: ‘mahesh’,
password: ‘password1’,
profession: ‘teacher’,
id: 1 },
user3:
{ name: ‘ramesh’,
password: ‘password3’,
profession: ‘clerk’,
id: 3 }
}

Node.js 多进程
我们都知道 Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于我们在多核 cpu 的系统上创建多个子进程，从而提高性能。

每个子进程总是带有三个流对象：child.stdin, child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。

Node 提供了 child_process 模块来创建子进程，方法有：

exec - child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。

spawn - child_process.spawn 使用指定的命令行参数创建新进程。

fork - child_process.fork 是 spawn()的特殊形式，用于在子进程中运行的模块，如 fork(‘./son.js’) 相当于 spawn(‘node’, [’./son.js’]) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

exec() 方法
child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。

语法如下所示：

child_process.exec(command[, options], callback)
参数
参数说明如下：

command： 字符串， 将要运行的命令，参数使用空格隔开

options ：对象，可以是：

cwd ，字符串，子进程的当前工作目录
env，对象 环境变量键值对
encoding ，字符串，字符编码（默认： ‘utf8’）
shell ，字符串，将要执行命令的 Shell（默认: 在 UNIX 中为/bin/sh， 在 Windows 中为cmd.exe， Shell 应当能识别 -c开关在 UNIX 中，或 /s /c 在 Windows 中。 在Windows 中，命令行解析应当能兼容cmd.exe）
timeout，数字，超时时间（默认： 0）
maxBuffer，数字， 在 stdout 或 stderr 中允许存在的最大缓冲（二进制），如果超出那么子进程将会被杀死 （默认: 200*1024）
killSignal ，字符串，结束信号（默认：’SIGTERM’）
uid，数字，设置用户进程的 ID
gid，数字，设置进程组的 ID
callback ：回调函数，包含三个参数error, stdout 和 stderr。

exec() 方法返回最大的缓冲区，并等待进程结束，一次性返回缓冲区的内容。

实例
让我们创建两个 js 文件 support.js 和 master.js。

support.js 文件代码：
console.log(“进程 “ + process.argv[2] + “ 执行。” );
master.js 文件代码：
const fs = require(‘fs’);
const child_process = require(‘child_process’);

for(var i=0; i<3; i++) {
var workerProcess = child_process.exec(‘node support.js ‘+i, function (error, stdout, stderr) {
if (error) {
console.log(error.stack);
console.log(‘Error code: ‘+error.code);
console.log(‘Signal received: ‘+error.signal);
}
console.log(‘stdout: ‘ + stdout);
console.log(‘stderr: ‘ + stderr);
});

workerProcess.on('exit', function (code) {

    console.log('子进程已退出，退出码 '+code);

}); } 执行以上代码，输出结果为：

$ node master.js
子进程已退出，退出码 0
stdout: 进程 1 执行。

stderr:
子进程已退出，退出码 0
stdout: 进程 0 执行。

stderr:
子进程已退出，退出码 0
stdout: 进程 2 执行。

stderr:
spawn() 方法
child_process.spawn 使用指定的命令行参数创建新进程，语法格式如下：

child_process.spawn(command[, args][, options])
参数
参数说明如下：

command： 将要运行的命令

args： Array 字符串参数数组

options Object

cwd String 子进程的当前工作目录
env Object 环境变量键值对
stdio Array|String 子进程的 stdio 配置
detached Boolean 这个子进程将会变成进程组的领导
uid Number 设置用户进程的 ID
gid Number 设置进程组的 ID
spawn() 方法返回流 (stdout & stderr)，在进程返回大量数据时使用。进程一旦开始执行时 spawn() 就开始接收响应。

实例
让我们创建两个 js 文件 support.js 和 master.js。

support.js 文件代码：
console.log(“进程 “ + process.argv[2] + “ 执行。” );
master.js 文件代码：
const fs = require(‘fs’);
const child_process = require(‘child_process’);

for(var i=0; i<3; i++) {
var workerProcess = child_process.spawn(‘node’, [‘support.js’, i]);

workerProcess.stdout.on(‘data’, function (data) {
console.log(‘stdout: ‘ + data);
});

workerProcess.stderr.on(‘data’, function (data) {
console.log(‘stderr: ‘ + data);
});

workerProcess.on(‘close’, function (code) {
console.log(‘子进程已退出，退出码 ‘+code);
});
}
执行以上代码，输出结果为：

$ node master.js stdout: 进程 0 执行。

子进程已退出，退出码 0
stdout: 进程 1 执行。

子进程已退出，退出码 0
stdout: 进程 2 执行。

子进程已退出，退出码 0
fork 方法
child_process.fork 是 spawn() 方法的特殊形式，用于创建进程，语法格式如下：

child_process.fork(modulePath[, args][, options])
参数
参数说明如下：

modulePath： String，将要在子进程中运行的模块

args： Array 字符串参数数组

options：Object

cwd String 子进程的当前工作目录
env Object 环境变量键值对
execPath String 创建子进程的可执行文件
execArgv Array 子进程的可执行文件的字符串参数数组（默认： process.execArgv）
silent Boolean 如果为true，子进程的stdin，stdout和stderr将会被关联至父进程，否则，它们将会从父进程中继承。（默认为：false）
uid Number 设置用户进程的 ID
gid Number 设置进程组的 ID
返回的对象除了拥有ChildProcess实例的所有方法，还有一个内建的通信信道。

实例
让我们创建两个 js 文件 support.js 和 master.js。

support.js 文件代码：
console.log(“进程 “ + process.argv[2] + “ 执行。” );
master.js 文件代码：
const fs = require(‘fs’);
const child_process = require(‘child_process’);

for(var i=0; i<3; i++) {
var worker_process = child_process.fork(“support.js”, [i]);

worker_process.on(‘close’, function (code) {
console.log(‘子进程已退出，退出码 ‘ + code);
});
}
执行以上代码，输出结果为：

$ node master.js
进程 0 执行。
子进程已退出，退出码 0
进程 1 执行。
子进程已退出，退出码 0
进程 2 执行。
子进程已退出，退出码 0

Node.js JXcore 打包
Node.js 是一个开放源代码、跨平台的、用于服务器端和网络应用的运行环境。

JXcore 是一个支持多线程的 Node.js 发行版本，基本不需要对你现有的代码做任何改动就可以直接线程安全地以多线程运行。

这篇文章主要是要向大家介绍 JXcore 的打包功能。

JXcore 安装
下载 JXcore 安装包，并解压，在解压的的目录下提供了 jx 二进制文件命令，接下来我们主要使用这个命令。

步骤1、下载
下载 JXcore 安装包 https://github.com/jxcore/jxcore-release，你需要根据你自己的系统环境来下载安装包。

1、Window 平台下载：Download(Windows x64 (V8))。

2、Linux/OSX 安装命令：

$ curl https://raw.githubusercontent.com/jxcore/jxcore/master/tools/jx_install.sh | bash
如果权限不足，可以使用以下命令：

$ curl https://raw.githubusercontent.com/jxcore/jxcore/master/tools/jx_install.sh | sudo bash
以上步骤如果操作正确，使用以下命令，会输出版本号信息：

$ jx –version
v0.10.32
包代码
例如，我们的 Node.js 项目包含以下几个文件，其中 index.js 是主文件：

drwxr-xr-x 2 root root 4096 Nov 13 12:42 images
-rwxr-xr-x 1 root root 30457 Mar 6 12:19 index.htm
-rwxr-xr-x 1 root root 30452 Mar 1 12:54 index.js
drwxr-xr-x 23 root root 4096 Jan 15 03:48 node_modules
drwxr-xr-x 2 root root 4096 Mar 21 06:10 scripts
drwxr-xr-x 2 root root 4096 Feb 15 11:56 style
接下来我们使用 jx 命令打包以上项目，并指定 index.js 为 Node.js 项目的主文件：

$ jx package index.js index
以上命令执行成功，会生成以下两个文件：

index.jxp 这是一个中间件文件，包含了需要编译的完整项目信息。

index.jx 这是一个完整包信息的二进制文件，可运行在客户端上。

载入 JX 文件
Node.js 的项目运行：

$ node index.js command_line_arguments
使用 JXcore 编译后，我们可以使用以下命令来执行生成的 jx 二进制文件：

$ jx index.jx command_line_arguments
更多 JXcore 安装参考：https://github.com/jxcore/jxcore/blob/master/doc/INSTALLATION.md。

更多 JXcore 功能特性你可以参考官网：https://github.com/jxcore/jxcore。

Node.js 连接 MySQL
本章节我们将为大家介绍如何使用 Node.js 来连接 MySQL，并对数据库进行操作。

如果你还没有 MySQL 的基本知识，可以参考我们的教程：MySQL 教程。

本教程使用到的 Websites 表 SQL 文件：websites.sql。

安装驱动
本教程使用了淘宝定制的 cnpm 命令进行安装：

$ cnpm install mysql
连接数据库
在以下实例中根据你的实际配置修改数据库用户名、及密码及数据库名：

test.js 文件代码：
var mysql = require(‘mysql’);
var connection = mysql.createConnection({
host : ‘localhost’,
user : ‘root’,
password : ‘123456’,
database : ‘test’
});

connection.connect();

connection.query(‘SELECT 1 + 1 AS solution’, function (error, results, fields) {
if (error) throw error;
console.log(‘The solution is: ‘, results[0].solution);
});
执行以下命令输出结果为：

$ node test.js
The solution is: 2
数据库连接参数说明：
参数 描述
host 主机地址 （默认：localhost）
　　user 用户名
　　password 密码
　　port 端口号 （默认：3306）
　　database 数据库名
　　charset 连接字符集（默认：’UTF8_GENERAL_CI’，注意字符集的字母都要大写）
　　localAddress 此IP用于TCP连接（可选）
　　socketPath 连接到unix域路径，当使用 host 和 port 时会被忽略
　　timezone 时区（默认：’local’）
　　connectTimeout 连接超时（默认：不限制；单位：毫秒）
　　stringifyObjects 是否序列化对象
　　typeCast 是否将列值转化为本地JavaScript类型值 （默认：true）
　　queryFormat 自定义query语句格式化方法
　　supportBigNumbers 数据库支持bigint或decimal类型列时，需要设此option为true （默认：false）
　　bigNumberStrings supportBigNumbers和bigNumberStrings启用 强制bigint或decimal列以JavaScript字符串类型返回（默认：false）
　　dateStrings 强制timestamp,datetime,data类型以字符串类型返回，而不是JavaScript Date类型（默认：false）
　　debug 开启调试（默认：false）
　　multipleStatements 是否许一个query中有多个MySQL语句 （默认：false）
　　flags 用于修改连接标志
　　ssl 使用ssl参数（与crypto.createCredenitals参数格式一至）或一个包含ssl配置文件名称的字符串，目前只捆绑Amazon RDS的配置文件
更多说明可参见：https://github.com/mysqljs/mysql

数据库操作( CURD )
在进行数据库操作前，你需要将本站提供的 Websites 表 SQL 文件websites.sql 导入到你的 MySQL 数据库中。

本教程测试的 MySQL 用户名为 root，密码为 123456，数据库为 test，你需要根据自己配置情况修改。

查询数据
将上面我们提供的 SQL 文件导入数据库后，执行以下代码即可查询出数据：

查询数据
var mysql = require(‘mysql’);

var connection = mysql.createConnection({

host : ‘localhost’,

user : ‘root’,

password : ‘123456’,

port: ‘3306’,

database: ‘test’
});

connection.connect();

var sql = ‘SELECT * FROM websites’;
//查
connection.query(sql,function (err, result) {
if(err){
console.log(‘[SELECT ERROR] - ‘,err.message);
return;
}

   console.log('--------------------------SELECT----------------------------');

   console.log(result);

   console.log('------------------------------------------------------------\n\n');   });

connection.end();
执行以下命令输出就结果为：

$ node test.js
————————–SELECT—————————-
[ RowDataPacket {
id: 1,
name: ‘Google’,
url: ‘https://www.google.cm/’,
alexa: 1,
country: ‘USA’ },
RowDataPacket {
id: 2,
name: ‘淘宝’,
url: ‘https://www.taobao.com/’,
alexa: 13,
country: ‘CN’ },
RowDataPacket {
id: 3,
name: ‘菜鸟教程’,
url: ‘http://www.runoob.com/’,
alexa: 4689,
country: ‘CN’ },
RowDataPacket {
id: 4,
name: ‘微博’,
url: ‘http://weibo.com/’,
alexa: 20,
country: ‘CN’ },
RowDataPacket {
id: 5,
name: ‘Facebook’,
url: ‘https://www.facebook.com/’,
alexa: 3,
country: ‘USA’ } ]
————————————————————
插入数据
我们可以向数据表 websties 插入数据：

插入数据
var mysql = require(‘mysql’);

var connection = mysql.createConnection({

host : ‘localhost’,

user : ‘root’,

password : ‘123456’,

port: ‘3306’,

database: ‘test’
});

connection.connect();

var addSql = ‘INSERT INTO websites(Id,name,url,alexa,country) VALUES(0,?,?,?,?)’;
var addSqlParams = [‘菜鸟工具’, ‘https://c.runoob.com’,’23453’, ‘CN’];
//增
connection.query(addSql,addSqlParams,function (err, result) {
if(err){
console.log(‘[INSERT ERROR] - ‘,err.message);
return;
}

   console.log('--------------------------INSERT----------------------------');

   //console.log('INSERT ID:',result.insertId);        

   console.log('INSERT ID:',result);        

   console.log('-----------------------------------------------------------------\n\n');   });

connection.end();
执行以下命令输出就结果为：

$ node test.js
————————–INSERT—————————-
INSERT ID: OkPacket {
fieldCount: 0,
affectedRows: 1,
insertId: 6,
serverStatus: 2,
warningCount: 0,
message: ‘’,
protocol41: true,
changedRows: 0 }
—————————————————————–
执行成功后，查看数据表，即可以看到添加的数据：

更新数据
我们也可以对数据库的数据进行修改：

更新数据
var mysql = require(‘mysql’);

var connection = mysql.createConnection({

host : ‘localhost’,

user : ‘root’,

password : ‘123456’,

port: ‘3306’,

database: ‘test’
});

connection.connect();

var modSql = ‘UPDATE websites SET name = ?,url = ? WHERE Id = ?’;
var modSqlParams = [‘菜鸟移动站’, ‘https://m.runoob.com’,6];
//改
connection.query(modSql,modSqlParams,function (err, result) {
if(err){
console.log(‘[UPDATE ERROR] - ‘,err.message);
return;
}

console.log(‘————————–UPDATE—————————-‘);
console.log(‘UPDATE affectedRows’,result.affectedRows);
console.log(‘—————————————————————–\n\n’);
});

connection.end();
执行以下命令输出就结果为：

————————–UPDATE—————————-
UPDATE affectedRows 1
—————————————————————–
执行成功后，查看数据表，即可以看到更新的数据：

删除数据
我们可以使用以下代码来删除 id 为 6 的数据:

删除数据
var mysql = require(‘mysql’);

var connection = mysql.createConnection({

host : ‘localhost’,

user : ‘root’,

password : ‘123456’,

port: ‘3306’,

database: ‘test’
});

connection.connect();

var delSql = ‘DELETE FROM websites where id=6’;
//删
connection.query(delSql,function (err, result) {
if(err){
console.log(‘[DELETE ERROR] - ‘,err.message);
return;
}

   console.log('--------------------------DELETE----------------------------');

   console.log('DELETE affectedRows',result.affectedRows);

   console.log('-----------------------------------------------------------------\n\n');   });

connection.end();