express使用基础手册
简介
基于Node.js的Web开发框架
安装
npm安装express、body-parser、cookie-parser、serve-static
结构
app demo
- node_modules------用于安装本地模块。
- public------------用于存放用户可以下载到的文件，比如图片、脚本、样式表等。
- routes------------用于存放路由文件。
- views-------------用于存放网页的模板。
- app.js------------应用程序的启动脚本。
- package.json------项目的配置文件。
启动脚本package.json
package.json用于指定app信息，nodejs版本号和其他组件的依赖关系
{
"name": "demo",
"description": "test",
"version": "1.0.0",
"dependencies": {
"express": "4.x"
}
}
生成 npm init
安装 npm install
app入口app.js
app.js主要包含http的创建，基本路由，监听端口号
创建express服务器
//app.js文件
var express = require('express');
var app = express();
//根目录显示helloworld
app.get('/', function(req, res){
res.send('Hello World');
});
//指定监听端口
var server = app.listen(3000, function() {
console.log('Listening on port %d', server.address().port);
});
运行nodejs应用程序
/>node app.js
创建HTTPs服务器
var fs = require('fs');
var options = {
key: fs.readFileSync('E:/ssl/myserver.key'),
cert: fs.readFileSync('E:/ssl/myserver.crt'),
passphrase: '1234'
};
var https = require('https');
var express = require('express');
var app = express();
app.get('/', function(req, res){
res.send('Hello World Expressjs');
});
var server = https.createServer(options, app);
server.listen(8084);
console.log('Server is running on port 8084');
中间件
中间件(middleware)就是处理HTTP请求的函数
当一个HTTP请求进入服务器，服务器实例会调用第一个中间件，完成后根据设置，决定是否再调用下一个中间件.
每个中间件都可以对HTTP请求（request对象）进行加工，并且决定是否调用next方法，将request对象再传给下一个中间件。
参数:
- 四个参数—错误处理、客户请求request、服务器响应respond、next中间件.
function(error,request, response, next){}
- 三个参数—请求request，服务器响应respond，next中间件
function(request, response, next){}
- 两个参数—客户请求request，服务器响应respond
function(request,response){}
路由set方法
设置环境变量，set用于指定变量的值.
app.set("views", __dirname + "/views");
app.set('view engine','jade')
路由use方法
use是express注册中间件的方法，它返回一个函数。
app.use(function(request, response, next) {
console.log("In comes a " + request.method + " to " + request.url);
next();
});
app.use(function(request, response) {
response.writeHead(200, { "Content-Type": "text/plain" });
response.end("Hello world!\n");
});
使用app.use方法，注册了两个中间件。收到HTTP请求后，先调用第一个中间件，在控制台输出一行信息，然后通过next方法，将执行权传给第二个中间件，输出HTTP回应。由于第二个中间件没有调用next方法，所以request对象就不再向后传递了。
use使用方式
express路由的方式有多种，常用:
app.all("*",middleware);
app.use('/', middleware);//get/post时，对于路径/的处理
app.get("/", middleware);//http中get时，对于路径/的处理
app.post("/", middleware);//http中post时，对于路径/的处理
app.put("/", middleware);//http中put时，对于路径/的处理
app.delete("/", middleware);//http中delete时，对于路径/的处理
routes.js
module.exports=function(app){
app.get/post......
}
app.js引入路由
require('./routes')(app)
错误内容显示
app.use(cookieParser())
app.use(serveStatic('public'))
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: './tmp/'}).array('image'));
app.use(cookieParser());
app.use(function(err, req, res, next){
console.error(err.stack);
res.send(500, 'Something broke!');
});//错误内容显示
路径通配符
app.get("*", function(request, response) {
response.end("404!");
});//所有路径都返回404
app.get("/hello/:who", function(req, res) {
res.end("Hello, " + req.params.who + ".");
});//如"/hello/alice”网址，网址中的alice将被捕获，作为req.params.who属性的值
response对象方法
重定向redirect
response.redirect("/hello/anime");//重定向到/hello/anime
response.redirect("http://www.example.com");
response.redirect(301, "http://www.example.com");
发送文件sendFile
response.sendFile("/path/to/anime.mp4");
渲染网页模板render
response.render("index", { message: "Hello World" });//将message变量传入index模板，值为"Hello World"渲染成HTML网页
requst对象方法
获取客户ip地址:request.ip
获取上传的文件:request.files
##指定静态网页目录
//app.js
app.use(serveStatic('public'));//指定静态网页目录,当浏览器发出非HTML文件请求时，服务器端就到public目录寻找这个文件
例如：
<link href="/bootstrap/css/bootstrap.css" rel="stylesheet">
服务器端就到public/bootstrap/css/目录中寻找bootstrap.css文件
Express.Router用法
从Express 4.0开始，路由器功能成了一个单独的组件Express.Router。它好像小型的express应用程序一样，有自己的use、get、param和route方法。
基本用法
首先，Express.Router是一个构造函数，调用后返回一个路由器实例。然后，使用该实例的方法，为不同的访问路径，指定回调函数；最后，挂载到某个路径。
var router = express.Router();
router.get('/', function(req, res) {
res.send('首页');
});
router.get('/about', function(req, res) {
res.send('关于');
});
app.use('/', router);
上面代码先定义了两个访问路径，然后将它们挂载到根目录。如果最后一行改为app.use(‘/app’, router)，则相当于为/app和/app/about这两个路径，指定了回调函数。
这种路由器可以自由挂载的做法，为程序带来了更大的灵活性，既可以定义多个路由器实例，也可以为将同一个路由器实例挂载到多个路径。
router.route方法
router实例对象的route方法，可以接受访问路径作为参数
var router = express.Router();
router.route('/api')
.post(function(req, res) {
// ...
})
.get(function(req, res) {
Bear.find(function(err, bears) {
if (err) res.send(err);
res.json(bears);
});
});
app.use('/', router);
router中间件
use方法为router对象指定中间件，即在数据正式发给用户之前，对数据进行处理。下面就是一个中间件的例子。
router.use(function(req, res, next) {
console.log(req.method, req.url);
next();
});
上面代码中，回调函数的next参数，表示接受其他中间件的调用。函数体中的next()，表示将数据传递给下一个中间件。
注意，中间件的放置顺序很重要，等同于执行顺序。而且，中间件必须放在HTTP动词方法之前，否则不会执行。
对路径参数的处理
router对象的param方法用于路径参数的处理
router.param('name', function(req, res, next, name) {
// 对name进行验证或其他处理……
console.log(name);
req.name = name;
next();
});
router.get('/hello/:name', function(req, res) {
res.send('hello ' + req.name + '!');
});
get方法为访问路径指定了name参数，param方法则是对name参数进行处理。注意，param方法必须放在HTTP动词方法之前。
app.route
假定app是Express的实例对象，Express 4.0为该对象提供了一个route属性。app.route实际上是express.Router()的缩写形式，除了直接挂载到根路径。因此，对同一个路径指定get和post方法的回调函数，可以写成链式形式。
app.route('/login')
.get(function(req, res) {
res.send('this is the login form');
})
.post(function(req, res) {
console.log('processing');
res.send('processing the login form!');
});
上面代码的这种写法，显然非常简洁清晰。
简单的开发实例（手动）
项目目录结构
package.json
{
"name": "demoproject",
"version": "1.0.0",
"description": "a demo project for nodejs express mysql",
"main": "app.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/Lorogy/demoProject.git"
},
"keywords": [
"nodejs",
"express",
"mysql",
"bootstrap"
],
"author": "lorogy",
"license": "ISC",
"bugs": {
"url": "https://github.com/Lorogy/demoProject/issues"
},
"homepage": "https://github.com/Lorogy/demoProject#readme",
"dependencies": {
"body-parser": "^1.18.2",
"cookie-parser": "^1.4.3",
"express": "^4.16.2",
"multer": "^1.3.0",
"mysql": "^2.15.0",
"serve-favicon": "^2.4.5"
},
"devDependencies": {}
}
编写启动脚本
- 先建立一个项目目录（假定这个目录叫做demoProject）
- 进入该目录，初始化
npm init//生成package.json文件
npm install
- 项目目录下新建文件app.js
var express = require('express');
var app = express();
首先加载express模块，赋给变量express。然后，生成express实例，赋给变量app。
接着，设定express实例的参数。
// 设定port变量，意为访问端口
var port=process.env.PORT || 3000;
//app.set('port',process.env.PORT || 3000);
// 设定views变量，意为视图存放的目录
app.set('views', path.join(__dirname, '/views'));
// 设定view engine变量，意为网页模板引擎
app.set('view engine', 'jade');
//中间件，自选、多种
app.use(bodyParser.urlencoded({extended:true}))
app.use(cookieParser())
// 设定静态文件目录，比如本地文件
// 目录为demo/public/images，访问
// 网址则显示为http://localhost:3000/images
app.use(serveStatic('public'))
set方法用于设定内部变量，use方法用于调用express的中间件。
最后，调用实例方法listen，让其监听事先设定的端口（3000）。
app.listen(port);
或者
app.listen(app.get('port'));
这时，运行下面的命令，就可以在浏览器访问http://127.0.0.1:3000。
node app.js
此时网页提示“Cannot GET /”，表示没有为网站的根路径指定可以显示的内容。
配置路由
所谓“路由”，就是指为不同的访问路径，指定不同的处理方法。
- 指定根路径
在app.js之中，先指定根路径的处理方法。
app.get('/', function(req, res) {
res.send('Hello World');
});
get方法，表示处理客户端发出的GET请求。
相应还有app.post、app.put、app.del（delete是JavaScript保留字，所以改叫del）方法。
get方法的第一个参数是访问路径，正斜杠（/）就代表根路径；第二个参数是回调函数，它的req参数表示客户端发来的HTTP请求，res参数代表发向客户端的HTTP回应，这两个参数都是对象。
在回调函数内部，使用HTTP回应的send方法，表示向浏览器发送一个字符串。
然后，运行下面的命令。
node app.js
此时，在浏览器中访问http://127.0.0.1:3000，网页就会显示“Hello World”。
如果需要指定HTTP头信息，回调函数就必须换一种写法，要使用setHeader方法与end方法。
app.get('/', function(req, res){
var body = 'Hello World';
res.setHeader('Content-Type', 'text/plain');
res.setHeader('Content-Length', body.length);
res.end(body);
});
- 指定特定路径
上面是处理根目录的情况，下面再举一个例子。
假定用户访问/api路径，希望返回一个JSON字符串。这时，get可以这样写。
app.get('/api', function(request, response) {
response.send({name:"张三",age:40});
});
上面代码表示，除了发送字符串，send方法还可以直接发送对象。重新启动node以后，再访问路径/api，浏览器就会显示一个JSON对象。
{
"name": "张三",
"age": 40
}
我们也可以把app.get的回调函数，封装成模块。
先在routes目录下面建立一个routes.js文件。
// routes/routes.js
var path=require('path');
var fs = require("fs");
module.exports=function(app){
app.get('/', function (req, res) {
console.log('GET:/index.htm')
res.sendFile( path.resolve(__dirname,"../views/index.htm"));
});
app.post('/file_upload', function (req, res) {
console.log('POST:/file_upload')
console.log(req.files[0]); // 上传的文件信息
var des_file =path.resolve(__dirname,"../tmp/",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.writeHead(200, {'Content-Type': 'text/html; charset=utf8'});
res.end( JSON.stringify( response ) );
});
});
});
};
然后，在app.js中加载这个模块。
// app.js
require('./routes/routes.js')(app);
现在访问时，就会显示与上一次同样的结果。
如果只向浏览器发送简单的文本信息，上面的方法已经够用；但是如果要向浏览器发送复杂的内容，还是应该使用网页模板。
静态网页模板
在项目目录之中，建立一个子目录views，用于存放网页模板。
app.js：
var express = require('express');
var app = express();
app.get('/', function(req, res) {
res.sendfile('./views/index.htm');
});
向服务器发送信息的方法，从send变成了sendfile，后者专门用于发送文件。
假定index.html的内容如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>HELLO WORLD!</title>
</head>
<body>
<h3>hello,welcome~</h3>
</form>
<h3>文件上传：</h3>
选择一个文件上传: <br />
<form action="/file_upload" method="post" enctype="multipart/form-data">
<input type="file" name="image" size="50" />
<br />
<input type="submit" value="上传文件" />
</form>
</body>
</html>
这是一个静态网页。如果想要展示动态内容，就必须使用动态网页模板。
动态网页模板
- 安装模板引擎
- 改写app.js
- 新建数据脚本
- 新建网页模板
- 渲染模板
- 改写app.js
- node app.js
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
