express使用基础手册

#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目录寻找这个文件

例如：

服务器端就到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的内容如下：

  
  


  
hello,welcome~
  
  
文件上传：
  选择一个文件上传: 

  

    
    

    
  

这是一个静态网页。如果想要展示动态内容，就必须使用动态网页模板。
###动态网页模板

1. 安装模板引擎
2. 改写app.js
3. 新建数据脚本
4. 新建网页模板
5. 渲染模板
6. 改写app.js
7. node app.js

---

参考链接：http://www.cnblogs.com/mq0036/p/5243312.html