如何构建一个简单的Node.js REST API

文章来源：infoqChristos Ploutarchou

这篇文章中，我们会使用Express、Sequelize和MySQL构建一个Node.js Rest API。这里我们将使用Sequelize来与MySQL实例交互。

所需的应用程序

Docker（https://www.docker.com/products/docker-desktop），是一套平台即服务产品，其使用系统级虚拟化，以称为容器的软件包来交付软件。容器之间彼此隔离，各自将它们的软件、库和配置文件打包在一起；它们可以通过明确定义的通道来通信。
Node.js（https://nodejs.org/en/），是基于Chrome的JavaScript运行时构建的平台，可轻松构建快速且可扩展的网络应用程序。Node.js是一个开源、跨平台的运行时环境，用于开发服务端和网络应用程序。
ExpressJS（https://expressjs.com/），是node.js上最受欢迎的Web框架之一。它建立在node.js的HTTP模块之上，并增加了对路由、中间件、视图系统等特性的支持。它非常简单，体积轻巧，不像其他那些想要无所不包的框架那样臃肿，也就不会牺牲开发人员手中的灵活性，让他们可以选择自己的设计。
Sequelize（https://sequelize.org/），是基于promise，支持Postgres、MySQL、MariaDB、SQLite和微软SQL Server的Node.js ORM。它具有可靠的事务支持、关系、急切和延迟加载及读取复制等特性。
CORS（https://www.npmjs.com/package/cors），是用来提供Connect/Express中间件的node.js包，可使用各种选项来启用CORS。
body-parser（https://github.com/expressjs/body-parser），在处理程序之前在一个中间件中解析传入的请求主体，它在req.body属性下可用。
Postman（https://www.getpostman.com/），是一个API（应用程序编程接口）开发工具，可帮助构建、测试和修改API。它具有发出各种HTTP请求（GET、POST、PUT和PATCH等）的能力。

Node.js Rest CRUD API概述

我们准备构建的Rest API可以按标题来创建、检索、更新、删除和查找帖子（post）。

首先我们做一个Express Web服务器。然后我们为MySQL数据库添加配置，使用Sequelize为Post创建一个模型，编写控制器。接下来，我们定义用来处理所有CRUD操作（包括自定义查找）的路由。

下表概述了将要导出的Rest API

下图是我们的项目结构：

现在开始创建Node.js应用

首先，我们创建一个文件夹：

$ mkdir node_rest_api_with_mysql
$ cd node_rest_api_with_mysql

接下来，我们使用package.json文件初始化Node.js应用：

npm init
name: (nodejs-express-sequelize-mysql) 
version: (1.0.0) 
description: Node.js Rest Apis with Express, Sequelize & MySQL.
entry point: (index.js) server.js
test command: 
git repository: 
keywords: nodejs, express, sequelize, mysql, rest, api, docker
author: Christos Ploutarchou
license: (ISC)
Is this ok? (yes) yes

如果你的PC上已经安装了MySQL，则可以忽略以下步骤

接下来，需要为mysql和phpMyAdmin安装docker。

安装Docker（在此处了解有关Docker安装的更多信息「https://docs.docker.com/install/」）
进入项目根目录
up compose

docker-compose up -d

访问phpmyadmin

your_ip:8183
Server: mysql
Username: root/root
Password: root/pass

在终端上访问mysql

docker exec -it mysql_container_name mysql -u root -p

Docker phpmyadmin ENV

如果你需要有关phpmyadmin映像的更多信息，点这里（https://hub.docker.com/r/phpmyadmin/phpmyadmin/）。
如果你需要有关mysql映像的更多信息，点这里（https://hub.docker.com/_/mysql/）。

我们还要在项目上安装必要的模块：express、sequelize、mysql2和body-parser。

运行命令：

npm install express body-parser cors  sequelize mysql2 --save

安装完成后，package.json文件应如下所示：

{
  "name": "node_rest_api_with_mysql",
  "version": "1.0.0",
  "description": "Node.js Rest Api with Express, Sequelize, MySQL & phpMyAdmin .",
  "main": "server.js",
  "scripts": {
    "start": "nodemon server.js"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/cploutarchou/node_rest_api_with_mysql.git"
  },
  "keywords": [
    "node",
    "rest-api",
    "tutorial",
    "mysql",
    "phpMyAdmin",
    "docker",
    "node.js",
    "sequilize"
  ],
  "author": "Christos Ploutarchou",
  "license": "ISC",
  "bugs": {
    "url": "https://github.com/cploutarchou/node_rest_api_with_mysql/issues"
  },
  "homepage": "https://github.com/cploutarchou/node_rest_api_with_mysql#readme",
  "dependencies": {
    "body-parser": "^1.19.0",
    "cors": "^2.8.5",
    "express": "^4.17.1",
    "mysql2": "^2.1.0",
    "sequelize": "^5.21.5"
  },
  "devDependencies": {
    "nodemon": "^2.0.2"
  }
}

设置Express Web服务器

在我们的根目录中需要创建一个新的server.js文件：

const express = require("express");
const bodyParser = require("body-parser");
const cors = require("cors");
const server = express();
const db = require("./models");
const corsSettings = {
  originL: "http://localhost:8081"
};
const api = require("./routes/index");
server.use(cors(corsSettings));
// Parse request of content-type - application/json
server.use(bodyParser.json());
// parse requests of content-type -application/x-www-form-urlencoded
server.use(bodyParser.urlencoded({ extended: true }));
create a simple route
server.get("/", (_req, res) => {
   res.json({ message: "Welcome to node.js rest api application. Created for learning purposes by Christos Ploutarchou" });
});
// set listening ports for request
const port = process.env.PORT || 8080;
server.listen(port, () => {
  console.log("Server running on port : " + port );
});

我们在这里做的事情是：

导入express、body-parser和cors模块：
- Express用于构建Rest API。
- body-parser帮助解析请求并创建req.body对象。
- cors提供了Express中间件，以多种选项启用CORS。
创建一个Express应用，然后使用app.use()方法添加body-parser和cors中间件。请注意，我们设置了原点：http://localhost:8081。
定义一个易于测试的GET路由。
在端口8080上侦听传入请求。

现在运行以下命令来运行应用：

node server.js。

在浏览器中打开URL http://localhost:8080/，你将看到：

正确，第一步已经完成。在下一部分中我们将动用Sequelize。

配置MySQL数据库和Sequelize

在根文件夹中，我们创建一个单独的config文件夹，用来使用db.config.js文件进行配置，如下所示：

注意：如果你不使用docker compose项目，则需要使用本地环境凭据和信息来更新数据库信息。

module.exports = {
  HOST: "localhost",
  USER: "root",
  PASSWORD: "pass",
  DB: "restapi",
  dialect: "mysql",
  pool: {
    max: 10,
    min: 0,
    acquire: 30000,
    idle: 50000
  }
};

前五个参数用于MySQL连接。 pool是可选的，它将用于Sequelize连接池配置：

max：池中的最大连接数
min：池中的最小连接数
idle：连接释放之前可以空闲的最长时间（以毫秒为单位）
acquire：在引发错误之前，该池将尝试获取连接的最长时间（以毫秒为单位）

有关更多信息，你可以访问Sequelize构造函数的API参考（https://sequelize.org/master/class/lib/sequelize.js~Sequelize.html#instance-constructor-constructor）。

初始化Sequelize

我们将在app/models文件夹中初始化Sequelize，下一步中这个文件夹里会包含模型。

现在使用以下代码创建app/models/index.js：

const dbConfig = require("../config/db.config");
const Sequelize = require("sequelize");
const database = new Sequelize(dbConfig.DB, dbConfig.USER, dbConfig.PASSWORD, {
  host: dbConfig.HOST,
  dialect: dbConfig.dialect,
  operatorsAliases: false,
  pool: {
    max: dbConfig.pool.max,
    min: dbConfig.pool.min,
    acquire: dbConfig.pool.acquire,
    idle: dbConfig.pool.idle
  }
});
const db = {};
db.Sequelize = Sequelize;
db.databaseConf = database;
db.posts = require("./Sequelize.model")(database, Sequelize);
module.exports = db;

不要忘记在server.js中调用sync()方法：

const db = require("./models");
db.databaseConf.sync();

之后，你的server.js文件应该如下所示：

const express = require("express");
const bodyParser = require("body-parser");
const cors = require("cors");
const server = express();
const db = require("./models");
const corsSettings = {
  originL: "http://localhost:8081"
};
const api = require("./routes/index");
server.use(cors(corsSettings));
// Parse request of content-type - application/json
server.use(bodyParser.json());
// parse requests of content-type -application/x-www-form-urlencoded
server.use(bodyParser.urlencoded({ extended: true }));
create a simple route
server.get("/", (_req, res) => {
   res.json({ message: "Welcome to node.js rest api application. Created for learning purposes by Christos Ploutarchou" });
});
// set listening ports for request
const port = process.env.PORT || 8080;
server.listen(port, () => {
  console.log("Server running on port : " + port );
});
db.databaseConf.sync();

定义Sequelize模型

在models文件夹中，创建Sequelize.model.js文件，如下所示：

module.exports = (database, Sequelize) => {
  return database.define("restTutorial", {
    title: {
      type: Sequelize.STRING
    },
    description: {
      type: Sequelize.TEXT
    },
    published: {
      type: Sequelize.BOOLEAN
    },
    publisher: {
      type: Sequelize.STRING
    }
  });
};

这个Sequelize模型表示MySQL数据库中的restTutorials表。以下列将自动生成：id、title（标题）、description（描述）、published（已发布）、createdAt、updatedAt。初始化Sequelize之后我们不需要编写CRUD函数，Sequelize支持下列所有功能：

创建一个新帖子：create(object)（https://sequelize.org/master/class/lib/model.js~Model.html#static-method-create）
获取所有帖子：findAll()（https://sequelize.org/master/class/lib/model.js~Model.html#static-method-findAll）
按id更新一个帖子：update(data, where: { id: id })（https://sequelize.org/master/class/lib/model.js~Model.html#static-method-update）
删除一个帖子：destroy(where: { id: id })（https://sequelize.org/master/class/lib/model.js~Model.html#static-method-destroy）
删除所有帖子：destroy(where: {})
按标题获取所有帖子：findAll({ where: { title: … } })
按发布者名称获取所有帖子：findAll({ where: { title: … } })

这些函数将用在我们的控制器上。

创建控制器

在app/controllers文件夹中，我们使用以下CRUD函数创建Post.js：

create
findAll
findOne
update
delete
deleteAll
findAllPublished
findByPublisherName

const db = require('../models')
const postObj = db.posts
const Op = db.Sequelize.Op
// 创建并保存一个新帖子
exports.create = (request, result) => {
}
// 将帖子对象保存到数据库
postObj.create(post).then(data => {
}
// 获取所有帖子 (接收带条件的数据).
exports.getAllPosts = (request, result) => {
}
// 按ID获取帖子对象
exports.getPostByID = (request, result) => {
}
// 按id更新一个帖子对象
exports.updatePostByID = (request, result) => {
}
// 按ID删除帖子对象
exports.deletePostByID = (request, result) => {
}
// 从数据库删除所有帖子对象
exports.deleteAllPosts = (request, result) => {
}
// 获取所有已发布帖子
exports.getAllPublishedPosts = (request, result) => {
}
// 按发布者名称获取所有帖子
exports.getAllPostsByPublisherName = (request, result) => {
}
// 按标题获取所有已发布帖子
exports.getPostByTitle = (request, result) => {
}

现在我们来实现这些函数。

创建一个新的帖子对象

// 创建并保存新帖子
exports.create = (request, result) => {
  if (!request.body.title) {
    result.status(400).send({
      message: "Content cannot be empty"
    });
  }
  // 创建一个帖子对象
  const post = {
    title: request.body.title,
    description: request.body.description,
    published: request.body.published ? request.body.published : false,
    publisher: request.body.publisher ? request.body.publisher : false
  };
  // 将帖子对象保存到数据库
  postObj.create(post).then(data => {
    result.send(data);
  }).catch(err => {
    result.status(500).send({
      message: err.message || "Some error occurred while saving."
    });
  });
};

获取所有对象（按帖子标题）

// 按标题获取所有已发布帖子
exports.getPostByTitle = (request, result) => {
  const title = request.query.title;
  postObj.findAll({
    where: {
      publisher: { [Op.like]: <code data-enlighter-language="generic" class="EnlighterJSRAW">%${title}%</code> },
      published: true
    }
  }).then(data => {
    result.send(data);
  }).catch(err => {
    result.status(500).send({
      message: err.message || "Something going wrong. Unable to retrieve data!"
    });
  });
};

在这个函数上，我们使用request.query.title从Request中获取查询字符串，并将其视为findAll()方法的条件。

获取单个帖子对象（按帖子ID）

// 按ID获取帖子对象
exports.getPostByID = (request, result) => {
  const paramID = request.params.id;
  console.log(paramID);
  console.log(paramID);
  postObj.findAll({
    where: { id: paramID }
  }).then(data => {
    result.send(data);
  }).catch(err => {
    result.status(500).send({
      message: err.message || <code data-enlighter-language="generic" class="EnlighterJSRAW">Some error occurred while retrieving data with id : ${paramID}</code>
    });
  });
};

按id更新帖子对象

// 按id更新一个帖子对象
exports.updatePostByID = (request, result) => {
  const id = request.params.id;
  postObj.update(request.body, {
    where: { id: id }
  }).then(num => {
    if (num === 1) {
      result.send({
        message: "Post object successfully updated."
      });
    } else {
      result.send({
        message: <code data-enlighter-language="generic" class="EnlighterJSRAW">Cannot update Post object with id=${id}!</code>
      });
    }
  }).catch(err => {
    result.status(500).send({
      message: err.message || <code data-enlighter-language="generic" class="EnlighterJSRAW">Error while updating Post object with id=${id}!</code>
    });
  });
};

按ID删除帖子对象

// 按id删除帖子对象
exports.deletePostByID = (request, result) => {
  const id = request.params.id;
  postObj.destroy({
    where: { id: id }
  }).then(num => {
    if (num === 1) {
      result.send({
        message: "Post object successfully deleted."
      });
    } else {
      result.send({
        message: <code data-enlighter-language="generic" class="EnlighterJSRAW">Cannot delete Post object with id=${id}!</code>
      });
    }
  }).catch(err => {
    result.status(500).send({
      message: err.message || <code data-enlighter-language="generic" class="EnlighterJSRAW">Cannot delete Post object with id=${id}!</code>
    });
  });
};

从数据库中删除所有帖子对象

// 从数据库删除所有帖子对象
exports.deleteAllPosts = (request, result) => {
  postObj.destroy({
    where: {},
    truncate: false
  }).then(nums => {
    result.send({
      message: <code data-enlighter-language="generic" class="EnlighterJSRAW">${nums} Post objects was deleted successfully!</code>
    });
  }).catch(err => {
    result.status(500).send({
      message: err.message || "Cannot delete Post objects. Something going wrong}!"
    });
  });
};

获取所有已发布的帖子

// 获取所有已发布帖子
exports.getAllPublishedPosts = (request, result) => {
  postObj.findAll({
    where: { published: true }
  }).then(data => {
    result.send(data);
  }).catch(err => {
    result.status(500).send({
      message: err.message || "Something going wrong. Unable to retrieve data!"
    });
  });
};

从数据库获取所有已发布的帖子对象

exports.getAllPosts = (request, result) => {
  postObj.findAll()
    .then(data => {
      result.send(data);
    }).catch(err => {
      result.status(500).send({
        message: err.message || "Some error occurred while retrieving data."
      });
    });
};

按发布者名称获取所有帖子

// 按发布者名称获取所有帖子
exports.getAllPostsByPublisherName = (request, result) => {
  const name = request.params.name;
  const condition = name ? { publisher: { [Op.like]: <code data-enlighter-language="generic" class="EnlighterJSRAW">%${name}%</code> } } : null;
  postObj.findAll({ where: condition }).then(data => {
    result.send(data);
  }).catch(err => {
    result.status(500).send({
      message: err.message || "Something going wrong. Unable to retrieve data!"
    });
  });
};

定义路由

当客户端使用HTTP请求（GET、POST、PUT、DELETE）发送对一个端点的请求时，我们需要设置路由来确定服务器的响应方式。

现在我们在route/文件夹中创建一个index.js文件，其内容如下：

const post = require("../controllers/Post");
const express = require("express");
const router = express.Router();
// 创建新帖子
router.post("/api/posts/create", post.create);
// // 检索所有帖子
router.get("/api/posts/all", post.getAllPosts);
// 检索所有已发布帖子
router.get("/api/posts/published", post.getAllPublishedPosts);
// 按发布者名称检索所有已发布帖子
router.get("/api/posts/publisher", post.getAllPostsByPublisherName);
// 按标题检索所有帖子
router.get("/api/posts", post.getPostByTitle);
// 按id检索帖子
router.get("/api/posts/:id", post.getPostByID);
// // 按id更新帖子
router.put("/api/post/update/:id", post.updatePostByID);
// // 按id删除帖子
router.delete("/api/post/delete/:id", post.deletePostByID);
// 删除所有帖子
router.delete("/api/posts/deleteAll", post.deleteAllPosts);
module.exports = router;

你可以看到我们使用了…controllers/Post中的一个控制器。我们还需要在server.js中包含路由（在app.listen()之前）：

const api = require("./routes/index");
server.use("/", api);

更新之后，我们的server.js文件应该如下所示：

const express = require("express");
const bodyParser = require("body-parser");
const cors = require("cors");
const server = express();
const db = require("./models");
const corsSettings = {
  originL: "http://localhost:8081"
};
const api = require("./routes/index");
server.use(cors(corsSettings));
// Parse request of content-type - application/json
server.use(bodyParser.json());
// parse requests of content-type -application/x-www-form-urlencoded
server.use(bodyParser.urlencoded({ extended: true }));
server.use("/", api);
// set listening ports for request
const port = process.env.PORT || 80;
server.listen(port, () => {
  console.log(<code data-enlighter-language="generic" class="EnlighterJSRAW">Server running on port : ${port}</code>);
});
// 如果你要删除已有的表并重新同步数据库，请运行以下函数
// db.dropRestApiTable();
db.databaseConf.sync();

注意：在开发过程中，你可能需要删除现有的表并重新同步数据库。因此我们要在models/index.js上创建一个新函数以应用这个步骤。

在index.js上添加以下函数：

db.dropRestApiTable = () => {
  db.databaseConf.sync({ force: true }).then(() => {
    console.log("restTutorial table just dropped and db re-synced.");
  });
};

要删除现有表时，可以在server.js文件上调用该函数：

db.dropRestApiTable();

测试API

使用以下命令运行我们的Node.js应用程序：

node server.js

Server running on port : 80
Executing (default): CREATE TABLE IF NOT EXISTS restTutorials (id INTEGER NOT NULL auto_increment , title VARCHAR(255), description TEXT, published TINYINT(1), publisher VARCHAR(255), createdAt DATETIME NOT NULL, updatedAt DATETIME NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM restTutorials

我们将使用Postman测试以上所有的API。

1. 使用/api/posts/create API创建一个新帖子

下面是我们的发帖请求示例：

{
    "title": "JS Tutorials : Part 1",
    "description": "Node.js Rest APIs with Express, Sequelize & MySQL Part 1",
    "published": true,
    "publisher": "Christos Ploutarchou"
}

当我们发送发帖请求（如果数据存储在数据库上）时，我们应该会收到STATUS: 200OK

注意：如果使用docker-compose运行MySQL，则可以使用以下凭据username: root | password: pass在localhost:8183上访问phpMyAdmin。

创建了一些新帖子后，你可以在phpMyAdmin上运行以下查询来检查MySQL表

select * from posts;

你的输出应该如下图所示：

2. 使用GET /api/posts/all API检索所有帖子

你应该获得如下图所示的反馈：

获取所有帖子

3. 使用GET /api/posts/:id API检索所有帖子

按ID获取帖子

4. 使用PUT /api/post/update/:id API更新帖子

按ID更新帖子

5. 使用GET /api/posts?title=tutorial API查找所有包含单词“tutorials”的帖子

按标题获取帖子

6. 使用GET /api/posts/publisher/?name=Christos API按发布者名称查找所有帖子

按发布者名称获取所有帖子

7. 使用GET /api/posts/published API查找所有已发布的帖子

获取所有已发布的帖子

8. 使用DELETE /api/posts/delete/:id API删除帖子

按帖子ID删除帖子

9. 使用DELETE /api/posts/deleteAll API删除所有帖子

删除所有帖子

你可以通过我的GitHub存储库下载项目的完整副本（https://github.com/cploutarchou/node_rest_api_with_mysql）。（如果你喜欢我的项目，请留下一颗星星）

原文链接：https://christosploutarchou.com/how-to-build-simple-node-js-rest-api

本文最初发布于Christos Ploutarchou博客，经原作者授权由InfoQ中文站翻译并分享。

发表于: 2020-04-212020-04-21 10:26:11
本文为 InfoQ 中文站特供稿件
首发地址：https://www.infoq.cn/article/W2NlDcVzU3YYqd0YFH6B
如有侵权，请联系 cloudcommunity@tencent.com 删除。

扫码

添加站长进交流群

领取专属 10元无门槛券

私享最新 技术干货

如何构建一个简单的Node.js REST API

所需的应用程序

Node.js Rest CRUD API概述

现在开始创建Node.js应用

接下来，需要为mysql和phpMyAdmin安装docker。

Docker phpmyadmin ENV

设置Express Web服务器

配置MySQL数据库和Sequelize

初始化Sequelize

定义Sequelize模型

创建控制器

创建一个新的帖子对象

获取所有对象（按帖子标题）

获取单个帖子对象（按帖子ID）

按id更新帖子对象

按ID删除帖子对象

从数据库中删除所有帖子对象

获取所有已发布的帖子

从数据库获取所有已发布的帖子对象

按发布者名称获取所有帖子

定义路由

测试API

我们将使用Postman测试以上所有的API。

1. 使用/api/posts/create API创建一个新帖子

2. 使用GET /api/posts/all API检索所有帖子

3. 使用GET /api/posts/:id API检索所有帖子

4. 使用PUT /api/post/update/:id API更新帖子

5. 使用GET /api/posts?title=tutorial API查找所有包含单词“tutorials”的帖子

6. 使用GET /api/posts/publisher/?name=Christos API按发布者名称查找所有帖子

7. 使用GET /api/posts/published API查找所有已发布的帖子

8. 使用DELETE /api/posts/delete/:id API删除帖子

9. 使用DELETE /api/posts/deleteAll API删除所有帖子

相关快讯

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐