阅读 2160

细嚼慢咽 Mongoose 5

此文已由作者黄锴授权网易云社区发布。

欢迎访问网易云社区,了解更多网易技术产品运营经验。

前言

由于Mongoose一直没有中文文档,加上现在市面上充斥着太多“快速上手”,很多中文文档都只盲目介绍了Mongoose的API用法(但是现在升级后,很多API发生了变化),没有做详细介绍,导致很多人用了半天的Mongoose,还是对其一知半解(比如我!),因此写了这篇文章,从以下三个角度聊聊Mongoose。

  • 是什么(what?)

  • 为什么?(why?)

  • 怎么用(how?)

    • 快速上手

    • 再深一点(这才是细嚼慢咽的关键哦)

本文阅读可快,可慢全凭喜好。但本着贪多嚼不烂的想法,还是希望客观慢慢品尝。

是什么(what)?


首先,必须要知道Mongoose是什么

Mongoose(狐獴)就是图上这个小可爱。(学名:Suricata suricatta),头尾长42-60厘米,是一种小型的哺乳动物……

好像有点跑题。当然,今天介绍的Mongoose不是真的小动物,而是一款在Node.js环境下对MongoDB API 进行便捷操作的对象模型工具(所以理论上,我默认你是需要大概懂MongoDB数据库才会来用这个的)。

要特别强调的是,我这里说它是对象模型工具,说明Mongoose的操作是以对象为单位的。

同时,由于Mongoose升级后(差不多)全面支持Promise,可以很方便的对接async/await语法。因此接下来的我的代码都会默认使用Promise形式。

为什么(Why)?

我们知道,MongoDB官网提供了一个Node.js环境下的MongoAPI,那为什么我还需要使用Mongoose呢?当然是因为它提供了一些官方不能提供的功能,如它官网介绍的:

Let's face it, writing MongoDB validation, casting and business logic boilerplate is a drag.

可以看出,Mongoose主要是减轻我们在写数据验证,业务逻辑模板的负担。同时,由于Mongoose一直强调它是一个MongoDB对象建模工具,因此在这里就必须要提出Mongoose的核心,也是Mongoose困扰人已久的一个东西——模式和模型。

模式?模型?

对于Mongoose的新人来说,最头疼的就是它里面有关模式(Schema),模型(Model)的概念。Mongoose的一切都始于一个模式。这点和MongoDB基于集合(Collection)的思路可能不太一致,因为本身MongoDB是无模式的,也正是因为它的无模型,导致其使用起来极具灵活性。

那Mongoose为什么要定义一个模型?Why Define a Mongoose Schema? 给出了解释:

have you ever wondered how to pull these random documents out and figure out which properties were saved to document? The truth is that for 90% of your web applications you’ll be using model classes and you’ll have a standard set of fields you’ll be expecting to be saved to your database

模式有模式的好处,生活中绝大部分的数据是遵循一定的模式的,模式能让我们规范数据的表现形式,不至于太随心所欲。同时模式给我们提供了很多数据验证的便利(这就像我们讨论JavaScript弱类型和TypeScript强类型是一样一样的)。

同时,由于Mongoose使用的依然MongoDB而非关系型数据库,因此它没有完全失去其天生的灵活性,它依然开放了让你可以定义任意字段的能力。

// Defining a schema on a Mongoose model// that allows storage of arbitrary fields// Mongoose.schema(schemaObject, options)var User = Mongoose.schema({
  username: String,
  password: String}, {
  strict: false});复制代码

注意到上面代码的第二个字段,你把strict设置为false,你就能在这个模型中加入任意字段了(但是还是不建议这样做,因为这意味着你需要自己去做数据的验证)。

如果你实在不习惯使用 模式,可以使用MongoDB官方的API。

与其说Mongoose定义模式是多此一举的,不如说,它在灵活性的基础上,提供了更安全的模型化操作对象的方式。

我个人感觉:使用Mongoose你更有操作对象的感觉。

模式 VS 模型

我们已经知道了模式是有其优势的,那为什么我还需要模型?这两个有什么区别?

官方的定义:Each schema defines the shape of the documents within that collection.

模式

模式它是一个 抽象的概念。其实可以把模式考虑成设计规范 ,定义了设计图纸应该如何画,默认单位是多少,如果没有该规范,那每个人画的设计图纸就是各式各样,没法真正投入建造。


模型

模型相对于模式是具体的概念,可以把模型考虑成设计图纸 :按照设计规范画出一个图纸,任何人根据该规范就可以把房子造出来。

实例

而模型的实例才是真正的我们住的房子,在MongoDB里也就是文档(document)


多此一举?

你可能会说,何必多此一举,把模式和模型合起来不就好了嘛?很多人喜欢这样写:

const studentModel = Mongoose.model('Student', new Mongoose.Schema({ name: String, sex: String});复制代码

这样写也可以,但是这个前提是你确定你的模式只在这一个模型中使用。之所以有个模式这个抽象概念,就像设计规范, 它从来不是说只能在一张图纸中使用,你可以利用这个规范绘制出很多符合规范的图纸。

有时候你可能会有这样的需求,基本一样的数据结构,但是我需要建多个不同集合,或者稍微修改一下模式,新建一个新的集合,这时候把模式独立出来,你就会发现省事很多了。

const personSchema = new Mongoose.Schema({ name: String, sex: String});const studentModel = Mongoose.model('Student', personSchema);const otherStudentModel = Mongoose.model('OtherStudent', personSchema);const teacherSchema = personSchema.clone();
teacherSchema.add({ teach: String});const teacherModel = Mongoose.model('Teacher', teacherSchema);复制代码

举例

再来举一个例子:假设,我们建立了一个宠物猫咪乐园,我们需要去招集一批宠物喵成为我们的会员。但是呢,我们的宣传员他没见过喵(多么神奇的生物)。于是,我们绞尽脑汁,合计出一个规范:所有的宠物猫应该满足三个属性name,type, meow。也就是说,宠物喵必须要有名字,必须有一个品种,同时它必须要会“喵喵”叫!

const catSchema = new Mongoose.Schema({ name: String, type: String,meow: Boolean});复制代码

好了,现在我们把规范告诉他,但是他说他记性不好。怕忘记,因此我们制定了一个叫《宠物猫咪指南1.0》的手册

const CatGuide = Mongoose.model('Animal', catSchema);复制代码

好了,宣传员开心的出去了,开始到处撩猫去了,把所有它认为是猫的生物都记录下来:

const kitty1 = new CatGuide({ name: 'mimi', type: 'American Shorthair', meow: true });const kitty2 = new CatGuide({ name: 'kaddy', type: 'American Shorthair', meow: true });const doggy = new CatGuide({ name: 'doggy', type: 'Dog!!', meow: false });
……复制代码

(但是这个不靠谱的,拿着手册也能找错,找了一只穿猫咪衣服的狗!!?)


因此,我们只把那两只猫保存到数据库里。

kitty1.save().then(() => console.log('meow'));
kitty2.save().then(() => console.log('meow'));复制代码

知道了他们之间的关系,剩下的就好办了。就是编程了,编程能解决的事情都是简单的事情。

怎么用(How)?

快速开始

Mongoose的使用流程很简单:

连接 ——> 定义模式 ——> 生成Model ——> 生成Model实例复制代码

其中,连接,Model,实例是实际跟数据库打交道的,他们之间的关系如下:

通过一个很简单的例子,我们就可以上手操作MongoDB,然后配合官方API,熟练的人可以直接跳过了,但是如果你想了解更多细节,可以继续看下去,看看每个操作具体还可以怎么配置。

// step 1 引入Mongooseconst Mongoose = require('Mongoose');// setp2 建立连接Mongoose.connect('MongoDB://localhost/test');// step3 建立模式const catSchema = new Mongoose.Schema({ name: String, type: String });// step4 生成模型const Cat = Mongoose.model('Cat', catSchema);// step5.1 模型直接操作documentCat.create({ name: 'mimi', type: 'American Shorthair' }).then(...)// or
                                                              // step5.2 生成实例,操作documentconst kitty = new Cat({ name: 'mimi', type: 'American Shorthair' });
kitty.save().then(() => console.log('meow'));复制代码

连接

我们都知道,使用数据库的第一步是需要连上数据库,Mongoose提供了一个很简单的方式连接:connect。

Mongoose.connect(url, [options]);复制代码

注意,现在使用url需要加上 { useNewUrlParser: true }选项,否则可能会报错。 Mongoose.connect(url, { useNewUrlParser: true });

其中url参数的完整形式,跟MongoDB连接字符串的一致:MongoDB://username:password@host:port/database?options...

默认情况下,用户名和密码可以省略:

Mongoose.connect('MongoDB://localhost/db1');复制代码

如果还需要传递用户名、密码,则可以使用如下方式

Mongoose.connect('MongoDB://username:password@host:port/database?options...');复制代码

connect()方法还接受一个选项对象options,该对象将传递给底层驱动程序。这里所包含的所有选项优先于连接字符串中传递的选项:

  • bufferCommands : 这个选项会关闭Mongoose的缓存机制 ,再深一点章节会说。

  • user/pass :用户名和密码

  • autoIndex :通常MongoDB会自动生成索引,但是有时候如果你不需要,可以把这个选项设置为false

  • dbName :制定数据库名,一般是没办法在连接字符串中指定的情形( MongoDB+srv 语法连接到 MongoDB Atlas

还有一些选项是用来配置Mongoose的,例如,我之前说的useNewUrlParser ,还有 pooleSize, bufferMaxEntries,connectTimeoutMS, socketTimeoutMS…… 这些都是比较高级的配置,一般人用不到。如果真的需要用到,可以翻官方文档

模式

我们知道,模式其的是规范的作用,因此定义模式主要是定义我们数据的表现形式以及做一些格式约定,方便自动校验。例如,我创建了一个学生的模式,它规定了name和age字段的类型:

const studentSchema = new Mongoose.Schema({
  name: String,
  age: Number,
});复制代码

基本类型

模式有以下10种基本类型,如果只使用基本类型,就输入以下字段就行

  • String | Number | Date | Buffer | Boolean | Schema.Types.Mixed | Schema.Types.ObjectId | Array | Schema.Types.Decimal128 | Map(新加入的ES6的Map)

注意:1. 如果是Array,可以使用[]代替,你可以可以规定Array内部数据类型,例如数字数组: [Number]。2. 很多人困惑为什么没有Object类型,如果你想定义对象,使用Schema.Types.Mixed就行了。Mixed类型支持多种类型混合,比如数组套对象,对象套数组……

额外约束

但是,只规定了基本类型还不够,我想做一些额外的约束,比如姓名长度,年龄大小。因此每种类型还有很多配置项,如果要使用额外的约束,需要使用Object形式,同时,类型通过type引入:

const studentSchema = new Mongoose.Schema({
  name: { type: String, minlength: 2 },
  age: { type: Number, min: 12, max: 16},
});复制代码

这里只介绍一些比较常用的,更多使用说明参考官方手册

所有类型可用:

  • required: boolean or function, 很好理解,如果为真就表示该字段必须要存在

  • default: Any or function, 设置默认值

  • validate: function, 增加一个校验函数

字符串 String:

  • lowercase/upppercase: boolean, 是否做大小写处理

  • trim: boolean, 是否去除首尾空格

  • match: RegExp, 只有满足特定正则的值才能被接受

  • enum: Array, 只有数组内的值才被接受

  • minlength/ maxLength: Number, 最小、大长度

数字 Number / 日期 Date

  • min / max: Number / Date (根据类型),必须满足的最大值/最小值

注意: Date使用的是内置的Date,但是你使用setMonth等内置的方法,不会被Mongoose不会识别到,因此使用doc.save()不会有效果。你必须设置doc.markModified(pathToYourDate)。

const Assignment = Mongoose.model('Assignment', { name: String, dueDate: Date });const a = new Assignment({ name: 'test', dueDate: Date.now() });
a.save().then(callback);
Assignment.findOne({ name: 'test' }, 'name dueDate', (err, doc) => {
doc.dueDate.setMonth(3);
doc.save(callback); // THIS DOES NOT SAVE YOUR CHANGEdoc.markModified('dueDate');
doc.save(callback); // works});复制代码

模型

有了模式之后,就可以生成模型了,生成模型很简单,就使用model函数就行了。

// step3 建立模式const catSchema = new Mongoose.Schema({ name: String, type: String });// step4 生成模型const Cat = Mongoose.model('Cat', catSchema);复制代码

注意,虽然所有的例子都是Mongoose.model,但是实际上model是Connect原型的方法:Connection.prototype.model(),即一个连接实例才有model方法。(具体的可以看后面的 再深一点章节)

其中,model第一个参数就是collection名称(Mongoose会自动 复数化,想修改名称也请看后面章节),同时model会把Schema里的内容复制一份

官方原文是说复制一份

The .model() function makes a copy of schema. Make sure that you've added everything you want to schema before calling .model()!

但是我实际测试,感觉还是引用,在调用model方法之后,通过add(), remove()方法修改Schema依然会影响之前创建的model。

const catSchema = new Mongoose.Schema({ name: String, type: String });const Cat = Mongoose.model('Cat', catSchema);
catSchema.remove('type');   // 在创建model后修改Schema会影响之前的modelconst kitty = new Cat({ name: 'mimi2', type: 'American Shorthair' });
kitty.save().then(() => console.log('meow'));  // type字段不会存储到数据库复制代码

实例

根据之前的图可以知道,model的实例就是文档,有一些比较方便的操作方法,更多方法参考文档

get(path,opt) : 获取文档的某个字段,这个函数比较好的是做数据处理,第2个参数可以将该字段转换成其他类型:«Schema|String|Number|Buffer|*»

  doc.get('age') // 47

  // dynamic casting to a string
  doc.get('age', String) // "47"复制代码

save():顾名思义保存文档到数据库

var Tank = Mongoose.model('Tank', yourSchema);var small = new Tank({ size: 'small' });
small.save(function (err) {  if (err) return handleError(err);  // saved!});复制代码

set(path, value, opt) : 设置文档的某个字段,第三个参数依然可以修改字段类型,同时,可以设置{ strict: false }添加任意字段(回顾 为什么章节)

// 简单用法doc.set(path, value)// 对象形式用法,修改多个字段doc.set({
    path  : value
  , path2 : {
       path  : value
    }
})// 把value通过Number进行转换doc.set(path, value, Number)// 填加任意字段doc.set(path, value, { strict: false });复制代码

CRUD操作

由于对文档的操作通常是在"集合"这个维度,因此大部分的操作都是在model上完成的,除了一些单文档的操作可以在文档这个维度,通过实例完成

新增文档[s]

文档保存有三种方法,除了之前介绍的save方法,还可以使用模型的下面两种方法。

  • model.create(object) : 其实就是new model.save()的简写

  • model.insertMany([object]) : 可以批量增加,从内存写到数据库比较实用

区别就像实例的save是猫主人自己跑过来报名。create,insertMany就是我们工作人员替用户直接录入。

const catSchema = new Mongoose.Schema({ name: String, type: String });const Cat = Mongoose.model('Cat', catSchema);
Cat.create({ name: 'mimi', type: 'American Shorthair' }).then(...)  // 插入单条文档Cat.insertMany([{ name: 'mimi', type: 'American Shorthair' }...]).then(...)  // 插入多条文档复制代码

查找文档

Mongoose的查删改的使用方法基本大同小异,这里重点介绍一下查询,剩下的更新和删除主要介绍方法,不会具体介绍怎么使用

跟查询有关的方法有…一堆(ByID那一批我排除了,实际用途不大,很多时候我们都不知道文档的_id):

大部分都大同小意,然后findOne跟find的差别就是,一个是查询所有满足条件的文档,一个是只返回第一个,因此我这里只讲一个find的用法:

Modle.find.(conditions, [projection], [options], [callback] )复制代码
  • conditions «Object» : 查询条件(完全跟MongoDB手册一致)

  • [projection] «Object|String» : 选取字段,和下面的select方法完全一致(我推荐使用链式调用)

  • [options] «Object» : 查询配置(在再深一点章节再介绍)

  • [callback] «Function» : 推荐使用Promise写发,不写callback

一般来说,查找MongoDB中的某个文档,是需要一个查询条件(condition)的,这个查询条件可以简单可以复杂,由于完全跟MongoDB手册一致,本文毕竟不是《MongoDB入门》这里就不做过多叙述,如果后续有时间会把整理的MongoDB手册发上来, 下面的例子也会说明一些。

这里重点说一下Mongoose自身提供的一些比较使用的方法,这里举官方一个例子来说明一下:

通常一个标准的MongoDB的查询大概是这样(其中Person是一个model),Mongoose完全支持这种查询方式:

Person.
  find({    // 这里写查询条件
    occupation: /host/,   // 查询条件可以用正则
    'name.last': 'Ghost',   //  限定name.last 
    age: { $gt: 17, $lt: 66 },   // 限定年龄范围
    likes: { $in: ['vaporizing', 'talking'] }   // 限定喜好必须要在这个数组中
  }).
  limit(10).    // 限定取出的文档条数
  sort({ occupation: -1 }).  // 针对某个字段排序,1表示正序,-1表示逆序
  select({ name: 1, occupation: 1 }).  // 选择取出的字段,1表示取出,0表示不取出,如果不需要id,需要显式写{_id : 0}
  exec(callback);  // 这里使用then也行,完全支持Promise,但是查询不是Promise,这个要注意,后面会说复制代码

但是Mongoose把 常用的方法都提取出来了,例如:where,gt,lt,in……(完整API文档),因此更推荐使用下面这种方式:

// Using query builderPerson.
  find({ occupation: /host/ }).
  where('name.last').equals('Ghost').
  where('age').gt(17).lt(66).
  where('likes').in(['vaporizing', 'talking']).
  limit(10).
  sort('-occupation').
  select('name occupation').
  exec(callback);复制代码

要强调一下,查询支持promise一些语法,但是它不是promise。这个坑必须要记得!! 千万不要将callback形式和promise混用!

例如,下面的query可以执行三次!并不会因为一次then或者callback结束。 说明then只是一个执行方法,查询并不是真正的Promise。

const q = MyModel.updateMany({}, { isDeleted: true }, function() {  console.log('Update 1');
});
q.then(() => console.log('Update 2'));
q.then(() => console.log('Update 3'));复制代码

如果要统计查询的文档数据,可以使用countDocuments(),用法和MongoDB的count()一致

Person.find(...)
.count()
.then() // 这里获得的是一个数字复制代码

注意: Mongoose的count()已经被废弃,需要统计个数得用countDocuments

更新文档

更新文档的方法有下面三个,condition的使用方法和find的方法一完全一致(包括where那些查询方法都可以使用),只是要注意, update只是更新字段(符合Schema),但是replace是完全的用新doc来替换。

删除文档

删除文档主要是两个方法,使用方法完全和查询一致。

再深一点

细品连接

缓存机制

根据上面的例子,你会发现一个奇怪的现象, 我们并没有判断连接是否成功就进行了操作?这是因为Mongoose内部缓存了函数调用。

Mongoose lets you start using your models immediately, without waiting for Mongoose to establish a connection to MongoDB

这很cool,很方便,我们不用去关心连接成功再去增加文档,否则你必须要这样:

Mongoose
    .connect('MongoDB://localhost/test')
    .then(() => {        const catSchema = new Mongoose.Schema({ name: String, type: String });        const Cat = Mongoose.model('Cat', catSchema);        const kitty = new Cat({ name: 'mimi', type: 'American Shorthair' });
        kitty.save().then(() => console.log('meow'));
    })
    .catch(err => console.log(err));复制代码

但是这样会带来一个问题就是你如果不建立连接,进行操作也不会收到任何提示。

var MyModel = Mongoose.model('Test', new Schema({ name: String }));// Will just hang until Mongoose successfully connectsMyModel.findOne(function(error, result) { /* ... */ });

setTimeout(function() {
  Mongoose.connect('MongoDB://localhost:27017/myapp');
}, 60000);复制代码

所以一定要养成良好的喜欢,在做查询,删除等操作的时候,判断一下是否已经连接。判断连接可以使用下面提的 connection对象的连接状态码

connection对象

说实话,刚开始使用Mongoose的时候我总是充满疑惑,一开始我认为Mongoose应该是一个类,它代表一次连接,通过new的方式可以创建一个数据库的连接。但是Mongoose不是,它直接通过connect方法就创建了一个连接,就能直接操作数据库上的集合,那说明这个Mongoose只是一个实例(的确也是)。那如果Mongoose只是一个实例,它就等于那一个连接吗?那为什么Mongoose上面没有操作数据库的方法?而且我要如何创建多个连接呢?一个个问题在脑海中回荡,脑子里早已一团浆糊,于是,还是回到了官方文档找答案。

其实,每次执行Mongoose.connect,实际就是创建了一个Connection对象(这个对象可以通过Mongoose.connection获得)这个对象才是真正对应的一个数据库的连接。因此,所有的数据库操作其实都是在connect对象中,例如:createCollection()dropCollection(), dropDatabase() ……

这个connection对象同时可以监听几个常用事件:connected,disconnected,error。

const connection = Mongoose.connection;
connection.on('connected', () => {  console.log('Mongoose connection open');
  connection.createCollection('test').then(() => console.log('add collection')),
});复制代码

连接状态码

为了方便查看对象的状态,connection也提供了一个readyState属性,可以方便判断当前连接状态,通过Mongoose.STATES能获取readyState的所有取值:

{ '0': 'disconnected',
  '1': 'connected',
  '2': 'connecting',
  '3': 'disconnecting',
  '99': 'uninitialized',
  disconnected: 0,
  connected: 1,
  connecting: 2,
  disconnecting: 3,
  uninitialized: 99 }复制代码

所以,理论上你可以这样判断连接是否建立

if (Mongoose.STATES[connection.readyState] === 'connected') ....复制代码

多个连接

同时,如果你想创建多个连接,你可以使用Mongoose.createConnection()的方式创建一个新的连接,参数什么的和connect一致,剩下的操作一致。例如以下这个官方例子:

var Mongoose = require('Mongoose');var db = Mongoose.createConnection(..);
db.model('Venue', new Schema(..));var Ticket = db.model('Ticket', new Schema(..));var Venue = db.model('Venue');复制代码

细品模式

虚属性

虚属性(Virtuals)是Mongoose提供的一个很有用的功能,它可以方便我们存储一些不需要存储在数据库中的数据。例如,我存储一个用户的姓名,只需要存名和姓:

  const personSchema = new Schema({
    name: {
      first: String,
      last: String
    }
  });  const Person = Mongoose.model('Person', personSchema);  const voidsky = new Person({
    name: { first: 'void', last: 'sky' }
  });复制代码

但是我在读出的时候,需要打印用户的全名,当然我们可以这样做:

console.log(voidsky.name.first + ' ' + voidsky.name.last); // void sky复制代码

但是虚属性提供了一个更方便的方式:

personSchema.virtual('fullName').get(function () {  return this.name.first + ' ' + this.name.last;
});console.log(voidsky.fullName);复制代码

如果你用过一些前端框架,你可以把它当作计算属性。但是这个属性不会被持久化到MongoDB中,虚函数有get和set的方法,熟悉setter和getter的就应该知道,一样一样的。

虚属性还提供了一个很有用的Aliases字段,它可以把Schema的某个属性完全跟一个虚属性进行连接(set和get的绑定),你操作这两个属性的效果完全一致,这个好处是你可以在存储的时候节约空间,但是获取数据的时候,使用语义化的描述 。只是Aliases定义的属性不会被持久化到数据库。这里看官方案例:

const personSchema = new Schema({
  n: {
    type: String,
    alias: 'name'   // 注意这里,等于创建了一个name的虚属性,绑定到n
  }
});const Person = Mongoose.model(personSchema);const person = new Person({ name: 'Val' });console.log(person); // { n: 'Val' }console.log(person.toObject({ virtuals: true })); // { n: 'Val', name: 'Val' }console.log(person.name); // "Val"person.name = 'Not Val';console.log(person); // { n: 'Not Val' }复制代码

子模式

schema是可以嵌套的,如果我们需要定义一个复杂的结构,可以使用嵌套的方式(通常子模式会配置成{ _id: false },具体可以参考下面的模式配置)

const childSchema = new Schema({
  n: {
    type: String,
    alias: 'name'
  }
}, { _id: false });const parentSchema = new Schema({  // If in a child schema, alias doesn't need to include the full nested path
  c: childSchema,
  name: {
    f: {
      type: String,      // Alias needs to include the full nested path if declared inline
      alias: 'name.first'
    }
  }
});复制代码

模式配置

schema是有很多配置的,你可以在定义Schema的时候配置,或者使用set方法。

new Schema({..}, options);// orconst schema = new Schema({..});
schema.set(option, value);复制代码

相关配置可以参考文档,这里举例几个可能会用到的:

  • colleciton 这个配置可以修改collection的名字(默认是使用model的复数化名称,见下面)

const dataSchema = new Schema({..}, { collection: 'data' });const dataModel = Mongoose.model('othername', dataSchema);复制代码

模式方法

(未完待续)

额外推荐:可视化客户端

当然,你可以通过命令行查看结果,但是更多人还是习惯使用图形化的界面,这里推荐一个MongoDB的可视化客户端:robot 3T,这就是原来大名鼎鼎的RoboMongo。全平台都支持。要是之前我还真不想推荐它,因为在mac上显示实在难受,不支持retina屏幕。

但是现在,已经好了很多


免费体验云安全(易盾)内容安全、验证码等服务

更多网易技术、产品、运营经验分享请点击




相关文章:
【推荐】 Spring Cloud使用总结