Node与Mysql交互
采用node-mysql开源项目作为Node框架的MySQL扩展库包括以下方面：
1. 连接MySQL数据库操作
2. 查询MySQL数据库操作
3. 修改MySQL数据库操作
4. 插入MySQL数据库操作
5. 删除MySQL数据库操作
6. MySQL数据库连接池
连接MySQL数据库操作
console.info("------ mysql connetion() ------");
console.info();
var http = require("http"); // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules.mysql"); // 引入mysql模块
console.log("Now start HTTP server on port 6868...");
console.info();
/**
* 创建数据库连接
*/
var connection = mysql.createConnection({
host: "localhoset", // 主机地址
user: "root", // 数据库用户名
password: "root", // 数据库密码
database: "nodejs", // 数据库名称
port: 3306 // 端口号
});
/**
* 创建HTTP服务器
*/
http.createServer(function(req, res) {
res.writeHead(200, {"Content-Type": "text/html;charset=utf8"});
res.write("测试 Node.js-MySQL 数据库；连接！
");
/**
* 测试数据库连接
*/
connection.connect(function(err) {
if(err) {
res.end("Error Connected to MySQL!
");
return;
} else {
res.end('Connected to MySQL!
');
}
});
}).listen(6868); // 监听6868端口号
查询MySQL数据库操作
console.log("------ mysql query() ------");
console.info();
var http = require("http"); // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql"); //引入mysql模块
// ......省略12行代码见上代码块对应部分
/**
* 创建HTTP服务器
*/
http.createServer(function(req, res) {
connection.query("select * from userInfo;", function(error, rows, fields) {
res.writeHead(200, {"Content-Type":text/html;charset=utf8"});
res.write("测试 Node.js-MySQL 数据库查询操作
");
res.end(JSON.stringify(rows));
});
}).listen(6868); // 监听6868端口号
插入MySQL数据库操作
console.log("------ mysql insert() ------");
console.info();
var http = require("http"); // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql"); //引入mysql模块
//......此处省略连接数据库代码，可参考本章节
connection.query('insert into userinfo(id, name, pwd) values(7, "genius", "12345678");',
function(errorinsert, resinsert) {
if(errorinsert) console.log(errorinsert);
console.log("INSERT Return ==> ");
console.log(resinsert);
}
);
//......此处省略连接数据库代码，可参考本章节
删除MySQL数据库操作
console.log("------ mysql delete() ------");
console.info();
var http = require("http"); // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql"); //引入mysql模块
//......此处省略连接数据库代码，可参考本章节
connection.query('delete from userinfo where id=7;', function(errordelete, resdelete) {
if(errordelete) console.log(errordelete);
console.log("DELETE Return ==>");
console.log(resdelete);
});
//......此处省略连接数据库代码，可参考本章节
更新MySQL数据库
console.log("------ mysql update() ------");
console.info();
var http = require("http"); // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql"); //引入mysql模块
//......此处省略连接数据库代码，可参考本章节
connection.query('update userinfo set pwd="87654321" where pwd="12345678";',
function(errorupdate, resupdate) {
if(errorupdate) console.log(errorupdate);
console.log("Update Return ==>");
console.log(resupdate);
}
);
//......此处省略连接数据库代码，可参考本章节
操作MySQL数据库连接池
console.log("------ mysql pool() ------");
console.info();
var http = require("http"); // 引入HTTP模块
var mysql = require("/usr/local/lib/node_modules/mysql"); //引入mysql模块
//......省略12行代码，见建立数据连接部分
/**
* 创建HTTP服务器
*/
http.createServer(function(req, res) {
/**
* 获取数据库连接池
*/
pool.getConnection(function(err, conn) {
if(err) {
console.log("POOL ==> " + err);
console.log();
}
/**
* 定义SQL查询语句
* @type {string}
*/
var selectSQL = 'select * from userinfo';
/**
* 执行数据查询操作
*/
conn.query(selectSQL, function(err, rows) {
if(err) {
console.log(err);
console.log();
}
console.log("SELECT ==> ");
for(var i in rows) {
console.log(rows[i]);
}
conn.release(); // 释放数据库连接
res.writeHead(200, {"Content-Type": "text/html;charset=utf8"});
res.write("测试 Node.js - MySQL 数据库连接池操作！
");
res.end(JSON.stringify(rows));
});
});
}).listen(6868); // 监听6868端口号
Node异步I/O与Async流程控制库
1. Node框架异步I/O机制
2. Node框架异步I/O应用
3. Async流程控制库
Node框架异步I/O机制基础
console.inf("/n");
console.info('------ Node异步编程：基础初步！ ------');
console.inf("/n");
// 使用setTimeout()异步方法初探异步机制
setTimeout(function() {
console.log('async - print it now'); // 在回调函数内输出信息
}, 3000);
console.log("asyn - print it 3 second later!"); // 异步方法后输出信息
console.inf("/n");
console.inf("------ Node异步编程 ------");
console.inf("/n");
Node框架异常捕获机制
console.info('------ Node异步编程：异常捕获！ ------');
setTimeout(function() {
try {
var data = b/0; //错误的计算
} catch(e) {
console.log(e);
}
}, 1000);
console.info();
Async串行流程控制
console.info('------ Node异步编程：Async series Array');
console.info();
var async = require("async"); // 引用'async'包
/**
* 使用series函数方法
*/
async.series([
function(callback) {
callback(null, 'hello');
},
function(callback) {
callback(null, 'async');
},
function(callback) {
callback(null, 'series');
}
], function(err, results) {
console.log(results);
});
console.info();
console.info('------ Node异步编程：Async series ------');
console.info('------ Node异步编程：Async series Json ------');
console.info();
var async = require('async'); // 引用'async'包
/**
* 使用series函数方法
*/
async.series({
one: function(callback) {
callback(null, "hello");
},
two: function(callback) {
callback(null, "async");
},
three: function(callback) {
callback(null, "series");
},
}, function(err, results) {
console.log(results);
});
console.info();
console.info('------ Node异步编程： Async series Json ------');
说明：在应用Async流程控制库过程中，async.series()函数完全严格按照串行执行的，它完成的是同步操作的功能。
Async瀑布模式流程控制（串行）
console.info('------ Node异步编程：Async waterfall ------');
console.info();
var async = require('async'); // 引用'async'包
/**
* 使用waterfall函数方法
*/
async.waterfall([
function(callback) {
// 回调函数的第一个参数为非空值时，waterfall会停止执行剩余任务
callback(null, 1);
},
function(data, callbackl) {
console.info(data);
callback(‘test’, 2);
},
function(data, callback) {
console.info(data);
callback(null, 3);
}
], function(err, results) {
console.log(results);
});
console.info();
console.info('------ Node异步编程：Async waterfall ------');
Async并行流程控制
console.info('------ Node异步编程：Async parallel ------');
console.info();
var async = require('async'); // 引用'async'包
/**
* 使用parallel函数方法
*/
async.parallel([
function(callback) {
setTimeout(function() {
callback(null, 'one');
}, 2000);
},
function(callback) {
setTimeout(function() {
callback(null, 'two');
}, 1000);
}
],
function(err, results) {
console.log(results);
});
console.info();
console.info('------ Node异步编程：Async parallel ------');
Async限制性并行流程控制
console.info('------ Node异步编程：Async parallelLimit ------');
console.info();
var async = require('async'); // 引用'async'包
/**
* 使用parallelLimit函数方法
*/
async.parallelLimit([
function(callback) {
setTimeout(function() {
callback(null, 'one');
}, 1000);
},
function(callback) {
setTimeout(function() {
callback(null, 'two');
}, 1000);
}
],
1,
function(err, results) {
console.log(results);
));
console.info();
console.info('------ Node异步编程：Async parallelLimit ------');
Async循环流程控制
console.info('------ Node异步编程：Async whilst ------');
console.info();
var async = require('async');
var count = 0;
/**
* Define JSON Array
* @type {{name:string, age:number}[]}
*/
var list = [
{name:'Jack', age:20},
{name:'Lucy', age:18},
{name:'Jack', age:20},
{name:'Lucy', age:18},
{name:'Lucy', age:18}
];
async.whilst() {
function() {
return count < 5;
},
function(callback) {
console.log(count);
list[count].age += 1;
count++;
setTimeout(callback, 1000);
},
function(err) {
console.log(count);
console.log(list);
}
};
console.info();
console.info('------ Node异步编程：Async whilst ------');
console.info('------ Node异步编程：Async doWhilst ------');
console.info();
var async = require('async');
var count = 0;
/**
* Define JSON Array
* @type {{name:string, age:number}[]}
*/
var list = [
{name:'Jack', age:20},
{name:'Lucy', age:18},
{name:'Jack', age:20},
{name:'Lucy', age:18},
{name:'Lucy', age:18}
];
async.doWhilst{
function(callback) {
console.log(count);
list[count].age += 1;
count++;
setTimeout(callback, 1000);
},
function() {return count < 5},
function(err) {
console.log(list);
}
};
console.info();
console.info('------ Node异步编程：Async doWhilst ------');
Async队列流程控制
console.info('------ Node异步编程：Async queue ------');
console.info();
var async = require('async');
/**
* 定义一个queue，设worker数量为2
*/、
var q = async.queue(function(task, callback) {
console.log('worker is processing task:', task.name);
}, 2);
/**
* 独立加入5个任务
*/
q.push({name: 'foo'}, function(err) {
console.log('finished processing foo');
});
q.push({name: 'bar'}, function(err) {
console.log('finished processing bar');
});
q.push({name: 'cap'}, function(err) {
console.log('finished processing cap');
});
q.push({name: 'egg'}, function(err) {
console.log('finished processing egg');
});
q.push({name: 'app'}, function(err) {
console.log('finished processing app');
});
/**
* listen: 当最后一个任务交给worker时，将调用该函数
*/
q.empty = function() {
console.log('no more tasks waiting');
}
/**
* listen: 当所有任务都执行完以后，将调用该函数
*/
q.drain = function() {
console.log('all tasks have been processed');
}
注意：相对于async.parallel()函数而言，async.queue()函数在很多关键点提供了回调处理，而且pusj新任务的功能也是async.parallel()函数所做不到的，由此可见async.queue()函数的并行处理能力更为强大。
Node Web开发
围绕以下方面：
1. HTTP模块方法与应用
2. HTTPS模块方法与应用
3. Express开发框架应用
构建一个基本的HTTP服务器
console.info("------ http - create basic server ------");
console.info();
var http = require('http'); // 引入http模块
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res){
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(200, {'Content-type' : 'text/html'});
/**
* 通过res.write()方法写页面内容
*/
res.write('Node.js-HTTP
');
/**
* 通过res.end()方法发送响应状态码，并通知服务器消息完成
*/
res.end('Create Basic HTTP Server
');
}).listen(6868); // 监听6868端口号
说明：当第一次调用response.write()方法时，将会发送缓存的header信息和第一个报文给客户端。当第二次调用response.write()方法时，Node框架假设用户将发送数据流，然后分别地进行发送。意味着响应是缓存到第一次报文的数据块。如果response.write()方法的所有数据被成功刷新到内核缓冲区，则返回true。如果所有或部分数据还处在队列中，则返回false。当缓冲区再次被释放时，drain事件会被分发。
编写一个简单的HTTP客户端
console.info('------ http-create basic client ------');
console.info();
var http = require('http'); // 引入http模块
/**
* 定义服务器参数字段
* @type {{hostname: string, port: number, path: string, method: string}}
*/
var options = {
hostname: 'localhost', // 定义服务器主机地址
port: 6868, // 定义服务器主机端口号
path: '/', // 定义服务器路径
method: 'POST' // 定义服务器访问方式
};
/**
* 通过http.request()方法
* 由客户端向HTTP服务器发起请求
*/
var req = http.request(options, function(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
res.on('data', function(chunk) {
console.log('BODY:' + chunk);
});
});
/**
* 监听request对象的'error'事件
*/
req.on('error', function(e) {
console.log('problme with request: ' + e.message);
});
/**
* write data to request body
*/
req.write('data/n');
/**
* write end to request body
*/
req.end();
console.info('------ http - create basic server ------');
console.info();
var http = require('http'); // 引入http模块
// 调用http.createServer()方法创建服务器
http.createServer(function(req, res) {
// 通过res.writeHeader()方法写HTTP文件头
res.writedHeader(200, {'Content-Type' : 'text/html'}),
// 通过res.write()方法写页面内容
res.write('Node.js -- HTTP
');
// 通过res.end()方法响应状态吗，并通知服务器消息完成
res.end('Create Basic HTTP Server Response to clients request
');
}).listen(6868); // 监听6868端口号
---------------------------------------
####HTTP响应状态码
```javascript
console.info("------ http - create basic client ------");
console.info();
var http = require('http'); // 引入http模块
var querystring = require('querystring'); // 引入Query String模块
/**
* 定义响应状态码数据
*/
var status_codes = new Array();
status_codes[0] = "201";
status_codes[1] = "202";
status_codes[2] = "203";
status_codes[3] = "401";
status_codes[4] = "402";
/**
* 定义查询字段
*/
var postData = new Array();
for(var n = 0; n < 5; n++) {
postData[n] = querystring.stringify({
statuscodes: status_code[n]
});
}
/**
* 模拟HTTP客户端向HTTP服务端连续发送request请求
*/
for(var i = 0; i < 5; i++) {
/**
* 定义服务器参数字段
* @type {{hostname: string, port: number, path: string, method: string, headers: {Content-Type: string, Content-Length: *}}}
*/
var options = {
hostname: 'localhost',
port: 6868,
path: '/' + postData[i],
method: 'POST',
header: {
'Content-Type': 'application/x-www-form-urlencode',
'Content-Length': postData.length
}
};
/**
* 通过http.request()方法
* 由客户端向HTTP服务器发起请求
*/
var req = http.requets(options, function(res) {
console.log('STATUS_CODES:' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
console.info();
res.setEncoding('utf8');
res.on('data', function(chunk) {
console.log('BODY: ' + chunk);
console.info();
});
});
/**
* 监听request对象的'error'事件
*/
req.on(''error', function(e) {
console.log('problem with request: ' + e.message);
console.info();
})
/**
* write data to request body
*/
req.write("/n");
/**
* write end to request body
*/
req.end();
};
console.info("------ http STATUS_CODES");
console.info();
var http = require('http); // 引入http模块
console.log("Now start HTTP server...");
console.info();
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
var status = req.url,substr(1); // 获取url查询字段
var status_codes = status.substring(12); // 获取HTTP.STATUS_CODES
// 判断http.STATUS_CODES响应状态码集合是否有效
if(!http.STATUS_CODES[status_codes]) {
status_codes = '404';
}
// 通过res.writeHeader()方法写HTTP文件头
res.writeHeader(status_codes, {'Content-Type':'text/plain'});
// 通过res.end()方法发送响应状码，并通知服务器消息完成
res.end(http.STATUS_CODES[status_codes]);
}).listen(6868); // 监听6858端口号
设定和获取HTTP头文件
console.log("------ http - server write header ------");
console.info();
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
/**
* 通过res.writeHead()方法写HTTP文件头
*/
res.writeHead(200, {
'Content-Length' : body.length,
'Content-Type' ： ‘text/plain’
});
/**
* 通过res.write()方法写页面内容
*/
res.write("Node.js");
res.write("HTTP");
/**
* 通过res.end()方法发送响应状态码， 并通知服务器消息完成
*/
res.end();
}).listen(6868); // 监听6868端口号
console.info("------ http - client write header ------");
console.info();
var http = require('http'); // 引入http模块
/**
* 定义服务器参数字段
* @type {{hostname : string, port : number, path : string, method : string}}
*/
var options = {
hostname: 'localhost', // 定义服务器主机地址
port: 6868, // 定义服务器主机端口号
path: '/', // 定义服务器路径
method: 'POST' // 定义服务器访问方式
};
/**
* 通过http.request()方法
* 由客户端向HTTP服务器发起请求
*/
var req = http.request(options, function(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
res.on('data', funcition(chunk) {
console.log('BODY: ' + chunk);
});
});
// 监听request对象的'error'事件
req.on('error', function(e) {
console.log('problem with request: ' + e.message);
});
req.write('data/n');
re.end();
发送与处理GET请求
console.info("------ http - client get ------');
console.info();
var http = require('http'); // 引入http模块
/**
* 发送HTTP GET请求
*/
http.get("http://localhost:6868/signature=12345678&echostr=78787878×tamp=168",
/**
* GET回调函数
* @param res
*/
function(res) {
console.log('STATUS: ' + res.statusCode); // 打印输出Status_Codes响应状态码
console.info();
/**
* 监听"data"事件处理函数
*/
res.on('data', function(chunk) {
console.log('BODY:' + chunk);
console.info();
});
console.info();
}).on('error',
/**
* "error"事件回调函数
* @param e
*/
function(e) {
console.log("Got error: " + e.message); // 打印出error信息
console.info();
}
);
console.info("------- http - server get ------");
console.info();
var http = require('http'); // 引入http模块
var url = require('url'); // 引入url模块
var qs = require('querystring'); // 引入querystring模块
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(200, {'Content-Type' : 'text/plain'});
/**
* 通过url.parese()方法获取查询字段
*/
var query = url.$.parseXML(req.url).query;
console.info(query);
console.info();
/**
* 通过res.end()方法发送响应状态码，并通知服务器消息完成
*/
var qs_parse = qs.$.parseXML(query);
console.info(qs_parse);
console.info();
res.end(JSON.stringify(qs_parse));
}).listen(6868); // 监听6868端口号
进行重定向操作
console.info("------ http - create redirect server A ------");
console.info();
var http = require('http'); // 引入http模块
console.log('Now start HTTP server on port 6868...');
console.info();
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(301, {
'Loaction': 'http://localhost:8686'
});
/**
* 通过res.write()方法写页面内容
*/
res.write('Node.js --- HTTP
');
/**
* 通过res.end()方法发送响应状态吗，并通知服务器消息完成
*/
res.end('Create Redirect HTTP Server on Port 6868!
');
}).listen(6868); // 监听6868端口号
console.info("------ http - create redirect server ------");
console.info();
var http = require('http'); // 引入http模块
console.log('Now start HTTP server on 8686...');
console.info();
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
// 通过res.writeHeader()方法写HTTP文件头
res.writeHeader(200, {'Content-type': 'text/html'});
// 通过res.write()方法写页面内容
res.write('Node.js - HTTP
');
// 通过res.end()方法发送响应状态吗，并通知服务器消息完成
res.end('Create Redirect HTTP Server on Port 8686!
');
}).listen(8686); // 监听8686端口
服务器多路径处理方式
console.info("------ http - server pathname ------");
console.info();
var http = require('http'); // 引入http模块
var url = require('url'); // 引入url模块
console.log('Now start HTTP server on port 6868...');
console.info();
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
/**
* 获取url.pathname路径
* @type{path|*|req.pathname|parseTests.pathname|parseTestWithQueryString}
*/
var pathname = url.parse(req.url).pathname;
/**
* Responding to multi type of request
*/
if(pathname === '/') {
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(200, {
'Content-Type': 'text/plain'
});
/**
* 通过res.end()方法响应状态码，并通知服务器消息完成
*/
res.end('Home Page/n');
} else if(pathname === '/about') {
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(200, {
'Content-Type': 'text/plain'
});
/**
* 通过res.write()方法写页面内容
*/
res.write('Node.js - HTTP/n');
/**
* 通过res.end()方法发送响应状态码。并通知服务器消息完成
*/
res.end('About Us/n');
} else if(pathname === '/redirect') {
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(301, {
'Location': '/'
});
/**
* 通过res.end()方法发送响应状态码，并通知服务器消息完成
*/
res.end();
} else {
/**
* 通过res.writeHeader()方法写HTTP文件头
*/
res.writeHeader(404, {
'Content-Type': 'text/plain'
});
/**
* 通过res.write()方法写页面内容
*/
res.write('Node.js - HTTP/n');
/**
* 通过res.end()方法发送响应状态码，并通知服务器消息完成
*/
res.end('Page not found/n');
}
}).listen(6868); // 监听6868端口号
模拟ping命令连接服务器
console.info("------ http -client ping ------");
console.info();
var http = require('http'); // 引入http模块
console.log("Now start ping HTTP server...");
console.info();
var http = require('http'); // 引入http模块
console.log("Now start ping HTTP server...");
console.info();
/**
* 定义查询字段
*/
var options = {
host: 'localhost',
port: 6868,
path: '/'
};
/**
* 自定义函数 ping_server()
*/
function ping_server() {
/**
* 发送HTTP GET请求
*/
http.get(options. function(res) {
if(res.statusCode == 200) {
console.log("The site is up!");
}
else {
console.log('The site is down!');
}
}).on('error', function(e) {
console.log("There was an error: " + e.message);
});
}
/**进行重定向操作的方法
* 通过setInterval()方法设定时间间隔
*/
setInterval(ping_server, 1000);
console.info("------ http - server ping ---");
console.info();
var http = require('http'); // 引入http模块
console.log("Now start HTTP server...");
console.info();
/**
* 调用http.createServer()方法创建服务器
*/
http.createServer(function(req, res) {
// 通过res.writeHeader()方法写HTTP文件头
if(Math.round(Math.random())) {
res.writeHeader(200, {'Content-Type': 'text/html'});
} else {
res.writeHeader(404, {'Content-Type': 'text/html'});
}
// 通过res.end()方法发送响应状态码，并通知服务器消息完成
res.end();
}).listen(6868); // 监听6868端口号