在本文中，我会分享一些有关 MongoDB 命令的基本知识，例如查询、过滤数据、删除、更新等等。

好的，我们开始吧！

配置

为了使用 MongoDB，首先需要在计算机上安装 MongoDB。为此，请访问官方下载中心，下载适用于你的操作系统的版本。在这篇文章里，我会以 Windows 为例。

下载 MongoDB 社区服务器设置后，你将依次点击“下一个”完成安装。完成后，转到安装了 MongoDB 的 C 驱动器。打开程序文件，然后选择 MongoDB 目录。

C: -> Program Files -> MongoDB -> Server -> 4.0(version) -> bin

在 bin 目录中，你会发现几个有趣的可执行文件。

• mongod
• mongo

我们看一下这两个文件。

mongod 代表“ Mongo Daemon”。mongod 是 MongoDB 使用的后台进程。mongod 的主要目的是管理所有 MongoDB 服务器任务，例如：接受请求，响应客户端和内存管理。

mongo 是可以与客户端（例如，系统管理员和开发人员）进行交互的命令行外壳。

现在，让我们看看如何启动和运行该服务器。在 Windows 上，首先需要在 C 驱动器中创建几个目录。在 C 驱动器中打开命令提示符，然后执行以下操作：

C:\> mkdir data/dbC:\> cd dataC:\> mkdir db

这些目录的目的是 MongoDB 需要一个文件夹来存储所有数据。MongoDB 的默认数据目录路径是驱动器上的 /data/db。因此，有必要像这样提供这些目录。

如果启动不带这些目录的 MongoDB 服务器，则可能会看到以下错误：

创建完这两个文件后，再次转到 mongodb 目录中的 bin 文件夹，然后打开其中的 shell。运行以下命令：

mongod

瞧！ 现在，我们的 MongoDB 服务器已启动并正在运行！？

为了使用此服务器，我们需要一个中介器。在 bind 文件夹中打开另一个命令窗口，然后运行以下命令：

mongo

运行此命令后，导航到运行 mongod 命令的外壳程序（这是我们的服务器）。你会在最后看到“接受连接”消息。这意味着我们的安装和配置成功！

只需在 mongo shell 中运行即可：

db

配置环境变量

为了节省时间，你可以设置环境变量。在 Windows 中，通过以下菜单完成：

Advanced System Settings -> Environment Variables -> Path(Under System Variables) -> Edit

只需复制我们的 bin 文件夹的路径，然后运行它。在我的这个示例里，是这样的：

C:\Program Files\MongoDB\Server\4.0\bin

现在你就完成设置了！

使用 MongoDB

大量的 GUI 图形用户界面（例如 MongoDB Compass，Studio 3T 等）可和 MongoDB  服务器一起使用。

它们提供了图形界面，因此你可以轻松地使用数据库并执行查询，而无需使用 Shell 并手动键入查询。

但是在本文中，我们将使用命令提示符来完成工作。

现在我们深入研究 MongoDB 命令，这些命令将帮助你在将来的项目中使用。

• 打开命令提示符，然后键入 mongod 以启动 MongoDB 服务器。
• 打开另一个外壳，然后键入 mongo 以连接到 MongoDB 数据库服务器。

1. 确定你目前在哪个数据库

db

此命令将显示你当前所在的数据库。test 是默认情况下的初始数据库。

2. 罗列数据库

show databases

我目前有四个数据库：CrudDB， admin， config 和 local。

3. 访问某个数据库

use <your_db_name>

在这里，我已移至 local 数据库。你可以使用命令 db 打印出当前数据库的名称，进行检查。

4. 创建一个数据库

使用 RDBMS（关系数据库管理系统），我们可以获得数据库、表、行和列。

但是，在 NoSQL 数据库（例如 MongoDB）中，数据以 BSON 格式（JSON 的二进制版本）存储。它们存储在称为“集合”的结构中。

在 SQL 数据库中，这些类似于表。

接下来，我们谈谈如何在 mongo shell 中创建数据库。

use <your_db_name>

等一下，我们之前有这个命令！ 为什么我再次使用它？

在 MongoDB 服务器中，如果你的数据库已经存在，则使用该命令将导航到你的数据库。

但是，如果数据库尚不存在，则 MongoDB 服务器将为你创建数据库。然后，它将导航到其中。

创建新数据库后，运行 show database 命令将不会显示你新创建的数据库。这是因为，当数据库包含一些数据（文档）后，它才会显示在你的数据库列表中。

5. 创建一个集合

使用 use 命令导航到新创建的数据库。

实际上，有两种创建集合的方法。

一种方法是将数据插入到集合中：

db.myCollection.insert({"name": "john", "age" : 22, "location": "colombo"})

即使该集合不存在，这也将创建你的集合 myCollection。然后它将插入带有 name 和 age 的文档。这些是无上限的集合。

第二种方法如下所示：

2.1 创建一个无上限的集合

db.createCollection("myCollection")

2.2 创建一个有上限的集合

db.createCollection("mySecondCollection", {capped : true, size : 2, max : 2})

这样，你将无需插入数据即可创建集合。

“有上限的集合”规定了最大的文档数，可防止文档溢出。在此示例中，我通过将其值设置为 true 启用上限。

size : 2 表示限制为 2MB，max: 2 将最大文档数设置为 2。

现在，如果你尝试在 mySecondCollection 中插入两个以上的文档，并使用 find  命令（我们将在稍后讨论），你只会看到最近插入的文档。请记住，这并不意味着第一个文档已被删除——它只是未显示。

6. 插入数据

我们可以将数据插入到新集合或之前创建的集合中。

有三种插入数据的方法：

• insertOne() 仅用于插入单个文档
• insertMany() 用于插入多个文档
• insert() 用于插入所需数量的文档

下面是一些示例：

• insertOne()

db.myCollection.insertOne(
  {
    "name": "navindu", 
    "age": 22
  }
)

• insertMany()

db.myCollection.insertMany([
  {
    "name": "navindu", 
    "age": 22
  },
  {
    "name": "kavindu", 
    "age": 20
  },

  {
    "name": "john doe", 
    "age": 25,
    "location": "colombo"
  }
])

insert() 方法类似于 insertMany() 方法。

另外，请注意，我们在文档中为 John Doe 插入了一个名为 location 的新属性。因此，如果你使用 find，则只会看到 john doe 具有 location 属性。

对于 NoSQL 数据库（例如 MongoDB），这可能是一个优势，有利于可扩展性。

7. 查询数据

你可以通过以下方法查询集合中的所有数据：

db.myCollection.find()

如果你想通过更清晰的方式查看此数据，只需在其末尾添加 .pretty() 即可。这将以漂亮的 JSON 格式显示文档。

db.myCollection.find().pretty()

等等，在这些示例中，你是否注意到了类似 _id 的东西？

无论何时插入文档，MongoDB 都会自动添加一个 _id 字段。该字段唯一地标识每个文档。如果你不想显示它，只需运行以下命令：

db.myCollection.find({}, _id: 0).pretty()

接下来，我们看一下过滤数据。

如果要显示某些特定文档，则可以指定要显示的文档的单个详细信息。

db.myCollection.find(
  {
    name: "john"
  }
)

假设你只想显示年龄在 25 岁以下的人。您可以使用 $lt 对此进行过滤。

db.myCollection.find(
  {
    age : {$lt : 25}
  }
)

同样，$gt 表示大于，$lte 表示“小于或等于”，$gte 表示“大于或等于”，$ne 是“不等于”。

8. 更新文档

假设你想更新某人的地址或年龄，该怎么做？ 请看下一个例子：

db.myCollection.update({age : 20}, {$set: {age: 23}})

第一个参数是要更新哪个文档的字段。在这里，我为简单起见指定了 age。在生产环境中，你可以使用 _id 字段。

最好使用 _id 之类的内容来更新特定的一行。 这是因为多个字段可以具有相同的年龄和名称。 因此，如果更新一行，它将影响具有相同名称和年龄的所有行。

如果你使用新属性（例如 location）更新文档，则文档将使用新属性进行更新。如果你执行 find，那么结果是：

如果你需要从单个文档中删除某个属性，则可以执行以下操作（假设你希望删除 age）：

db.myCollection.update({name: "navindu"}, {$unset: age});

9. 删除一个文档

如前所述，当你更新或删除文档时，你只需要指定 _id 即可，而不是 name，age，location。

db.myCollection.remove({name: "navindu"});

10. 删除一个集合

db.myCollection.remove({});

注意，这不等于 drop() 方法。不同之处在于 drop() 用于删除集合中的所有文档，而 remove() 方法用于删除集合本身以及所有文档。

逻辑运算符

MongoDB 提供逻辑运算符。下图总结了不同类型的逻辑运算符。

假设你要显示年龄小于 25 岁且位置在科伦坡的人，怎么做呢？

我们可以使用 $and 运算符！

db.myCollection.find({$and:[{age : {$lt : 25}}, {location: "colombo"}]});

最后，我们来谈谈聚合。

聚合

快速看一下我们了解到的有关 SQL 数据库中聚合函数的知识：

简而言之，聚合对多个文档中的值进行分组并以某种方式进行汇总。

想象一下，如果我们在 recordBook 集合中有男女学生，而我们希望每个学生都有总数。为了获得男生和女生的总和，我们可以使用 $group 聚合函数。

db.recordBook.aggregate([
  {
    $group : {_id : "$gender", result: {$sum: 1}}
  }  
]);

总结

我们讨论了 MongoDB 基础，将来构建应用程序时可能需要用到。希望你喜欢这篇文章。谢谢阅读！

如果你对此教程有任何疑问，请随时在下面的评论部分中进行评论，或者在 Facebook 或 Twitter 或 Instagram 上与我联系。

下篇再见！ ❤️✌

原文：How to get started with MongoDB in 10 minutes，作者：Navindu Jayatilake

创建一个 MongoDB Atlas 账号

MongoDB Atlas 是一个 MongoDB 数据库即服务平台，可以为你配置和托管数据库。然后，你唯一需要做的就是将数据上传到数据库。

• 在这里注册一个新的 MongoDB Atlas 账号。
• 在注册表格中填写你的信息，然后点击 Sign up（注册）。

创建一个新的集群

• 在下一页填写你的组织名称、项目名称，选择 JavaScript 作为你的首选编程语言，然后点击绿色的 Continue（继续）按钮。
• 点击共享集群下的 Create a cluster（创建集群）按钮。这应该是唯一的免费选项。
• 在 Cloud Provider & Region（云提供商和区域）下拉列表中，将其保留为默认值（通常为 AWS）。
• 在 Cluster Tier（集群计划）下拉列表中，将其保留为默认值：M0 Sandbox (Shared RAM, 512 MB Storage)。
• 在 Cluster Name（集群名称）下拉列表中，你可以为集群命名，也可以将其保留为默认名称 Cluster 0。
• 点击屏幕底部的绿色 Create Cluster（创建集群）按钮。
• 现在，你应该看到消息 Your cluster is being created. New clusters take between 1-3 minutes to provision.（正在创建集群，新集群需要 1-3 分钟的时间进行配置）。等待集群创建完成，然后再进行下一步。

为数据库创建一个新用户

• 在屏幕的左侧，点击 Database Access（数据库访问）。
• 点击绿色的 Add New Database User（添加新的数据库用户）按钮。
• 输入新的用户名和密码。
• 在 Database User Privileges（数据库用户权限）下，将此保留为默认选项，即 Read and write to any database（读写任何数据库）。
• 点击 Add User（添加用户）按钮以创建你的新用户。

允许所有 IP 地址访问

• 在屏幕的左侧，点击 Network Access（网络访问）。
• 点击绿色的 Add IP Address（添加 IP 地址）按钮。
• 点击 ALLOW ACCESS FROM ANYWHERE（允许从任何地方访问）按钮。你应该在 Access List Entry（访问列表）输入字段中看到 0.0.0.0/0。
• 点击绿色的 Confirm（确认）按钮。

连接到你的集群

• 点击屏幕左下方绿色的 Get Started（开始）按钮，现在应该显示最后一步，即 Connect to your cluster（连接到你的集群），点击它。
• 在屏幕的左侧，点击 Clusters（集群）。
• 单击集群的 Connect（连接）按钮。
• 在弹出框中，单击 Connect your application（连接你的应用程序）。
• 你应该会看到类似于以下内容的 URI，用于连接你的数据库：mongodb+srv://<username>:<password>@<cluster-name>.mongodb.net/<db-name>?retryWrites=true&w=majority。
• 单击 Copy（复制）按钮，将 URI 复制到剪贴板。

请注意，你复制的 URI 的 <username>、<cluster-name>、和 <db-name>字段已经为你填写好。你需要做的就是将 <password> 字段替换为你在上一步中创建的字段。

就是这样——你现在有了 URI，可以将其添加到你的应用程序，并连接到数据库。请妥善保存这个 URI，以便以后使用。

原文：MongoDB Atlas Tutorial – How to Get Started

高可用 API 有如下衡量标准：

• 速度（API 响应时间）
• 文档（清晰简洁的文档，能够很好的描述 API）
• 架构和持续性（代码可维护可扩展）

这篇教程我们将要通过 Node.js、MongoDB、Fastify 和 Swagger 搭建高可用后端架构。

源代码已经托管到了 GitHub 3 上。

开始之前

你应该具有初级\中极 JavaScript 知识，了解 Node.js 和 MongoDB，知道什么是 REST APIS。

下面是相关链接：

• JavaScript 2
• Node.js 1
• MongoDB 1
• REST APIS 3

涉及的技术

• Fastify 3
• Mongoose
• Swagger 1

可以在标签页中打开这些链接，随时查阅。

需要安装的环境：

• NodeJS/NPM
• MongoDB
• Postman

除此之外，还需要 IDE 和 终端，我在 Mac 用的是 iTerm2 ，在 Windows 上用的是 Hyper。

让我们开始吧

打开终端初始化项目，执行下面的代码：

mkdir fastify-api
cd fastify-api
mkdir src
cd src
touch index.js
npm init

上面的代码，创建了两个新目录，然后切换到了新建的路径下，创建了一个 index.js 文件并通过 npm 初始化项目。

在初始化新项目的时候会提示输入一些值，这些值可以留空在稍后更新。

完成后，src 目录下生成了 package.json。在这个文件里你可以更改工程初始化时留空的值。

接下来安装将要用到的所有的依赖库：

npm i nodemon mongoose fastify fastify-swagger boom

下面是在它们的官网引用的介绍：

nodemon

nodemon 是 node.js 应用的开发工具，当检测到目录下的文件改变时它会自动重启 node 应用。

使用 nodemon 不需要更改代码，它是 node 命令的封装，直接在执行脚本的时候用 nodemon替换 node 即可。

把下面的代码添加到 package.json 文件里来使用 nodemon：

"start": "./node_modules/nodemon/bin/nodemon.js ./src/index.js"

这时 package.json 文件应该这样：

{
  "name": "fastify-api",
  "version": "1.0.0",
  "description": "A blazing fast REST APIs with Node.js, MongoDB, Fastify and Swagger.",
  "main": "index.js",
  "scripts": {
  "start": "./node_modules/nodemon/bin/nodemon.js ./src/index.js",
  "test": "echo \"Error: no test specified\" && exit 1"
},
  "author": "Siegfried Grimbeek <siegfried.grimbeek@gmail.com> (www.siegfriedgrimbeek.co.za)",
  "license": "ISC",
  "dependencies": {
  "boom": "^7.2.2",
  "fastify": "^1.13.0",
  "fastify-swagger": "^0.15.3",
  "mongoose": "^5.3.14",
  "nodemon": "^1.18.7"
  }
}

mongoose

Mongoose 提供了一个直截了当、基于 schema 的应用数据 model 解决方案。它包括了内置类型转换、校验、构建查询、业务逻辑钩子等功能，可直接使用。

fastify 3

Fastify 是一个高度专注于以最少的开销和强大的插件架构提供最佳开发者体验的 web 框架。Fastify 受到Hapi 和 Express 的启发，是目前最快的 web 框架之一。

fastify-swagger 1

Swagger 1 文档生成器速度很快。它通过 routes 里声明的 schema 生成符合 swagger 规范的文档。

boom

boom 提供一个返回 HTTP 错误的工具集。

启动服务开始创建第一个路由

在 index.js 里添加如下代码：

// Require the framework and instantiate it
const fastify = require('fastify')({
  logger: true
})

// Declare a route
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
})

// Run the server!
const start = async () => {
  try {
    await fastify.listen(3000)
    fastify.log.info(`server listening on ${fastify.server.address().port}`)
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()

在这里引入了 Fastify 框架，声明了第一个 route 并在 port 3000 上启动了服务，代码很容易理解但是要注意初始化 Fastify 时传入了可选的对象：

// Require the fastify framework and instantiate it
const fastify = require('fastify')({
  logger: true
})

上面的代码开启了默认关闭的 Fastify 内置日志功能。

在终端的 src 目录下运行下面的代码：

npm start

浏览器访问 http://localhost:3000/ 会看到 {hello:world}。

回到 index.js 开始配置数据库。

启动 MongoDB 创建 model

安装 MongoDB，打开终端运行以下命令启动 MongoDB。

mongod

在 MongoDB 里不需要手动创建数据库。只需要在配置的时候指定数据库名，当数据存储的时候， MongoDB 会自动创建数据库。

在 index.js 里添加如下代码：

...
// Require external modules
const mongoose = require('mongoose')
// Connect to DB
mongoose.connect(‘mongodb://localhost/mycargarage’)
 .then(() => console.log(‘MongoDB connected…’))
 .catch(err => console.log(err))
...

在上面的代码里我们引入了 Mongoose 来连接 MongoDB 数据库。数据库名是 mycargarage，如果一切顺利，在终端里会看到 MongoDB connected...。

注意不需要手动重启 app，因为我们之前添加了 Nodemon 库。

现在数据库已经运行，可以创建第一个 Model 了。在 src 路径下创建一个名为 models 的新文件夹，在里面创建一个 Car.js 文件，添加如下代码：

// External Dependancies
const mongoose = require('mongoose')

const carSchema = new mongoose.Schema({
  title: String,
  brand: String,
  price: String,
  age: Number,
  services: {
    type: Map,
    of: String
  }
})

module.exports = mongoose.model('Car', carSchema)

上面的代码声明的 carSchema 包含了和 cars 相关的所有信息。除了两个基本数据类型: String和 Number。还用到了相对比较陌生的 Map，可以在这里 2阅读更多。接着导出了 carSchema，以便在 app 里使用。

也可以把 routes、controllers 和 config 的代码都放到 index.js 文件里，但是为了代码可维护，这里每个组件都有它自己的文件夹。

创建 car controller

在 src 下创建 controllers 文件夹，在文件夹里创建 carController.js 文件：

// External Dependancies
const boom = require('boom')

// Get Data Models
const Car = require('../models/Car')

// Get all cars
exports.getCars = async (req, reply) => {
  try {
    const cars = await Car.find()
    return cars
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Get single car by ID
exports.getSingleCar = async (req, reply) => {
  try {
    const id = req.params.id
    const car = await Car.findById(id)
    return car
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Add a new car
exports.addCar = async (req, reply) => {
  try {
    const car = new Car(req.body)
    return car.save()
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Update an existing car
exports.updateCar = async (req, reply) => {
  try {
    const id = req.params.id
    const car = req.body
    const { ...updateData } = car
    const update = await Car.findByIdAndUpdate(id, updateData, { new: true })
    return update
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Delete a car
exports.deleteCar = async (req, reply) => {
  try {
    const id = req.params.id
    const car = await Car.findByIdAndRemove(id)
    return car
  } catch (err) {
    throw boom.boomify(err)
  }
}

carController.js

代码看起来有点长，其实很简单。

• 引入了 boom 来处理错误：boom.boomify(err)。
• 导出了所有的函数以便在 route 里引入。
• 每个函数都是异步的，使用了 await 表达式，这样在执行异步函数的时会候暂停运行直到程序调用传入的 Promise 的 resolve，然后继续异步函数的执行并返回 resolved 值。点击点解更多
• 每个函数代码都在 try/catch 语句里。点击了解更多
• 每个函数都有两个参数：req (request) 和 reply。教程里只用到了 request 参数，用来访问 request body、 参数以及处理数据。点击了解更多

注意代码 31 行：

const car = new Car({ …req.body })

用到了扩展运算符。点击了解更多

注意代码 42 行：

const { …updateData } = car

使用了 JavaScript 解构赋值和扩展运算符。点击了解更多

另外，代码还用到了一些标准的 Mongoose 方法来操作数据库。

可能你已经迫不及待的想要运行你的 API 测试一下了，但是在开始之前，还需要把 controller 连接到 routes，把 routes 连接到 app 上。

创建导入 routes

同样，在项目根目录下创建 routes 文件夹。在文件夹内创建 index.js 文件，文件代码如下：

// Import our Controllers
const carController = require('../controllers/carController')

const routes = [
  {
    method: 'GET',
    url: '/api/cars',
    handler: carController.getCars
  },
  {
    method: 'GET',
    url: '/api/cars/:id',
    handler: carController.getSingleCar
  },
  {
    method: 'POST',
    url: '/api/cars',
    handler: carController.addCar,
    // schema: documentation.addCarSchema
  },
  {
    method: 'PUT',
    url: '/api/cars/:id',
    handler: carController.updateCar
  },
  {
    method: 'DELETE',
    url: '/api/cars/:id',
    handler: carController.deleteCar
  }
]

module.exports = routes

在这里我们引入了 controller 并且把每个函数分发到了相应的 routes 上。

每个 route 都是由 method、url、和 handler 组成，访问路由会调用相应 app 函数。

上面 routes 里出现的的 :id 是向路由里传递参数的一个常见做法，它允许以下面这种形式传入 id：

http://127.0.0.1:3000/api/cars/5bfe30b46fe410e1cfff2323

文件建立关联，测试 API

现在大部分功能都已完成，需要做的只是把他们连接起来，启动 API 服务。导入 routes，在 index.js 文件里添加如下代码：

const routes = require(‘./routes’)

接下来需要遍历 routes 数组，然后在 Fastify 里面初始化。可以用下面的代码实现，、在 index.js 文件里添加：

routes.forEach((route, index) => {
 fastify.route(route)
})

现在准备好测试了！

API 测试有一个很棒的工具 Postman。我们在request 的 body 里以 raw object 做为参数。

查询所有 cars:

查询指定 car：

添加新 car：

services 看起来是空的，实际上数据已经添加到了数据库里了

更新 car：

删除 car：

现在一个全功能 API 已具备，还差文档，别怕，用 Swagger 可以方便的生成。

添加 Swagger

现在创建 config 文件夹。在里面创建 swagger.js 文件，文件代码如下：

exports.options = {
  routePrefix: '/documentation',
  exposeRoute: true,
  swagger: {
    info: {
      title: 'Fastify API',
      description: 'Building a blazing fast REST API with Node.js, MongoDB, Fastify and Swagger',
      version: '1.0.0'
    },
    externalDocs: {
      url: 'https://swagger.io',
      description: 'Find more info here'
    },
    host: 'localhost',
    schemes: ['http'],
    consumes: ['application/json'],
    produces: ['application/json']
  }
}

上面的代码是将要传入到 fastify-swagger 插件的 option object，在index.js 里添加如下代码：

// Import Swagger Options
const swagger = require(‘./config/swagger’)
// Register Swagger
fastify.register(require(‘fastify-swagger’), swagger.options)

在启动服务之后还需要添加如下代码：

...
await fastify.listen(3000)
fastify.swagger()
fastify.log.info(`listening on ${fastify.server.address().port}`)
...

如果一切顺利访问 http://localhost:3000/documentation，效果如下：

是不是很简单？现在有了随着 API 自动更新的文档，可以任意在 routes 里面添加信息了点击此处阅读更多

接下来

现在基本 API 已经成型，可以扩展成能想象的任何应用，有一万种可能。

接下在的教程里，我们将要集成 GraphQL，最后会集成前端的 Vue.js。

原文链接：How to build blazing fast REST APIs with Node.js, MongoDB, Fastify and Swagger，作者：Siegfried Grimbeek

用这个地址生成的二维码也是密密麻麻，虽不影响微信长按扫码，一旦二维码尺寸缩一点点，图片马上就会糊掉，导致摄像头直接扫码会难以识别。

那这种情况下， 我们自然就会想到如果使用短链接减少url的字符，生成的码自然就会变得容易识别了，同时还会使url更美观且易于转发。现在市面上可用的就是微博的t.cn和一些第三方的生成短链接工具，但这两类工具都有一些使用上的问题，例如：t.cn现在的规则是会出现一个中转页不会直接跳转，而第三方的工具因为是一个公共平台，有时可能会因一些不良信息导致整个平台无法访问。

那与其这样，不如我们自己来实现一个短链接平台吧，实现一个短链接平台原理上也非常简单，搞定两部分就行了：1.保存长短链接的对应关系。2.通过短链接查询长连接并重定向。

为了高效，我这使用的是node和mongodb，下面我们就来开始动手吧。

首先，我们先创建一个express工程：

express -e demo

   change directory:
     > cd demo

   install dependencies:
     > npm install

   run the app:
     > SET DEBUG=demo:* & npm start

然后进入demo目录并安装express必要依赖：

npm install

同时通过 npm 安装我们需要用到的 mongoose 和 shortid 和 body-parser：

npm install mongoose
npm install shortid
npm install body-parser

下面分别对使用到的这三个包简单说明一下：

• 在这个应用中，我们使用了 mongodb，之所以选择它是因为执行高效且低开销，所以执行起来也很高效，不过如果使用其他数据库也是没问题的。这里的mongoose就是npm的一个包，主要是为程序提供连接mongodb并增删查改的功能。
• 通过使用shortid可以生成一个指定字符不重复的编码，便于我们生成类似xxx.com/ngTsfdgh 类似红字部分的编码。
• 由于我们生成短链接部分的api使用的是post方法，使用body-parser可以多扩展一种body编码类型解析能力。

首先设置MongoDB的连接信息

module.exports = {
    mongo_base_connection_url: 'mongodb://localhost:27017',
    mongo_db: 'mongodb://localhost:27017/shorturl',
    mongo_options: {
        autoReconnect: true,
        keepAlive: true,
        reconnectTries: 50,
        reconnectInterval: 1000,
        connectTimeoutMS: 5000000,
    }
}
console.log("Connection local mongo db");

数据库模型定义

因为我们的对应关系是需要通过短链接查询长连接，所以这里我们主要以存储短链接和长连接为主，另外大家也可以根据自己需要添加链接点击统计之类的字段，方便后期统计。

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
 
var urlSchema = new Schema({
  shortUrl: String,
  longUrl: String
});
 
module.exports = mongoose.model('UrlTable', urlSchema);

定义express路由

因为这个应用我们只有生成和Redirect两个功能，所以这里只有两个页面即可完成所有工作。

var index = require('./routes/index');
var url = require('./routes/url');
app.use('/', index);
app.use('/url', url);

生成短链接页面

const express = require("express");
const router = express.Router();
const shortId = require('shortid');
const UrlTable = require('../models/urltable');
const mongoose = require('mongoose');
var setup = require('../dbconfig/db');
 
router.post('/', function(req, res, next) {
    var params = req.body;
    var url = params.longUrl;
shortId.characters(' 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ^*')
    var shortid = shortId.generate();
    var objurl = { shortUrl: shortid, longUrl: url};
    mongoose.connect(setup.mongo_db, setup.mongo_options);
    UrlTable.create(objurl, function (err, objurl) {
      //if (err) console.log(err);
      res.send("http://localhost:3000/" + shortid);
    });
    return;
});

指定生成 shortId 字符的范围并生成：

shortId.characters('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')

var shortid = shortId.generate();

为数据库构建符合要求的数据模型：

var objurl = { shortUrl: shortid, longUrl: url};

最后，连接数据库并保存后将短链接结果返回客户端：

mongoose.connect(setup.mongo_db, setup.mongo_options);
UrlTable.create(objurl, function (err, objurl) {
//if (err) console.log(err);
res.send("http://localhost:3000/" + shortid);
});

短链接跳转页面

const express = require("express");
const router = express.Router();
const UrlTable = require('../models/urltable');
const mongoose = require('mongoose');
var setup = require('../dbconfig/db');
 
router.get('/:shortUrl', function (req, res, next) {
    var shortUrl = req.params.shortUrl;
    mongoose.connect(setup.mongo_db, setup.mongo_options);
    UrlTable.findOne({ shortUrl:shortUrl }).then((result) => {
       //待添加错误处理
    res.redirect(result.longUrl);
    })
});
 
module.exports = router;

这个页面为了便于快速跳转，我们就使用get接收参数，这个页面功能就很简单了，接参查询并跳转。

接收短链接码：

var shortUrl = req.params.shortUrl;

连接数据库查询并跳转：

mongoose.connect(setup.mongo_db, setup.mongo_options);

    UrlTable.findOne({ shortUrl:shortUrl }).then((result) => {

           //待添加错误处理

      res.redirect(result.longUrl);

 })

后期大家可以对一些错误异常处理，数据统计等做一些增强，这里就不做补充了。

下面让我们启用应用开始测试吧。

启动应用并测试

npm start

启动后，默认的访问端口为3000，我们首先测试下短链接生成页，这里我们post一个名为longUrl的长链接参数，数据对象为：

{"longUrl" : "https://demo.grapecity.com.cn/spreadjs/SpreadJSTutorial/features/tables/basic-table/purejs"}

成功升成了如下短链接：

http://localhost:3000/iGE6ZlDmh

我们只要通过访问短链接能正常跳转至保存的长连接即可。

这样就测试通过了，其实代码量不大，原理也很简单。大家如果自己有较短的域名的话，上线后会让链接变得更短、更美观，这样一个属于我们自己短链接生成平台就开发完成了。下面附上源码，执行npm install 即可自动安装所有依赖，如果大家有问题，可通过评论区告诉我。

源码下载>>

我们在葡萄城官网发布更多文章，欢迎阅读！