Express 是一个简洁而灵活的 node.js Web 应用框架, 提供了一系列强大特性可以快速创建各种 Web 应用和 HTTP 工具。使用 Express 可以快速地搭建一个完整功能的网站。 Express 框架核心特性：
- 可以设置中间件来响应 HTTP 请求。
- 定义了路由表用于执行不同的 HTTP 请求动作。
- 可以通过向模板传递参数来动态渲染 HTML 页面。
1.1. 安装 Express
安装 Express 并将其保存到依赖列表中:
$ npm install express --save
以下几个重要的模块是需要与 express 框架一起安装的：
- body-parser : node.js 中间件，用于处理 JSON, Raw, Text 和 URL 编码的 POST 提交数据。
- cookie-parser : 这就是一个解析 Cookie 的工具。通过 req.cookies 可以取到传过来的 cookie，并把它们转成对象。
- multer : node.js 中间件，用于处理 enctype="multipart/form-data"（设置表单的 MIME 编码）的表单数据。
$ npm install body-parser --save
$ npm install cookie-parser --save
$ npm install multer --save
1.2. HelloWorld
下面的实例中我们引入了 express 模块，并在客户端发起请求后，响应 "Hello World" 字符串。
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello World');
});
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
});
Express 应用使用回调函数的参数 request 和 response 对象来处理请求和响应的数据。
1.2.1. Request对象
request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP头部等属性。
req.app：当callback为外部文件时，用req.app访问express的实例
req.baseUrl：获取路由当前安装的URL路径
req.body / req.cookies：获得「请求主体」/ Cookies
req.fresh / req.stale：判断请求是否还「新鲜」
req.hostname / req.ip：获取主机名和IP地址
req.originalUrl：获取原始请求URL
req.params：获取路由的parameters
req.path：获取请求路径
req.protocol：获取协议类型
req.query：获取URL的查询参数串
req.route：获取当前匹配的路由
req.subdomains：获取子域名
req.accpets（）：检查请求的Accept头的请求类型
req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages
req.get（）：获取指定的HTTP请求头
req.is（）：判断请求头Content-Type的MIME类型
1.2.2. Response对象
response 对象表示 HTTP 响应，即在接收到请求时向客户端发送的 HTTP 响应数据。
res.app：同req.app一样
res.append（）：追加指定HTTP头
res.set（）在res.append（）后将重置之前设置的头
res.cookie(name，value [，option]）：设置Cookie
opition: domain / expires / httpOnly / maxAge / path / secure / signed
res.clearCookie（）：清除Cookie
res.download（）：传送指定路径的文件
res.get（）：返回指定的HTTP头
res.json（）：传送JSON响应
res.jsonp（）：传送JSONP响应
res.location（）：只设置响应的Location HTTP头，不设置状态码或者close response
res.redirect（）：设置响应的Location HTTP头，并且设置状态码302
res.send（）：传送HTTP响应
res.sendFile（path [，options] [，fn]）：传送指定路径的文件 -会自动根据文件extension设定Content-Type
res.set（）：设置HTTP头，传入object可以一次设置多个头
res.status（）：设置HTTP状态码
res.type（）：设置Content-Type的MIME类型
1.3. Route 路由
路由决定了由谁(指定脚本)去响应客户端请求。在 HTTP 请求中，我们可以通过路由提取出请求的 URL 以及 GET/POST 参数。
var express = require('express');
var app = express();
// 主页输出 "Hello World"
app.get('/', function (req, res) {
console.log("主页 GET 请求");
res.send('Hello GET');
})
// POST 请求
app.post('/', function (req, res) {
console.log("主页 POST 请求");
res.send('Hello POST');
})
// /del_user 页面响应
app.delete('/del_user', function (req, res) {
console.log("/del_user 响应 DELETE 请求");
res.send('删除页面');
})
// /list_user 页面 GET 请求
app.get('/list_user', function (req, res) {
console.log("/list_user GET 请求");
res.send('用户列表页面');
})
// 对页面 abcd, abxcd, ab123cd, 等响应 GET 请求
app.get('/ab*cd', function(req, res) {
console.log("/ab*cd GET 请求");
res.send('正则匹配');
})
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
1.4. 静态文件
Express 提供了内置的中间件 express.static 来设置静态文件如：图片，CSS, JavaScript 等。你可以使用 express.static 中间件来设置静态文件路径。例如，如果将图片，CSS, JavaScript 文件放在 public 目录下，可以这么写：
app.use(express.static('public'));
修改下 "Hello Word" 应用添加处理静态文件的功能。
var express = require('express');
var app = express();
//
app.use(express.static('public'));
app.get('/', function (req, res) {
res.send('Hello World');
})
var server = app.listen(8081);
在 public 文件夹中添加一张图片'logo.png'，就可以在浏览器中通过 http://127.0.0.1:8081/logo.png 来访问了。
1.5. GET 请求
实例演示了在表单中通过 GET 方法提交两个参数，可以使用 server.js 文件内的 process_get 路由器来处理输入：
<html>
<body>
<form action="http://127.0.0.1:8081/process_get" method="GET">
First Name: <input type="text" name="first_name"> <br>
Last Name: <input type="text" name="last_name">
<input type="submit" value="Submit">
</form>
</body>
</html>
var express = require('express');
var app = express();
app.use(express.static('public'));
app.get('/index.html', function (req, res) {
res.sendFile(__dirname + "/" + "index.html" );
})
app.get('/process_get', function (req, res) {
// 输出 JSON 格式
response = {
first_name:req.query.first_name,
last_name:req.query.last_name
};
console.log(response);
res.end(JSON.stringify(response));
})
var server = app.listen(8081)
请求参数获取使用 req.query.paramName 获取。
1.6. POST 请求
使用 body-parser 可以解析出 POST 请求传递的参数，将上例中 form 表单请求方式改为 post。
<form action="http://127.0.0.1:8081/process_post" method="POST">
var express = require('express');
var app = express();
// ------------------------------
var bodyParser = require('body-parser');
// 创建 application/x-www-form-urlencoded 编码解析
var urlencodedParser = bodyParser.urlencoded({ extended: false })
// ------------------------------
app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
res.sendFile( __dirname + "/" + "index.htm" );
})
app.post('/process_post', urlencodedParser, function (req, res) {
// 输出 JSON 格式
response = {
first_name:req.body.first_name,
last_name:req.body.last_name
};
console.log(response);
res.end(JSON.stringify(response));
})
var server = app.listen(8081);
1.7. 文件上传
使用 POST 方法，表单 enctype 属性设置为 multipart/form-data。
<form action="/file_upload" method="post" enctype="multipart/form-data">
<input type="file" name="image" size="50" /><br />
<input type="submit" value="上传文件" />
</form>
var express = require('express');
var app = express();
var fs = require("fs");
var bodyParser = require('body-parser');
var multer = require('multer');
app.use(express.static('public'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/'}).array('image'));
app.get('/index.htm', function (req, res) {
res.sendFile( __dirname + "/" + "index.htm" );
})
app.post('/file_upload', function (req, res) {
console.log(req.files[0]); // 上传的文件信息
var des_file = __dirname + "/" + req.files[0].originalname;
fs.readFile(req.files[0].path, function (err, data) {
fs.writeFile(des_file, data, function (err) {
if (err){
console.log( err );
} else {
response = {
message:'File uploaded successfully',
filename:req.files[0].originalname
};
}
console.log( response );
res.end( JSON.stringify( response ) );
});
});
})
var server = app.listen(8081);
1.8. Cookie 管理
使用 cookie-parser 我们可以处理请求传递的 cookie 信息。
var express = require('express')
var cookieParser = require('cookie-parser')
var app = express();
app.use(cookieParser());
app.get('/', function(req, res) {
console.log("Cookies: ", req.cookies)
});
app.listen(8081);
1.9. url 参数
params 只能获取 express 路由传递的参数，
// name占位符
app.get('/api/:name/', function(req, resp){
var name = req.params.name; // 获取name参数
});
除了硬编码占位符之外，还可以使用正则路由:
app.get('/file/*', function(req, resp){
var param = req.params[0];
// localhost:3000/file/javascripts/jquery.js -> javascripts/jquery.js
});
如果没在路由器设置参数， 则 req.params 获得的值为空对象{}
1.9.1. query
直接获取地址栏传递的参数
var name = req.query.name;
1.9.2. body
body 属性主要用于 post 请求时传递参数使用；
var app = require('express')();
var bodyParser = require('body-parser');
var multer = require('multer');
app.use(bodyParser.json());
// for parsing application/json
app.use(bodyParser.urlencoded({ extended: true }));
// for parsing application/x-www-form-urlencoded
app.use(multer());
// for parsing multipart/form-data
app.post('/', function (req, res) {
console.log(req.body);
res.json(req.body);
})
1.10. router
var express = require('express');
var app = express();
var router = express.Router();
app.use(router);
router.route('/add').get(function(req, res){
var userObj = {};
userObj = {
name: req.body.name,
age: req.body.age
};
console.log(userObj); // {name:'a284628487',age:'25'}
});
1.11. 文件结构
-- bin
-- www
-- node_modules
-- public
-- images
-- javascripts
-- stylesheets
-- routes
-- index.js
-- views
-- index.ejs
-- app.js
-- package.json
1.11.1. bin/www
bin 目录下的 www 文件即是创建 http 服务器的文件，该文件主要内容
var app = require('../app'); // 加载外部的app.js文件
var server = http.createServer(app); // 创建server
server.listen(port); // 启动监听
server.on('error', onError); // 指定error处理函数
server.on('listening', onListening); // 启动成功回调
1.11.2. public
存放静态资源的文件夹,通常包括 images, javascripts, stylesheets;
1.11.3. routes
路由模块,每一个 js 通常就是一个模块,比如 user.js 表示 user 模块 order.js 表示 order 模块;
1.11.4. views
页面模板引擎,可使用不同的模块,比如 ejs, jade;
1.11.5. app.js
程序初始化配置文件
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
// 上面的都是通常一个express项目需要用到的模块
var routes = require('./routes/index'); // 加载routes/index模块
var app = express(); // 创建一个express app
// 指定view引擎文件目录
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs'); // 指定view渲染引擎为ejs
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(cookieParser()); // 指定cookieParser
app.use(express.static(path.join(__dirname, 'public'))); // 指定静态文件资源目录
app.use('/', routes); // 将 routes 绑定到路径 '/' 上
app.use('/test', routes_test);
// 404错误处理函数,如果用户访问的路径没在routes和routes_test的定义当中,则会回调到该函数
app.use(function (req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err); // 调用next将请求将由下一个函数处理
});
// development error handler will print stacktrace
if (app.get('env') === 'development') {
app.use(function (err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
});
}
// production error handler no stacktraces leaked to user
app.use(function (err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
module.exports = app;
1.11.6. app.locals
locals 是 app 的一个成员变量,可以用于存放一些公共的变量或者是配置;
app.locals.version = 1.0f;
{ settings:
{ 'x-powered-by': true,
etag: 'weak',
'etag fn': [Function: wetag],
env: 'development',
'query parser': 'extended',
'query parser fn': [Function: parseExtendedQueryString],
'subdomain offset': 2,
'trust proxy': false,
'trust proxy fn': [Function: trustNone],
view: [Function: View],
views: '/Users/ccfyyn/WebstormProjects/ExpressEjs/views',
'jsonp callback name': 'callback',
'view engine': 'ejs'
},
version: 1.0
}
locals 变量可以直接在 views 模板中使用; 比如下边是在 ejs 模板中使用:
<% if(version) { %>
<div><%= version %></div>
<% } %>
1.11.7. app.use
app.use 将一个路径指定到指定的处理函数或 router 路由; 如果未指定路径则表示所有请求都将先通过该 use 传递的回调函数或者是 router;
// 所有请求都将先通过该回调函数, 然后next将请求交给下一个处理函数;
app.use(function (req, resp, next) {
if (req.query.name) {
app.locals.cname = req.query.name;
}
next();
});
app.use('/', routes);
app.use('/users', users);
app.use('/hw', hw);
app.use 根据绑定的顺序从前往后执行,如果前面已经有函数处理并响应了该请求,则后面的函数不再执行;
app.all 则是将与指定正则表达式匹配的所有路径的处理都绑定到对应的处理函数中;
function checkCookie(req, resp) {
if (req.cookies["uid"] || req.query.uid) {
return true;
} else {
resp.send("{\"error\":-1, \"data\":\"请先登录\"}");
return false;
}
}
app.all('/*', function (req, resp, next) {
console.log('filter---');
if (checkCookie(req, resp)) next();
});
1.12. router
express 中的 Router
var express = require('express');
var path = require('path');
var router = express.Router();
1.12.1. router.get()
router.get('/list', function (req, resp) {
var arr = req.query.name || [];
if (typeof(arr) === 'string') {
arr = [arr];
}
resp.render('ejs_list', {
names: arr,
});
});
1.12.2. router.route()
给一个路径指定多个不同的方法:
router.route("/")
.post(function (req, resp) {
var name = req.body.name || "admin";
var age = req.body.age || "25";
resp.send(JSON.stringify({
method: "post",
name: name,
age: age,
}));
})
.delete(function (req, resp) {
var name = req.body.name || "admin";
var age = req.body.age || "25";
resp.send(JSON.stringify({
method: "delete",
name: name,
age: age,
}));
});