点击阅读全文

大家好，本文是「使用 NodeJS 构建影院微服务」系列的第 三篇文章。此系列文章旨在展示如何使用 ES6，¿ES7 … 8?，和 expressjs 构建一个 API 应用，如何连接 MongoDB 集群，怎样将其部署于 docker 容器中，以及模拟微服务运行于云环境中的情况。

## 以往章节快速回顾

• 我们讲了什么是微服务，探讨了微服务的利与弊
• 我们定义了影院微服务架构
• 我们设计并实现了电影服务和影院目录服务
• 我们实现了这些服务的 API 接口，并对这些接口做了单元测试
• 我们对运行于Docker中的服务进行了集成测试
• 我们讨论了微服务安全并使其适配了 HTTP/2 协议
• 我们对影院目录服务进行了压力测试

如果你没有阅读之前的章节，那么很有可能会错一些有趣的东西 🤘🏽，下面我列出前两篇的链接，方便你有兴趣的话可以看一下👀。

• 用 NodeJS 打造影院微服务并部署到 docker 上 — Part 1
• 用 NodeJS 打造影院微服务并部署到 docker 上 — Part 2

在之前的章节中，我们已经完成了以下架构图中的上层部分，接着从本章起，我们要开始图中下层部分的开发了。

到目前为止，我们的终端用户已经能够在影院看到电影首映信息，选择影院并下单买票。本章我们会继续构建影院架构，并探索订票服务内部是如何工作的，跟我一起学点有趣的东西吧。

我们将使用到以下技术：

• NodeJS version 7.5.0
• MongoDB 3.4.1
• Docker for Mac 1.13

要跟上本文的进度有以下要求：

• 已经完成上一篇文章中的例子代码

如果你还没有完成这些代码，我已经将代码传到了 github 上，你可以直接使用代码库分支 step-2。

# NodeJS 中的依赖注入

至今为止我们已经构建了两套微服务的 API 接口，不过都没有遇到太多的配置和开发工作，这是由这些微服务自身的特性和简单性决定的。不过这一次，在订票服务中，我们会看到更多与其它服务之间的交互，因为这个服务的实现依赖项更多，为了防止写出一团乱麻似的代码，作为好的开发者，我们需要遵循某种设计模式，为此我们将会探究什么是**“依赖注入”**。

想要达成良好的设计模式，我们必须很好地理解并应用 S.O.L.I.D 原则，我之前写过一篇与之相关的 javascript 的文章，有空你可以看一下🤓，主要讲述了这些原则是什么并且我们可以从中获得哪些好处。

S.O.L.I.D The first 5 principles of Ojbect Oriented Design with Javascritp

为什么依赖注入如此重要？因为它能给我们带来以下开发模式中的三大好处：

• 解耦：依赖注入可减少模块之间的耦合性，使其更易于维护。
• 单元测试：使用依赖注入，可使对于每个模块的单元测试做得更好，代码的 bug 也会较少。
• 快速开发：利用依赖注入，在定义了接口之后，可以更加容易地进行分工合作而不会产生冲突。

至今为此开发的微服务中，我们曾在 index.js 文件中使用到了依赖注入

// more code
mediator.on(‘db.ready’, (db) => {
let rep
// here we are making DI to the repository
// we are injecting the database object and the ObjectID object
repository.connect({
db,
ObjectID: config.ObjectID
})
.then(repo => {
console.log(‘Connected. Starting Server’)
rep = repo
// here we are also making DI to the server
// we are injecting serverSettings and the repo object
return server.start({
port: config.serverSettings.port,
ssl: config.serverSettings.ssl,
repo
})
})
.then(app => {
console.log(Server started succesfully, running on port: ${config.serverSettings.port}.)
app.on(‘close’, () => {
rep.disconnect()
})
})
})
// more code

在 index.js 文件中我们使用了手动的依赖注入，因为没有必要做得更多。不过在订票服务中，我们将需要一种更好地依赖注入方式，为了厘清个中缘由，在开始构建 API 接口之前，我们要先弄清楚订票服务需要完成哪些任务。

• 订票服务需要一个订票对象和一个用户对象，而且在进行订票动作时，我们首先要验证这些对象的有效性。
• 验证有效性之后，我们就可以继续流程，开始买票了。
• 订票服务需要用户的信用卡信息，通过支付服务，来完成购票动作。
• 扣款成功后，我们需要通过通知服务发送通知。
• 我们还需要为用户生成电影票，并将电影票和订单号信息发送给用户。

所以这次我们的开发任务变得相对重了一些，相应地代码也会变多，这也是我们需要一个单一依赖注入来源的原因，因为我们需要做更多的功能开发。

# 构建微服务

首先我们来看一下订票服务的 RAML 文件。

#%RAML 1.0
title: Booking Service
version: v1
baseUri: /
types:
Booking:
properties:
city: string
cinema: string
movie: string
schedule: datetime
cinemaRoom: string
seats: array
totalAmount: number
User:
properties:
name: string
lastname: string
email: string
creditcard: object
phoneNumber?: string
membership?: number
Ticket:
properties:
cinema: string
schedule: string
movie: string
seat: string
cinemaRoom: string
orderId: string
resourceTypes:
GET:
get:
responses:
200:
body:
application/json:
type: <<item>>
POST:
post:
body:
application/json:
type: <<item>>
type: <<item2>>
responses:
201:
body:
application/json:
type: <<item3>>
/booking:
type:   { POST: {item : Booking, item2 : User, item3: Ticket} }
description: The booking service need a Booking object that contains all
the needed information to make a purchase of cinema tickets. Needs a user information to make the booking succesfully. And returns a ticket object.
/verify/{orderId}:
type:  { GET: {item : Ticket} }
description: This route is for verify orders, and would return all the details of a specific purchased by orderid.

我们定义了三个模型对象，Booking 、User 以及 Ticket 。由于这是系列文章中第一次使用到 POST 请求，因此还有一项 NodeJS 的最佳实践我们还没有使用过，那就是数据验证。在“ Build beautiful node API's “ 这篇文章中有一句很好的表述：

一定，一定，一定要验证输入（以及输出）的数据。有 joi 以及 express-validator 等模块可以帮助你优雅地完成数据净化工作。— Azat Mardan

现在我们可以开始开发订票服务了。我们将使用与上一章相同的项目结构，不过会稍微做一点点改动。让我们不再纸上谈兵，撸起袖子开始编码！ 👩🏻‍💻👨🏻‍💻。

首先我们在 /src 目录下新建一个 models 目录

booking-service/src $ mkdir models
Now let’s move to the folder and create some files
booking-service/src/models $ touch user.js booking.js ticket.js
Now is moment to install a new npm package for data validation
npm i -S joi --silent

然后我们开始编写数据结构验证对象了，MonogDB也有内置的验证对象，不过这里需要验证的是数据对象的完整性，所以我们选择使用 joi，而且 joi 也允许我们同时进行数据验证，我们就由 booking.model.js 开始，然后是 ticket.model.js， 最后是 user.model.js。

const bookingSchema = (joi) => ({
  bookingSchema: joi.object().keys({
    city: joi.string(),
    schedule: joi.date().min('now'),
    movie: joi.string(),
    cinemaRoom: joi.number(),
    seats: joi.array().items(joi.string()).single(),
    totalAmount: joi.number()
  })
})
module.exports = bookingSchema

const ticketSchema = (joi) => ({
  ticketSchema: joi.object().keys({
    cinema: joi.string(),
    schedule: joi.date().min('now'),
    movie: joi.string(),
    seat: joi.array().items(joi.string()).single(),
    cinemaRoom: joi.number(),
    orderId: joi.number()
  })
})

module.exports = ticketSchema

const userSchema = (joi) => ({
  userSchema: joi.object().keys({
    name: joi.string().regex(/^[a-bA-B]+/).required(),
    lastName: joi.string().regex(/^[a-bA-B]+/).required(),
    email: joi.string().email().required(),
    phoneNumber: joi.string().regex(/^(\+0?1\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}$/),
    creditCard: joi.string().creditCard().required(),
    membership: joi.number().creditCard()
  })
})

module.exports = userSchema

如果你不是太了解 joi ，你可以去 github 上学习一下它的文档：文档链接

接下来我们编写模块的 index.js 文件，使这些校验方法暴露出来：

const joi = require('joi')
const user = require('./user.model')(joi)
const booking = require('./booking.model')(joi)
const ticket = require('./ticket.model')(joi)
const schemas = Object.create({user, booking, ticket})
const schemaValidator = (object, type) => {
return new Promise((resolve, reject) => {
if (!object) {
reject(new Error(‘object to validate not provided’))
}
if (!type) {
reject(new Error(‘schema type to validate not provided’))
}
const {error, value} = joi.validate(object, schemas[type])

if (error) {
  reject(new Error(`invalid ${type} data, err: ${error}`))
}
resolve(value)
})
}
module.exports = Object.create({validate: schemaValidator})

我们所写的这些代码应用了SOLID 原则中的单一责任原则，每个模型都有自己的校验方法，还应用了开放封闭原则，每个结构校验函数都可以对任意多的模型对象进行校验，接下来看看如何为这些模型编写测试代码。

/* eslint-env mocha */
const test = require('assert')
const {validate} = require('./')
console.log(Object.getPrototypeOf(validate))
describe(‘Schemas Validation’, () => {
it(‘can validate a booking object’, (done) => {
const now = new Date()
now.setDate(now.getDate() + 1)
const testBooking = {
  city: 'Morelia',
  cinema: 'Plaza Morelia',
  movie: 'Assasins Creed',
  schedule: now,
  cinemaRoom: 7,
  seats: ['45'],
  totalAmount: 71
}

validate(testBooking, 'booking')
  .then(value => {
    console.log('validated')
    console.log(value)
    done()
  })
  .catch(err => {
    console.log(err)
    done()
  })
})
it(‘can validate a user object’, (done) => {
const testUser = {
name: ‘Cristian’,
lastName: ‘Ramirez’,
email: ‘[email protected]’,
creditCard: ‘1111222233334444’,
membership: ‘7777888899990000’
}
validate(testUser, 'user')
  .then(value => {
    console.log('validated')
    console.log(value)
    done()
  })
  .catch(err => {
    console.log(err)
    done()
  })
})
it(‘can validate a ticket object’, (done) => {
const testTicket = {
cinema: ‘Plaza Morelia’,
schedule: new Date(),
movie: ‘Assasins Creed’,
seats: [‘35’],
cinemaRoom: 1,
orderId: ‘34jh1231ll’
}
validate(testTicket, 'ticket')
  .then(value => {
    console.log('validated')
    console.log(value)
    done()
  })
  .catch(err => {
    console.log(err)
    done()
  })
})
})

然后，我们要看的代码文件是 api/booking.js ，我们将会遇到更多的麻烦了，¿ 为什么呢 ?，因为这里我们将会与两个外部服务进行交互：支付服务以及通知服务，而且这类交互会引发我们重新思考微服务的架构，并会牵扯到被称作时间驱动数据管理以及 CQRS 的课题，不过我们将把这些课题留到之后的章节再进行讨论，避免本章变得过于复杂冗长。所以，本章我们先与这些服务进行简单地交互。

'use strict'
const status = require('http-status')
module.exports = ({repo}, app) => {
app.post(’/booking’, (req, res, next) => {
// we grab the dependencies need it for this route
const validate = req.container.resolve('validate')
const paymentService = req.container.resolve('paymentService')
const notificationService = req.container.resolve('notificationService')

Promise.all([
  validate(req.body.user, 'user'),
  validate(req.body.booking, 'booking')
])
.then(([user, booking]) => {
  const payment = {
    userName: user.name + ' ' + user.lastName,
    currency: 'mxn',
    number: user.creditCard.number,
    cvc: user.creditCard.cvc,
    exp_month: user.creditCard.exp_month,
    exp_year: user.creditCard.exp_year,
    amount: booking.amount,
    description: `
      Tickect(s) for movie ${booking.movie},
      with seat(s) ${booking.seats.toString()}
      at time ${booking.schedule}`
  }

  return Promise.all([
    // we call the payment service
    paymentService(payment),
    Promise.resolve(user),
    Promise.resolve(booking)
  ])
})
.then(([paid, user, booking]) => {
  return Promise.all([
    repo.makeBooking(user, booking),
    repo.generateTicket(paid, booking)
  ])
})
.then(([booking, ticket]) => {
  // we call the notification service
  notificationService({booking, ticket})
  res.status(status.OK).json(ticket)
})
.catch(next)
})
app.get(’/booking/verify/:orderId’, (req, res, next) => {
repo.getOrderById(req.params.orderId)
.then(order => {
res.status(status.OK).json(order)
})
.catch(next)
})
}

你可以看到，这里我们使用到了 expressjs 的中间件：container，并将其作为我们所用到的依赖项的唯一真实来源。

不过包含这些依赖项的 container 是从何而来呢？

我们现在对项目结构做了一点调整，主要是对 config 目录的调整，如下：

. 
|-- config 
|   |-- db 
|   |   |-- index.js 
|   |   |-- mongo.js 
|   |   `-- mongo.spec.js 
|   |-- di 
|   |   |-- di.js 
|   |   `-- index.js 
|   |-- ssl
|   |   |-- certificates 
|   |   `-- index.js
|   |-- config.js
|   |-- index.spec.js 
|   `-- index.js

在 config/index.js 文件包含了几乎所有的配置文件，包括依赖注入服务：

const {dbSettings, serverSettings} = require('./config')
const database = require('./db')
const {initDI} = require('./di')
const models = require('../models')
const services = require('../services')
const init = initDI.bind(null, {serverSettings, dbSettings, database, models, services})
module.exports = Object.assign({}, {init})

上面的代码中我们看到些不常见的东西，这里提出来给大家看看：

initDI.bind(null, {serverSettings, dbSettings, database, models, services})

这行代码到底做了什么呢？之前我提到过我们要配置依赖注入，不过这里我们做的事情叫作控制反转，的确这种说法太过于技术化了，甚至有些夸张，不过一旦你理解了之后就很容易理解。

所以我们的依赖注入函数不需要知道依赖项来自哪里，它只要注册这些依赖项，使得应用能够使用即可，我们的 di.js 看起来如下：

const { createContainer, asValue, asFunction, asClass } = require('awilix')
function initDI ({serverSettings, dbSettings, database, models, services}, mediator) {
mediator.once(‘init’, () => {
mediator.on(‘db.ready’, (db) => {
const container = createContainer()
  // loading dependecies in a single source of truth
  container.register({
    database: asValue(db).singleton(),
    validate: asValue(models.validate),
    booking: asValue(models.booking),
    user: asValue(models.booking),
    ticket: asValue(models.booking),
    ObjectID: asClass(database.ObjectID),
    serverSettings: asValue(serverSettings),
    paymentService: asValue(services.paymentService),
    notificationService: asValue(services.notificationService)
  })
  
  // we emit the container to be able to use it in the API
  mediator.emit('di.ready', container)
})

mediator.on('db.error', (err) => {
  mediator.emit('di.error', err)
})

database.connect(dbSettings, mediator)

mediator.emit('boot.ready')
})
}
module.exports.initDI = initDI

如你所见，我们使用了一个名为 awilix 的 npm 包用作依赖注入，awilix 实现了 nodejs 中的依赖注入机制（我目前正在试用这个库，这里使用它是为了是例子看起来更加清晰），要安装它需要执行以下指令：

npm i -S awilix --silent

现在我们的主 index.js 文件看起来就像这样：

'use strict'
const {EventEmitter} = require('events')
const server = require('./server/server')
const repository = require('./repository/repository')
const di = require('./config')
const mediator = new EventEmitter()
console.log(’— Booking Service —’)
console.log(‘Connecting to movies repository…’)
process.on(‘uncaughtException’, (err) => {
console.error(‘Unhandled Exception’, err)
})
process.on(‘uncaughtRejection’, (err, promise) => {
console.error(‘Unhandled Rejection’, err)
})
mediator.on(‘di.ready’, (container) => {
repository.connect(container)
.then(repo => {
container.registerFunction({repo})
return server.start(container)
})
.then(app => {
app.on(‘close’, () => {
container.resolve(‘repo’).disconnect()
})
})
})
di.init(mediator)
mediator.emit(‘init’)

现在你能看到，我们使用的包含所有依赖项的真实唯一来源，可通过 request 的 container 属性访问，至于我们怎样通过 expressjs 的中间件进行设置的，如之前提到过的，其实只需要几行代码：

const express = require('express')
const morgan = require('morgan')
const helmet = require('helmet')
const bodyparser = require('body-parser')
const cors = require('cors')
const spdy = require('spdy')
const _api = require('../api/booking')
const start = (container) => {
return new Promise((resolve, reject) => {
// here we grab our dependencies needed for the server
const {repo, port, ssl} = container.resolve('serverSettings')

if (!repo) {
  reject(new Error('The server must be started with a connected repository'))
}
if (!port) {
  reject(new Error('The server must be started with an available port'))
}

const app = express()
app.use(morgan('dev'))
app.use(bodyparser.json())
app.use(cors())
app.use(helmet())
app.use((err, req, res, next) => {
  if (err) {
    reject(new Error('Something went wrong!, err:' + err))
    res.status(500).send('Something went wrong!')
  }
  next()
})

// here is where we register the container as middleware
app.use((req, res, next) => {
  req.container = container.createScope()
  next()
})

// here we inject the repo to the API, since the repo is need it for all of our functions
// and we are using inversion of control to make it available
const api = _api.bind(null, {repo: container.resolve('repo')})
api(app)

if (process.env.NODE === 'test') {
  const server = app.listen(port, () => resolve(server))
} else {
  const server = spdy.createServer(ssl, app)
    .listen(port, () => resolve(server))
}
})
}
module.exports = Object.assign({}, {start})

基本上，我们只是将 container 对象附加到了 expressjs 的 req 对象上，这样 expressjs 的所有路由上都能访问到它了。如果你想更深入地了解 expressjs 的中间件是如何工作的，你可以点击这个链接查看 expressjs 的文档。

点击阅读全文