NodeJs03 express框架 Todo商城

前言

由于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);

中间件

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

使用中间件有两点注意：

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

应用程序级别中间件

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入口文件

编写项目逻辑

依次编写：

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

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})

});

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);

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进行测试每个接口。