Hướng dẫn is mongoose a part of mongodb? - mongoose có phải là một phần của mongodb không?

bởi Nick Karnik

Mongoose là thư viện mô hình dữ liệu đối tượng (ODM) cho MongoDB và Node.js. Nó quản lý mối quan hệ giữa dữ liệu, cung cấp xác thực lược đồ và được sử dụng để dịch giữa các đối tượng trong mã và biểu diễn của các đối tượng đó trong MongoDB.

MongoDB là một cơ sở dữ liệu tài liệu NoQuery không có lược đồ. Điều đó có nghĩa là bạn có thể lưu trữ các tài liệu JSON trong đó và cấu trúc của các tài liệu này có thể thay đổi vì nó không được thực thi như cơ sở dữ liệu SQL. Đây là một trong những lợi thế của việc sử dụng NoQuery vì nó tăng tốc độ phát triển ứng dụng và giảm sự phức tạp của việc triển khai.

Dưới đây là một ví dụ về cách dữ liệu được lưu trữ trong cơ sở dữ liệu Mongo so với SQL:

Thuật ngữ

Bộ sưu tập

Bộ sưu tập trên Mongo tương đương với các bảng trong cơ sở dữ liệu quan hệ. Họ có thể giữ nhiều tài liệu JSON.

Các tài liệu

‘Tài liệu, tương đương với các bản ghi hoặc hàng dữ liệu trong SQL. Trong khi một hàng SQL có thể tham chiếu dữ liệu trong các bảng khác, các tài liệu Mongo thường kết hợp nó trong một tài liệu.

Lĩnh vực

Các trường, các thuộc tính hoặc các thuộc tính tương tự như các cột trong bảng SQL.

Lược đồ

Trong khi Mongo không có lược đồ, SQL định nghĩa một lược đồ thông qua định nghĩa bảng. Một clowoose ‘lược đồ là một cấu trúc dữ liệu tài liệu (hoặc hình dạng của tài liệu) được thực thi thông qua lớp ứng dụng.

Mô hình

Các mô hình, là các hàm tạo bậc cao hơn lấy lược đồ và tạo một thể hiện tài liệu tương đương với các bản ghi trong cơ sở dữ liệu quan hệ.

Bắt đầu

Cài đặt Mongo

Trước khi chúng tôi bắt đầu, hãy để Cài đặt Mongo. Bạn có thể chọn từ một trong các tùy chọn sau (chúng tôi đang sử dụng tùy chọn số 1 cho bài viết này):one of the following options (we are using option #1 for this article):

1. Tải xuống phiên bản MongoDB phù hợp cho hệ điều hành của bạn từ trang web MongoDB và làm theo hướng dẫn cài đặt của họ
2. Tạo đăng ký cơ sở dữ liệu hộp cát miễn phí trên MLAB
3. Cài đặt Mongo bằng Docker nếu bạn thích sử dụng Docker

Hãy để điều hướng thông qua một số điều cơ bản của Mongoose bằng cách triển khai một mô hình đại diện cho dữ liệu cho một cuốn sách địa chỉ đơn giản hóa.

Tôi đang sử dụng mã Visual Studio, Node 8.9 và NPM 5.6. Bắn lên IDE yêu thích của bạn, tạo một dự án trống và để bắt đầu! Chúng tôi sẽ sử dụng cú pháp ES6 giới hạn trong nút, vì vậy chúng tôi đã giành được cấu hình Babel.

Cài đặt NPM

Hãy cùng đi đến thư mục dự án và khởi tạo dự án của chúng tôi

npm init -y

Hãy để cài đặt Mongoose và thư viện xác thực với lệnh sau:

npm install mongoose validator

Lệnh cài đặt ở trên sẽ cài đặt phiên bản mới nhất của thư viện. Cú pháp Mongoose trong bài viết này là đặc trưng cho Mongoose V5 và hơn thế nữa.

Kết nối cơ sở dữ liệu

Tạo một tập tin

let mongoose = require('mongoose')

Tiếp theo, chúng tôi sẽ thêm một lớp đơn giản với một phương thức kết nối với cơ sở dữ liệu.

Chuỗi kết nối của bạn sẽ thay đổi dựa trên cài đặt của bạn.

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

let mongoose = require('mongoose')

let mongoose = require('mongoose')

let mongoose = require('mongoose')

Tương tự, chúng tôi đã biến lớp cơ sở dữ liệu của chúng tôi thành một singleton bằng cách trả về một thể hiện của lớp trong câu lệnh

let mongoose = require('mongoose')

ES6 giúp chúng tôi rất dễ dàng tạo mẫu singleton (một thể hiện đơn) vì cách trình tải mô -đun hoạt động bằng cách lưu trữ phản hồi của tệp đã nhập trước đó.

Lược đồ Mongoose so với mô hình

Một mô hình Mongoose là một trình bao bọc trong lược đồ Mongoose. Lược đồ Mongoose xác định cấu trúc của tài liệu, giá trị mặc định, trình xác nhận, v.v., trong khi mô hình Mongoose cung cấp một giao diện cho cơ sở dữ liệu để tạo, truy vấn, cập nhật, xóa bản ghi, v.v.

Tạo một mô hình Mongoose bao gồm chủ yếu gồm ba phần:

1. Tham khảo Mongoose

let mongoose = require('mongoose')

Tham chiếu này sẽ giống như cái được trả về khi chúng tôi kết nối với cơ sở dữ liệu, điều đó có nghĩa là các định nghĩa lược đồ và mô hình sẽ không cần kết nối rõ ràng với cơ sở dữ liệu.

2. Xác định lược đồ

Lược đồ xác định các thuộc tính tài liệu thông qua một đối tượng trong đó tên khóa tương ứng với tên thuộc tính trong bộ sưu tập.

let emailSchema = new mongoose.Schema({
  email: String
})

Ở đây chúng tôi xác định một thuộc tính có tên là email có chuỗi loại lược đồ ánh xạ vào trình xác nhận nội bộ sẽ được kích hoạt khi mô hình được lưu vào cơ sở dữ liệu. Nó sẽ thất bại nếu loại dữ liệu của giá trị không phải là loại chuỗi.email with a schema type String which maps to an internal validator that will be triggered when the model is saved to the database. It will fail if the data type of the value is not a string type.

Các loại lược đồ sau đây được cho phép:

• Mảng
• Boolean
• Đệm
• Ngày
• Hỗn hợp (một loại dữ liệu chung / linh hoạt)
• Con số
• ID đối tượng
• Sợi dây

Hỗn hợp và Objectid được xác định theo

let mongoose = require('mongoose')

3. Xuất một mô hình

Chúng ta cần gọi hàm tạo mô hình trên thể hiện Mongoose và chuyển tên của bộ sưu tập và tham chiếu đến định nghĩa lược đồ.

module.exports = mongoose.model('Email', emailSchema)

Hãy để kết hợp mã trên vào

let mongoose = require('mongoose')

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

Một định nghĩa lược đồ phải đơn giản, nhưng sự phức tạp của nó thường dựa trên các yêu cầu ứng dụng. Các lược đồ có thể được tái sử dụng và chúng cũng có thể chứa một số trường học trẻ em. Trong ví dụ trên, giá trị của thuộc tính email là một loại giá trị đơn giản. Tuy nhiên, nó cũng có thể là một loại đối tượng với các thuộc tính bổ sung trên đó.

Chúng ta có thể tạo một thể hiện của mô hình mà chúng ta đã xác định ở trên và điền vào nó bằng cú pháp sau:

let EmailModel = require('./email')

let msg = new EmailModel({
  email: ''
})

Hãy để nâng cao lược đồ email để làm cho thuộc tính email trở thành một trường duy nhất, bắt buộc và chuyển đổi giá trị thành chữ thường trước khi lưu nó. Chúng tôi cũng có thể thêm một chức năng xác thực sẽ đảm bảo rằng giá trị là địa chỉ email hợp lệ. Chúng tôi sẽ tham khảo và sử dụng thư viện Trình xác thực được cài đặt trước đó.

let mongoose = require('mongoose')
let validator = require('validator')

let emailSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    validate: (value) => {
      return validator.isEmail(value)
    }
  }
})

module.exports = mongoose.model('Email', emailSchema)

Hoạt động cơ bản

Mongoose có API linh hoạt và cung cấp nhiều cách để hoàn thành một nhiệm vụ. Chúng tôi sẽ không tập trung vào các biến thể vì đó là phạm vi cho bài viết này, nhưng hãy nhớ rằng hầu hết các hoạt động có thể được thực hiện theo nhiều cách về mặt cú pháp hoặc thông qua kiến ​​trúc ứng dụng.

Tạo bản ghi

Hãy để tạo một thể hiện của mô hình email và lưu nó vào cơ sở dữ liệu:

let EmailModel = require('./email')

let msg = new EmailModel({
  email: ''
})

msg.save()
   .then(doc => {
     console.log(doc)
   })
   .catch(err => {
     console.error(err)
   })

Kết quả là một tài liệu được trả lại khi lưu thành công:

npm install mongoose validator

Các trường sau được trả về (các trường nội bộ được đặt trước với một dấu gạch dưới):

1. Trường

   let mongoose = require('mongoose')

   7 được Mongo tạo tự động và là chìa khóa chính của bộ sưu tập. Giá trị của nó là một định danh duy nhất cho tài liệu.
2. Giá trị của trường

   let mongoose = require('mongoose')

   8 được trả về. Lưu ý rằng nó có hàm lượng thấp hơn vì chúng tôi đã chỉ định thuộc tính

   let mongoose = require('mongoose')

   9 trong lược đồ.

3. let emailSchema = new mongoose.Schema({
     email: String
   })

   0 là thuộc tính phiên bản phiên bản được đặt trên mỗi tài liệu khi được tạo bởi Mongoose. Giá trị của nó chứa sửa đổi nội bộ của tài liệu.

Nếu bạn cố gắng lặp lại thao tác lưu ở trên, bạn sẽ gặp lỗi vì chúng tôi đã chỉ định rằng trường email phải là duy nhất.

Hồ sơ tìm nạp

Hãy để cố gắng lấy lại bản ghi mà chúng tôi đã lưu vào cơ sở dữ liệu trước đó. Lớp mô hình hiển thị một số phương thức tĩnh và thể hiện để thực hiện các hoạt động trên cơ sở dữ liệu. Bây giờ chúng tôi sẽ cố gắng tìm bản ghi mà chúng tôi đã tạo trước đây bằng phương thức Tìm và chuyển email làm thuật ngữ tìm kiếm.

npm install mongoose validator

Tài liệu được trả về sẽ tương tự như những gì được hiển thị khi chúng tôi tạo bản ghi:

npm install mongoose validator

Cập nhật hồ sơ

Hãy để sửa đổi bản ghi ở trên bằng cách thay đổi địa chỉ email và thêm một trường khác vào nó, tất cả trong một thao tác duy nhất. Vì lý do hiệu suất, Mongoose won đã trả lại tài liệu được cập nhật, vì vậy chúng tôi cần chuyển một tham số bổ sung để yêu cầu:

npm install mongoose validator

Tài liệu được trả về sẽ chứa email cập nhật:

npm install mongoose validator

Xóa hồ sơ

Chúng tôi sẽ sử dụng cuộc gọi

let emailSchema = new mongoose.Schema({
  email: String
})

npm install mongoose validator

Người trợ giúp

Chúng tôi đã xem xét một số chức năng cơ bản ở trên được gọi là CRUD (tạo, đọc, cập nhật, xóa), nhưng Mongoose cũng cung cấp khả năng định cấu hình một số loại phương thức và thuộc tính trợ giúp. Chúng có thể được sử dụng để đơn giản hóa hơn nữa làm việc với dữ liệu.

Hãy cùng tạo ra một lược đồ người dùng trong

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

npm install mongoose validator

Tài sản ảo

Một thuộc tính ảo không được tồn tại trong cơ sở dữ liệu. Chúng tôi có thể thêm nó vào lược đồ của chúng tôi như một người trợ giúp để có được và đặt các giá trị.

Hãy để tạo một thuộc tính ảo gọi là

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

npm install mongoose validator

Gọi lại cho GET và SET phải sử dụng từ khóa chức năng vì chúng ta cần truy cập mô hình thông qua

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

Bây giờ, chúng ta có thể đặt

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

let emailSchema = new mongoose.Schema({
  email: String
})

npm install mongoose validator

Mã trên sẽ xuất ra như sau:

npm install mongoose validator

Phương pháp thể hiện

Chúng ta có thể tạo các phương thức trợ giúp tùy chỉnh trên lược đồ và truy cập chúng thông qua thể hiện mô hình. Các phương pháp này sẽ có quyền truy cập vào đối tượng mô hình và chúng có thể được sử dụng khá sáng tạo. Chẳng hạn, chúng ta có thể tạo một phương thức để tìm tất cả những người có cùng tên với thể hiện hiện tại.

Trong ví dụ này, hãy để tạo ra một hàm để trả về tên viết tắt cho người dùng hiện tại. Hãy để thêm một phương thức trợ giúp tùy chỉnh được gọi là

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Phương pháp này sẽ có thể truy cập thông qua một thể hiện mô hình:

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Phương pháp tĩnh

Tương tự như các phương thức thể hiện, chúng ta có thể tạo các phương thức tĩnh trên lược đồ. Hãy để tạo ra một phương thức để truy xuất tất cả người dùng trong cơ sở dữ liệu:

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Gọi

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Thêm phiên bản và phương thức tĩnh là một cách tiếp cận tốt để thực hiện giao diện với các tương tác cơ sở dữ liệu trên các bộ sưu tập và bản ghi.

Phần mềm trung gian

Phần mềm trung gian là các chức năng chạy ở các giai đoạn cụ thể của đường ống. Mongoose hỗ trợ phần mềm trung gian cho các hoạt động sau:

• Tổng hợp
• Tài liệu
• Người mẫu
• Truy vấn

Chẳng hạn, các mô hình có chức năng

module.exports = mongoose.model('Email', emailSchema)

module.exports = mongoose.model('Email', emailSchema)

1. Loại sự kiện (‘init,‘ xác thực, ‘lưu,‘ loại bỏ,)
2. Một cuộc gọi lại được thực thi với phiên bản này tham chiếu phiên bản mô hìnhthis referencing the model instance

Hãy thử thử một ví dụ bằng cách thêm hai trường được gọi là

module.exports = mongoose.model('Email', emailSchema)

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Khi

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

Hãy để thêm một móc trước và đặt các giá trị cho

module.exports = mongoose.model('Email', emailSchema)

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Hãy để tạo và lưu mô hình của chúng tôi:

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Bạn sẽ thấy các giá trị cho

module.exports = mongoose.model('Email', emailSchema)

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

bổ sung

Giả sử rằng chúng tôi muốn theo dõi khi một bản ghi được tạo và cập nhật lần cuối trên mọi bộ sưu tập trong cơ sở dữ liệu của chúng tôi. Thay vì lặp lại quy trình trên, chúng tôi có thể tạo một plugin và áp dụng nó cho mọi lược đồ.

Hãy để tạo một tệp

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Để sử dụng plugin này, chúng tôi chỉ cần chuyển nó đến các lược đồ nên được cung cấp chức năng này:

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

Xây dựng truy vấn

Mongoose có một API rất phong phú, xử lý nhiều hoạt động phức tạp được MongoDB hỗ trợ. Hãy xem xét một truy vấn nơi chúng ta có thể tăng dần các thành phần truy vấn.

Trong ví dụ này, chúng tôi sẽ:

1. Tìm tất cả người dùng
2. Bỏ qua 100 bản ghi đầu tiên
3. Giới hạn kết quả ở 10 hồ sơ
4. Sắp xếp kết quả theo trường đầu tiên
5. Chọn FirstName
6. Thực hiện truy vấn đó

let mongoose = require('mongoose')

Đóng cửa

Chúng tôi hầu như không làm trầy xước bề mặt khám phá một số khả năng của Mongoose. Đó là một thư viện phong phú đầy đủ các tính năng hữu ích và mạnh mẽ làm cho nó trở thành niềm vui khi làm việc với các mô hình dữ liệu trong lớp ứng dụng.

Mặc dù bạn có thể tương tác với Mongo trực tiếp bằng Trình điều khiển Mongo, Mongoose sẽ đơn giản hóa sự tương tác đó bằng cách cho phép bạn mô hình hóa mối quan hệ giữa dữ liệu và xác nhận chúng một cách dễ dàng.

Sự thật thú vị: Mongoose được tạo ra bởi Valeri Karpovwho là một kỹ sư cực kỳ tài năng! Ông đặt ra thuật ngữ ngăn xếp trung bình. Mongoose is created by Valeri Karpov who is an incredibly talented engineer! He coined the term The MEAN Stack.

Nếu bài viết này hữu ích, ??? Và theo dõi tôi trên Twitter.