前言

由于NodeJs本身的异步非阻塞特性和对http的天然支持，所以使用NodeJs编写高性能，可伸缩的Web服务器非常简单。开发完整的Web服务器还需要路由，错误处理，请求拦截，请求和响应的解析，模板引擎等功能，所以直接使用NodeJs的http模块开发起来还是挺痛苦的。

目前有很多的Web框架都是基于http模块封装而成，最流行的当属Express框架。

学习资源：

快速开始

npm install express --save

快速开启服务器：

const express = require('express');
const app = express();

app.get('/', function(req, res){
  res.send('hello world');
});

app.listen(3000);

静态文件

express提供了托管静态文件的功能，比如html，图片，CSS，JavaScript等文件。

app.use(express.static('public'));

支持指定挂载路径：

app.use('/static', express.static('public'));

一般框架提供的静态文件托管功能，只是在开发环境使用。在生产环境，推荐交给反向代理服务器来管理，比如Nginx；最佳的做法是花点钱交给CDN提供商来服务。

路由

路由就是根据用户请求的url路径，交由对应的响应方法处理。

请求方法

app.get('/', function (req, res) {
  res.send('GET request to the homepage');
});

// POST method route
app.post('/', function (req, res) {
  res.send('POST request to the homepage');
});

路径匹配

// 匹配根路径
app.get('/', function (req, res) {
  res.send('root');
});

// 匹配 /user 路径的请求
app.get('/user', function (req, res) {
  res.send('user');
});

// 匹配 /xxx 路径的请求
app.get('/xxx', function (req, res) {
  res.send('xxx');
});

支持简单的字符串匹配：

// 匹配 acd 和 abcd
app.get('/ab?cd', function(req, res) {
  res.send('ab?cd');
});

// 匹配 abcd、abbcd、abbbcd等
app.get('/ab+cd', function(req, res) {
  res.send('ab+cd');
});

// 匹配 abcd、abxcd、abRABDOMcd、ab123cd等
app.get('/ab*cd', function(req, res) {
  res.send('ab*cd');
});

也支持完全的正则方式，但是不能用字符串了。

// 匹配以abc开头的所有字符
app.get(/abc[0-9a-zA-Z]*/, function(req, res) {
  res.send('ab?cd');
});

模块化路由

模块化路由是指我们可以将一组具有业务相关性的路由封装为一个router对象，然后挂载到指定路径。

const express = require('express');
const router = express.Router();

// 该路由使用的中间件
router.use(function timeLog(req, res, next) {
  console.log('Time: ', Date.now());
  next();
});
// 定义模块的根路由
router.get('/', function(req, res) {
  res.send('auth模块根路由');
});
// 定义登录
router.get('/login', function(req, res) {
  res.send('login');
});

module.exports = router;

将router挂载到指定路径：

const auth = require('./auth');
...
app.use('/auth', auth);

中间件

中间件就是整个请求——>响应流程中的一系列处理函数。路由也是属于中间件，是挂载了路径的中间件。

使用中间件有两点注意：

  1. next() 方法和 res.send() 必须调用一个，否则请求就会挂起，客户端等待响应。
  2. 中间件的顺序很重要，它是按照你注册的顺序执行的。

应用程序级别中间件

const app = express();

// 没有挂载路径的中间件，应用的每个请求都会执行该中间件
app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// 挂载至 /user/:id 的中间件，任何指向 /user/:id 的请求都会执行它
app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

​

路由级别中间件

路由级中间件和应用级中间件一样，只是它绑定的对象为 express.Router()。

const router = express.Router();

// 没有挂载路径的中间件，通过该路由的每个请求都会执行该中间件
router.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// 一个中间件栈，显示任何指向 /user/:id 的 HTTP 请求的信息
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// 一个中间件栈，处理指向 /user/:id 的 GET 请求
router.get('/user/:id', function (req, res, next) {
  // 如果 user id 为 0, 跳到下一个路由
  if (req.params.id == 0) next('route');
  // 负责将控制权交给栈中下一个中间件
  else next(); //
}, function (req, res, next) {
  // 渲染常规页面
  res.render('regular');
});

module.exports = router;

挂载router

const app = express();
app.use('/', router);

错误处理

程序总会遇到错误，比如：传参错误，我们不小心调用了undifined，或者我们自己也可能抛出异常。当发生这些错误的时候我们需要给用户一个友好的回应，这就是错误处理。

定义错误处理中间件和定义其他中间件一样，除了需要 4 个参数，而不是 3 个，其格式如下 (err, req, res, next)。例如：

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('出错了!');
});

错误中间件返回的响应是随意的，可以响应一个 HTML 错误页面、一句简单的话、一个 JSON 字符串，或者其他任何您想要的东西。

在其他 app.use() 和路由调用后，最后定义错误处理中间件，比如：

app.use(bodyParser());
app.use(router);
app.use(function(err, req, res, next) {
  // ...
});

模板引擎

Html页面本身是静态的，不含动态数据的。模板引擎的作用就是将从数据库读出来的，处理好的数据填充到html页面，然后返回给用户。

express支持很多的模板引擎，每个模板引擎都有自己的语法。这里以jade为例。

需要安装相应的模板引擎 npm 软件包。

npm install jade --save

设置模板的目录，和当前使用的模板引擎

app.set('views', './views') //设置模板存放的目录
app.set('view engine', 'jade'); //设置使用的引擎

在 views 目录下生成名为 index.jade 的 Jade 模板文件，内容如下：

html
  head
    title=title
  body
    h1=message

然后创建一个路由渲染 index.jade 文件。

app.get('/', function (req, res) {
  res.render('index', { title: 'Hey', message: 'Hello there!'});
});

index.jade 文件会被引擎渲染为html文件，然后发送给用户。jade引擎的更多使用请参考它的官方文档，这里只做简单演示，原因如下：

现代Web开发的模式是逐渐趋向于前后端分离，前端的人负责写Html页面，后台的人写API服务，前端数据通过AJAX得到。这样的好处是开发效率高，沟通成本降低。加上Vue和React等具有高性能和高效率的前端渲染引擎的出现，后端的模板引擎的几乎没有用武之地了。但不排除某些公司的技术人员仍然顽固地选择后端渲染。

WebApp进程管理

在生产环境我们不会使用node app.js的方式来开启程序，因为我们有这样的一些需求：

  • 如果进程崩溃了，需要重启
  • 监控当前进程的CPU使用率和内存占用
  • 搭建集群

进程管理器就能提供上面的功能，让我们的NodeJs进程永不退出。最流行的进程管理器有3个：

其中PM2除了提供上面的功能外，还可以监视程序的日志，错误提醒，并且内置了负载均衡器，界面还友好。所以我们选择使用PM2。

首先，安装。

npm install pm2 -g

启动程序：

pm2 start app.js

其他常用命令：

pm2 list
pm2 stop app
pm2 reload app
pm2 start xxx.js -i 4

学习资源

第三方中间件：http://www.expressjs.com.cn/resources/middleware.html

API查询：http://www.expressjs.com.cn/4x/api.html

TODO 后台项目

项目介绍

完成对TODO事项的增删改查功能，数据库使用mongodb。

安装依赖

创建项目，新建package.json文件。

npm i express -S
npm i mongoose -S
npm i morgan -S  // 打印log的类库
npm i express-async-errors -S  // 用来捕获promise错误

由于express 4x为了精简框架，移除了很多内置的中间件，比如body-parser。所以为了能够解析body参数，需要额外安装这个模块。

npm i body-parser -S

项目结构搭建

整个项目结构，仍然是基于MVC架构来分层。

  • service包：存放所有的业务逻辑类，相当于service层

  • router包：存放所有的路由，相当于controller层

  • util包：存放所有的帮助类

  • model包：存放所有的mongodb模型类，相当于dao层

  • config.js：配置文件

  • db.js：数据库入口文件

  • app.js：app入口文件

编写项目逻辑

依次编写：

  1. app.js 和 config.js

    'use strict'
// 连接数据库
require('./db')

const config = require('./config')
const bodyParser = require('body-parser');
const morgan = require('morgan');
const express = require('express')
// 引入express异步异常捕获模块
require('express-async-errors');
const app = express();

// 注册log中间件
app.use(morgan('combined'));

// 注册body解析中间件
// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }));
// parse application/json
app.use(bodyParser.json());

// 注册路由
app.use('/todos', require('./router/todo'));

// 注册错误处理中间件
app.use(function (err, req, res, next) {
    console.log(err);
    res.send({
        code: -1,
        msg: err.toString()
    })
});

app.listen(config.PORT);

    'use strict'
const config = {
    PORT: 3000,
    DB: 'TODO',
}

module.exports = config

  2. router

    'use strict'

const router = require('express').Router()
const todoController = require('../controller/todo')

module.exports = router

router.get('/', async (req, res)=>{
    let todos = await todoController.getAllTodo();
    res.send({
        code: 0,
        data: todos
    })
});

router.post('/', async (req, res)=>{
    await todoController.addTodo(req.body)
    res.send({code: 0})
});

router.put('/:id', async (req, res)=>{
    await todoController.updateTodo(req.params.id, req.body)
    res.send({code: 0})
});

// 删除某个todo
router.delete('/:id', async (req, res)=>{
    await todoController.deleteTodo(req.params.id)
    res.send({code: 0})
});

    ​

  3. db.js 和 model

    'use strict'

const config = require('./config')
const mongoose = require('mongoose')

mongoose.connect(`mongodb://127.0.0.1/${config.DB}`)

const db = mongoose.connection

db.on('error', err=>{
    console.log(err);
});
db.on('open', ()=>{
    console.log('db connect successful!');
});

    'use strict'
// To-do: 模型类, 内容，是否完成，创建日期
const mongoose = require('mongoose')

const schema = new mongoose.Schema({
    content: String,
    isDone: {
        type:Boolean,
        default: false
    },
    created: {
        type: Date,
        default: Date.now()
    }
});

module.exports = mongoose.model('todo', schema);

    ​

  4. controller

    'use strict'

const Todo = require('../model/todo')

// 取出数据库中的所有todo，然后返回
async function getAllTodo() {
    return await Todo.find({})
}

async function updateTodo(id, update) {
    await isIdExist(id)

    // { n: 1, nModified: 1, ok: 1 }
    let res = await Todo.updateOne({_id:id}, update)
    if(!res || res.n<1){
        throw `${update}更新失败`
    }
}

async function addTodo(todo) {
    // 先查询名字是否存在
    let t = await Todo.findOne({content: todo.content})
    if(t){
        //说明已经存在，则抛出异常，由异常处理中间件负责处理
        throw `${todo.content} 已经存在`
    }
    await Todo.create(todo)
}

async function isIdExist(id) {
    // 先判断传入的id是否存在
    let t = await Todo.findOne({_id: id})
    if(!t){
        throw `${id}不存在`
    }
}

async function deleteTodo(id) {
    await isIdExist(id)

    // { n: 1, ok: 1 }
    let res = await Todo.deleteOne({_id:id})
    console.log(res);
    if(!res || res.n < 1){
        throw `${id}删除失败`
    }
}

module.exports = {
    getAllTodo, updateTodo, addTodo, deleteTodo
}

    ​

API 测试

使用postman进行测试每个接口。