node 框架 LoopBack 教程

本文系原创，转载请注明出处

ES6 的出品为 JS 成为企业级语言扫清障碍，与之配套的，我们需要一个真正的企业级框架。Express 像一个精巧的微内核，不足以支撑起一个大项目。以下是 LoopBack 的一些入门知识，它是一个真正的企业级框架，随着使用的深入，读者将会发现它更多的用法和优秀的特性。本篇将对它的主要用法做一个详细的介绍 。

LoopBack 是建立在 Express 基础上的企业级 Node.js 框架，这个框架支持

• 只需编写少量代码就能创建动态端到端的 REST API
• 支持主流的数据源，例如 Mongodb、SOAP、MySQL 等和 REST API 的数据。
• 一致化的模型关系和对 API 访问的权限控制
• 可使用内置的用于移动应用场景下的地理定位、文件服务以及消息推送
• 提供 Android、iOS 和 JavaScript 的 SDK，轻松创建客户端应用程序
• 支持在云端或者本地部署服务

它可以像 Express 那样被使用。除此之外，LoopBack 作为一个面向企业级的 Web 框架，提供了更丰富的功能，这在我们添加模型，权限控制，连接数据源等操作时，极大的提升我们的效率。例如可以通过修改配置增加模型，并指定模型的数据源。它默认提供了一些基础模型，例如 User 这个模型包含了注册登录等逻辑。我们可以非常方便的继承这些内建模型，实现个性化的定制。它还提供了 Hook 编程的机制。它同时提供了可视化的调试页面，自动生成对应的前端 SDK 。这些功能在开发大型 Web 服务的时候，将帮助我们更容易查看和管理项目。本篇将会详细的介绍 LoopBack 的使用。

安装与运行

StrongLoop 是生成 LoopBack 框架的工具程序，我们首先安装它。运行

npm install -g strongloop

安装完成之后，可以运行 slc -v 查看是否安装成功(需要事先建立 slc 的软链接)。

紧接着，我们运行 slc loopback，这是一个交互式的命令，首先提示用户输入项目名称，这里就输入 loopback。接下来根据引导，按步骤填写相应信息即可。输入项目名称之后，接下来的步骤我们可以直接敲回车即可。最后 strongloop 会帮助我们创建 loopback 目录，并且在目录下创建默认的项目文件。我们进入 loopback 文件夹，运行 slc loopback:model，创建一个模型。我们可以随意输一个模块名，例如 cool 。接下来要求选择数据源，这里先选择默认值 db (memory)，敲回车即可。下一步要求选择模型的基类，也选用默认值 PersistedModel，代表此模型与持久化数据源连接。接下来，会出现

Expose cool via the REST API? Yes

当我们选择 ‘Y’，LoopBack 会为我们的模型生成 REST API 的代码。之后直接点击回车完成步骤即可。我们查看一下 loopback 目录都包含哪些文件

LoopBack 符合模型(M)—视图(V)—控制器©的设计规范。上图中的 server 文件夹，包含了程序的启动代码，配置信息。路由部分的逻辑也在 server 目录下。Express 支持将路由分组，因此 server 目录可以对应 MVC 的 C。client 目录包含给用户展示的前端代码，也包含由后台处理的用于生成页面的模板。这个目录对应 MVC 的 V。common 目录下有一个 models 文件夹，这里的代码处理具体的业务逻辑和数据，对应 M。

我们进入 server 文件夹，运行 node server.js，可以看到如下信息

Web server listening at: http://0.0.0.0:3000Browse your REST API at http://0.0.0.0:3000/explorer

在本地打开浏览器访问 http://0.0.0.0:3000/explorer， 可以看到如下界面

这是 LoopBack 集成的一个非常棒的功能，它列出了所有对外的模型和每一个模型的接口。LoopBack 默认生成的接口都是 REST API 风格。点击某一个接口，界面会展开，展开的界面提供了测试功能。我们可以将构造好的参数填入输入框，然后查看接口的返回结果。

LoopBack 为模型默认生成的接口包括

读系列

1. exists - 模型的数据源中对应id项是否存在
2. findById - 根据id返回数据源对应的项
3. find - 返回所有满足匹配查询条件的项
4. count - 返回满足匹配查询条件的项目个数

写系列

1. create - 创建新项
2. upsert - 更新项
3. destroyById - 删除为指定id的项

默认这些 REST API 可以被访问。如果需要屏蔽某一个，可以在模型的 JS 文件内部，例如cool.js，内部增加调用

module.exports = function(Cool) {
  Cool.disableRemoteMethod('findById', true);
  // 省略...

这样就能屏蔽掉 findById 这个接口。

当 LoopBack 服务启动的时候，它会按照文件名的字符串顺序，加载位于 /server/root 里面的所有 后缀名为 .js 的文件。这提供了一个初始化整个系统的机会。例如我们可以利用这个机制挂载模块，或者将初始化数据库的代码放到这个目录。

在浏览器中打开 explorer 调试接口虽然方便，但在实际项目中，别人随意可以查看这个界面存在着一定的风险。这时候就可以利用 LoopBack 加载 server/root 里面 JS 文件的机制，为 explorer 的访问增加权限控制。接下来在 server/root 里新建一个文件，起名为 explorer.js，这个文件的内容是

module.exports = function mountLoopBackExplorer(server) {
  var explorer;
  try {
    explorer = require('loopback-component-explorer');
  } catch(err) {
    // Print the message only when the app was started via `server.listen()`.
    // Do not print any message when the project is used as a component.
    server.once('started', function(baseUrl) {
      console.error(
        'Run `npm install loopback-component-explorer` to enable the LoopBack explorer'
      );
    });
    return;
  }
  //用户名 test 密码 123456
  server.use('/explorer', require('node-basicauth')({'test': '123456' }));

  server.use('/explorer', explorer.routes(server, { basePath: server.get('restApiRoot') }));

  server.once('started', function() {
    var baseUrl = server.get('url').replace(/\/$/, '');
    console.log('查看你的 REST API  %s%s', baseUrl, '/explorer');
  });
};

以上代码使用了一个新的模块 node-basicauth，因此在启动服务前需要先安装好，回到 loopback 目录运行

npm install node-basicauth

然后还需要修改 server/component-config.json 文件的内容，将默认的配置去除，或者直接删除这个文件。在 server 目录下重新启动服务，然后在本地用浏览器打开网址 http://0.0.0.0:3000/explorer ，出现提示，要输入用户名和密码。

mountLoopBackExplorer 函数的参数 server 是 LoopBack 传进来的，这个对象代表 LoopBack 程序本身。它在server.js文件开头创建

var app = module.exports = loopback();

app.models 包含了所有的模型，假如我们希望访问 cool 这个模型，可以通过如下形式

app.models.cool

得到此模型对象，之后便可以调用这个对象的函数。

路由与权限控制

LoopBack 添加路由的方式与 Express 一致。LoopBack 实现了 MVC 模型，在这个框架下，它提供了另外一种添加模块并导出 API 的方式。我们先来看 Express 添加路由的方法。默认生成的 server/server.js文件不大，大致内容为

var loopback = require('loopback');
var boot = require('loopback-boot');
var app = module.exports = loopback();

app.start = function() {
  // start the web server
  return app.listen(function() {
    app.emit('started');
    var baseUrl = app.get('url').replace(/\/$/, '');
    console.log('Web server listening at: %s', baseUrl);
    if (app.get('loopback-component-explorer')) {
      var explorerPath = app.get('loopback-component-explorer').mountPath;
      console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
    }
  });
};

// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
  if (err) throw err;

  // start the server if `$ Node server.js`
  if (require.main === module)
    app.start();
});

在 server.js 控制路由的逻辑中，应该将路由分类，以后方便管理。在 server 目录中新建一个文件夹，命名为 routes，然后新建一个 test.js 的文件，内容为

var router = module.exports.test_router = require('loopback').Router();

router.get('/name', function(req, res, next) {
  res.send('visit test/name');
});

router.get('/', function(req, res) {
  res.send('visit test root');
});

启动服务后，用户访问 /test/ 或者 /test/name 的时候要能正确返回。因此需要修改 server.js，建立 test 的路由，以下是修改之后的 server.js 内容

var loopback = require('loopback');
var boot = require('loopback-boot');
var path = require('path');
var app = module.exports = loopback();

app.start = function() {
  // start the web server
  return app.listen(function() {
    app.emit('started');
    var baseUrl = app.get('url').replace(/\/$/, '');
    console.log('Web server listening at: %s', baseUrl);
    if (app.get('loopback-component-explorer')) {
      var explorerPath = app.get('loopback-component-explorer').mountPath;
      console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
    }
  });
};

app.use('/test',require(path.resolve(__dirname, './routes/test.js')).test_router);

// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
  if (err) throw err;

  // start the server if `$ Node server.js`
  if (require.main === module)
    app.start();
});

process.on('uncaughtException', function (err){
  console.error('uncaughtException: %s', err.message);
});

重新启动服务，使用浏览器访问 http://0.0.0.0:3000/test/name 和 http://0.0.0.0:3000/test/ 可以看到返回的结果。以上代码除了添加了一个 test 的路由，还监听了 uncaughtException 这个事件，后面的部分在讲解 cluster 模式的时候，我们将会看到对这个事件更合理的处理。

按照上述方式添加路由非常简单，但这些导出的 API 无法在 explorer 页面中查看和调试，也难以对API 进行权限控制等操作。好在 LoopBack 框架提供了一套机制，通过修改配置文件就能增加模型和导出 REST API，并且能够方便的对接口进行权限控制。之前在 common/models 文件夹里，我们用 slc 生成了一个模型 cool，这个目录下包含两个文件

cool.js  cool.json

cool.json 是对这个模型的配置，这个文件包含的内容是

{
  "name": "cool",
  "base": "PersistedModel",
  "idInjection": true,
  "options": {
    "validateUpsert": true
  },
  "properties": {},
  "validations": [],
  "relations": {},
  "acls": [],
  "methods": {}
}

这个文件定义了几个字段，base 代表 cool 模型的基类，acls 字段用于权限控制。relations 定义了模型之间的关系，properties 定义了模型对应的持久化字段。cool.js 中包含这个模型的处理逻辑，这个文件的初始内容是

module.exports = function(Cool) {
};

现在我们给 cool 添加一个 get 请求，并对这个 API 添加不同类型的权限。要添加新接口，需要在cool.js 中编写新接口的代码，例如我们添加一个名字为 test 的接口，这个接口接收一个字符串，然后返回这个字符串，代码大致如下

module.exports = function(Cool) {

  Cool.test = function(content, cb){
  	cb(null, content);
  };

  Cool.remoteMethod(
    'test'
    ,{
      description: '输入一个字符串，返回它'
      ,accepts: [
      			  {arg: 'content', type: 'string',required: true}
                ]
             ,http: {path:'/test', verb: 'get'}
             ,returns : { arg: 'ret', type:"string", root: true,required: true}
    }
  );
};

LoopBack 是一个优秀而易用的框架，代码就是最好的教科书。经过修改之后，我们重新启动服务，用浏览器打开 explorer，测试我们新添加的接口如下图

我们在输入框随意输入一个字符串，点击测试按钮，可以立即查看返回结果。可见 LoopBack 框架内，给模型添加一个接口非常方便，新接口添加完毕，浏览器打开页面就可以直接调试。下面我们修改cool.json 文件，来实现对这个接口的权限控制。我们为 acls 这个字段添加如下内容

"acls": [
    {
      "principalType": "ROLE",
      "principalId": "$everyone",
      "permission": "DENY"
    }
  ]

保存文件之后重启服务，在 explorer 内重新测试，我们发现接口已经不可访问

{
    "error": {
    "name": "Error",
    "status": 401,
    "message": "Authorization Required",
    "statusCode": 401,
    "code": "AUTHORIZATION_REQUIRED",
    "stack": "Error: Authorization Required"
  }
}

principalId 是指对谁进行权限控制。在 LoopBack 中，我们常用的几个取值包括

$everyone$owner$authenticated自定义角色，例如 admin

$everyone 按照字面意思比较好理解。$owner 和 $authenticated 以及自定义角色在启用用户Token 的情况下使用。例如一个登录用户，在访问 REST API 时会带上他的 Token 信息，$owner 代表这个用户只能访问自己的信息，而对其他用户的数据没有访问权限。如果换成 $authenticated，那么只要用户的 Token 信息合法，就可以调用这个接口。下面我们继续修改 acls 这个键，使得 test 接口重新可访问，我们添加一个针对 test 接口的访问控制项

"acls": [
    {
      "principalType": "ROLE",
      "principalId": "$everyone",
      "permission": "DENY"
    }
    ,{
      "accessType": "EXECUTE",
      "principalType": "ROLE",
      "principalId": "$everyone",
      "permission": "ALLOW",
      "property": "test" 
    }
  ]

principalId 设置为对所有的人进行访问控制，permission 字段设置为允许。重启服务后，这个接口变得可访问。accessType 的取值有三个，分别是 READ，WRITE 和 EXECUTE。一般来讲，我们自定义的接口 accessType 使用 EXECUTE 修饰，principalId 使用 $everyone 或者 $authenticated 修饰。对于每一个模型，LoopBack 框架会自动生成一系列固定模式的 REST API，用于存取模型数据。这部分接口的 accessType 常会用到 READ 和 WRITE。接下来，我们基于 LoopBack 的一个内建模型 User，建立一个用户体系，允许使用者创建新用户，生成用户 Token，然后再进一步讨论 LoopBack 的权限控制，之后本章还将讨论 LoopBack 中模型之间的关系。

添加新模型

我们接下来添加一个模型 Ouser，并建立服务的用户体系。进入 server 目录，其中有一个配置文件 model-config.json，这个文件中记录了所有的模型。打开此文件，在 cool 之后，添加 Ouser 模型。

  "cool": {
    "dataSource": "db",
    "public": true
  },
  "Ouser":{
    "dataSource": "db",
    "public": true
  }

之后，在 common/models 目录下，新建两个文件

ouser.js      ouser.json

下面我们编辑ouser.json文件的内容，如下

{
  "name": "Ouser",
  "plural": "ousers",
  "base": "User",
  "idInjection": true,
  "properties": {
    "nickname": {
      "type": "string"
    }
  },
  "validations": [],
  "relations": {
  },
  "acls": [
    {
      "principalType": "ROLE",
      "principalId": "$everyone",
      "permission": "DENY"
    },
    {
      "accessType": "*",
      "principalType": "ROLE",
      "principalId": "$owner",
      "permission": "ALLOW"
    },
    {
      "accessType": "*",
      "principalType": "ROLE",
      "principalId": "admin",
      "permission": "ALLOW"
    }
  ],
  "methods": {}
}

Ouser 继承自 User，对应的 JS 文件在 LoopBack 模块目录的 common/models 文件夹中。User 代表了对用户操作的模型，包含了注册，登录等逻辑。接着编写 ouser.js 文件内容，如下

module.exports = function(Ouser) {
	
};

因为模型 Ouser 继承自 User，因此源文件中可以调用 User 定义的方法，User 对外的接口也被 Ouser 模型继承。在 model-config.json 文件中，我们屏蔽掉 User，使这个模型的接口不对外。

"User": {
    "dataSource": "db",
    "public":false
  }

接下来，我们重启服务，浏览器打开 explorer，可以看到，刚才新添加的模型 Ouser 已经存在，并且包含了一系列 REST API。这些 API 是 LoopBack 自动添加的，根据英文注释，不难理解每一个接口的含义。我们可以直接在 explorer 的界面中，创建一个新用户，先找到创建用户的接口

在输入框中填写如下内容

{
"nickname":"Json"
,"email":"[email protected]"
,"password":"12345"
}

nickname 是模型 Ouser 的一个属性。另外两个是基类 User 自带的属性。然后点击Try it out，返回如下内容

{
  "nickname": "Json",
  "email": "[email protected]",
  "id": 1
}

这代表新创建了一个用户。接下来调用 Ouser 的 /ousers/login 方法，试着尝试使用邮箱和密码登录。在 credentials 输入框输入如下内容

{"email":"[email protected]"
,"password":"12345"
}

点击发送按钮，将返回如下数据

{
  "id": "F7IliK3irck8ILWkAdEucYGoXw67j50GTYKIsurYx1EuZb61QcohEsAxcqLw0RMS",
  "ttl": 1209600,
  "created": "2016-07-24T06:20:28.436Z",
  "userId": 1
}

这代表我们已经登录成功，并返回一个此用户的 Token 信息。目前服务使用的是基于 memory 存储方案，服务重启，数据丢失。复制这个 Token 信息，将他拷贝到如下图所示的输入框，然后点击 Set Access Token 按钮

接着，我们点开 get /ousers/{id} 这个接口，在 id 对应的输入框输入1，点击 Try it out 按钮，将返回这个 id 为1的用户对应的信息。

以上过程演示了注册，登录和根据有效 Token 访问用户信息的步骤。而真正用于实际的步骤比这个要复杂一些。现在回过头再来看看，模型是怎么添加的，在 model-config.json，我们添加了如下内容

  "Ouser":{
    "dataSource": "db",
    "public": true
  }

dataSource 字段的内容是 db，表示 Ouser 使用名称为 db 的数据源。这个数据源在同级目录的 datasources.json 中定义，我们看一下这个文件的内容

{
  "db": {
    "name": "db",
    "connector": "memory"
  }
}

connector 字段的值为 memory，它代表基于内存的持久化。刚才创建的新用户和对数据的任何修改，服务重启之后都将消失。在实际的使用中，服务的数据源应该来自可持久化的数据库。例如可修改为一个使用 mongodb 存储的数据源，为这个文件添加如下内容

{
  "db": {
    "name": "db",
    "connector": "memory"
  },
  "mongods": {
    "host": "localhost",
    "port": 27017,
    "url": "mongodb://name:pass@localhost:27017/dbname",
    "database": "dbname",
    "username": "name",
    "password": "pass",
    "name": "mongods",
    "connector": "mongodb"
  }
}

url 字段中的 name，pass 和 dbname 以实际的为准。database 字段代表数据库名称，username 代表 mongodb 的用户名，password 是数据库连接密码。使用 mongodb 做存储，需要先安装 mongodb 的连接器，在工程根目录下运行

npm install --save loopback-connector-mongodb

这样，在服务启动后，LoopBack 根据这个配置文件给出的连接 url，自动去连接 mongodb 数据库。我们希望所有的模型使用 mongodb 作为数据源，那就需要全面的修改 model-config.json。修改后如下

{
  "_meta": {
    "sources": [
      "loopback/common/models",
      "loopback/server/models",
      "../common/models",
      "./models"
    ],
    "mixins": [
      "loopback/common/mixins",
      "loopback/server/mixins",
      "../common/mixins",
      "./mixins"
    ]
  },
  "User": {
    "dataSource": "mongods",
    "public":false
  },
  "AccessToken": {
    "dataSource": "mongods",
    "public": false
  },
  "ACL": {
    "dataSource": "mongods",
    "public": false
  },
  "RoleMapping": {
    "dataSource": "mongods",
    "public": false
  },
  "Role": {
    "dataSource": "mongods",
    "public": false
  },
  "cool": {
    "dataSource": "mongods",
    "public": true
  },
  "Ouser":{
    "dataSource": "mongods",
    "public": true
  }
}

可见，修改数据源只需要将这些模型的 dataSource 都改为 mongods。

---

loopback-connector-mongodb 模块依赖 Mongodb 的官方 Node.js 驱动 mongodb 模块。在程序中，我们可以直接使用官方驱动操作数据库，这也极为方便。下例是使用 mongodb 模块连接数据库并创建集合的例子

// A simple example showing the creation of a collection.

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  test.equal(null, err);

  // Create a capped collection with a maximum of 1000 documents
  db.createCollection("a_simple_collection", {capped:true, size:10000, max:1000, w:1}, function(err, collection) {
    test.equal(null, err);

    // Insert a document in the capped collection
    collection.insertOne({a:1}, {w:1}, function(err, result) {
      test.equal(null, err);

      db.close();
    });
  });
});

官方驱动原生支持 Promise 和 ES6 generator，其官网 API 文档对每一个接口的说明非常详尽。建议读者访问 http://mongodb.github.io/node-mongodb-native/2.1/api/ 了解更多。

---

初始化数据库

使用 mongodb 作为可持久化的数据源，最开始启动服务的时候，这个数据库为空。还记得 LoopBack 在启动时会到 server/root 目录下依次加载 JS 文件。因此也可以将初始化数据库的代码放入这个目录内。当启动服务时，JS 文件自动执行。但需要注意的是，这类初始化代码只需要执行一次，因此当数据库初始化完毕之后，要把文件名后缀的 js 去掉，防止以后重复执行。在 server/root 目录下，新添加一个文件 initmongo.js，内容为

module.exports = function(app) {
  var mongoDs = app.dataSources.mongods;
  mongoDs.automigrate('AccessToken', function(err){
    if(err) throw err;
  });
  mongoDs.automigrate('Ouser', function(err){
    if(err) throw err;

    var Ouser = app.models.Ouser;
    var Role = app.models.Role;
    var RoleMapping = app.models.RoleMapping;

    Ouser.create([
      {username: 'admin', email: '[email protected]', password: '12345', emailVerified: true}
      ], function(err, users) {
      if (err) throw err;
      mongoDs.automigrate('Role', function(err){
        if(err) throw err;
        mongoDs.automigrate('RoleMapping', function(err){
          if(err) throw err;
          var userid = users[0].id;
          Role.create({
          name: 'admin'
          }, function(err, role) {
            console.log('Created role:', role);

            role.principals.create({
            principalType: RoleMapping.USER
            , principalId: userid
            }, function(err, principal) {
            if (err) throw err;
              console.log('Created principal:', principal);
            });
          });
        });
      });
    });
  });
};

上面这段代码创建了 AccessToken，Role，RoleMapping 和 Ouser 这几张表。前三个模型是 LoopBack 预定义的。AccessToken 用于保存用户登录后的 Token 信息。Role 和 RoleMapping 用于权限控制。上述代码创建了 Role 表，并添加了一个角色 admin。在 RoleMapping 中，将权限角色 admin 与 Ouser 表中新创建的用户关联起来。此用户登录成功之后，就可以访问用 admin 限定的接口。

{
  "accessType": "EXECUTE",
  "principalType": "ROLE",
  "principalId": "admin",
  "permission": "ALLOW",
  "property": "test" 
}

用户登录成功之后，服务端向浏览器返回其有效 Token，程序中可以将这个 Token 保存到域名所在的 cookie 中，这样以后的 http 访问请求就会自带这个 Token 信息，LoopBack 根据这个 Token 信息，从 AccessToken 中反查出用户 id，如果 Token 有效，此用户就拥有了 $authenticated 角色，可以访问被 $authenticated 限定的接口。例如可以修改 ouser.js，在登录成功后，把这个 cookie 植如用户浏览器。

module.exports = function(Ouser) {
    Ouser.afterRemote('login', function (context, result, next) {
      var res = context.res;
      if ( result && result.id ) {
          res.cookie('authorization', result.id, { maxAge: 1000*60*60*24*14*6, httpOnly: true
                  ,signed: true, domain: '.domain.com' });
      }
      return next();
    });
};

当然，处于安全考虑，应该对保存在用户本地的 cookie 信息加密。这可以使用 cookie-parser 这个中间件来完成。

钩子机制

上一节结尾的代码用到了 LoopBack 的钩子机制。LoopBack 的钩子分为两种

1. 接口调用执行前和执行后，分别对应 beforeRemote 和 afterRemote；
2. CRUD 操作前或后，注册的方法被执行。主要有

accessbefore saveafter savebefore deleteafter delete

CRUD 是增加，读取查询，更新，删除的简称。这两种钩子使用起来都不复杂。上面的代码 afterRemote 就是使用第一种钩子的场景。在本章前面的部分，用例子演示了注册登录的过程。在实际的邮箱注册逻辑中，用户点击注册之后，应该给用户注册时填写的邮箱发送一封邮件。用户收到邮件后，点击连接，才能激活这个账户。而发送邮件的时机，应该是把用户的注册信息写到表 Ouser 之后。我们可以利用钩子的机制，在创建用户之后，执行一个函数，发送一封确认邮件。

Ouser.afterRemote('create', function (ctx, result, next) {
   if(!ctx.result.emailVerified && !ctx.result.username){
      let subject = '注册邮件';
      let template = path.resolve(path.join(__dirname, '..', '..', 'client','templates', 'verify.ejs'));
      ctx.result.verify({
      type:'email',
      from:'[email protected]', //发送邮箱
      to:ctx.result.email, //用户邮箱
      subject:subject,
      template: template
      }, function (err, data){
        if(err){
          console.error(err);
        }
        next();
      });
   }else{
      next();
   }
});

为了能够收发邮件，需要使用 LoopBack 的一个基础模型 Email 并增加相应的邮件配置，在 model-config.json 文件中增加

"Email": {
    "dataSource": "emailds"
  }

然后在datasources.json中增加邮件配置信息

"emailds": {
    "name": "emailds",
    "connector": "mail",
    "transports": [
      {
        "type": "smtp",
        "host": "the email host",
        "secure": false,
        "port": 25,
        "auth": {
          "user": "your email",
          "pass": "your pass"
        }
      }
    ]
  }

中间件

server 目录下有一个配置文件 middleware.json，LoobBack 增加了中间件执行序列的概念，这可以严格的定义中间件函数的调用顺序。LoopBack 预定义的阶段包含

initial - 中间件最早在这个阶段执行session - 准备会话对象auth - 权限认证parse - 解析请求体routes - 路由请求files - 对静态文件的请求final - 错误处理

每一个阶段又可分成三个子阶段，例如auth阶段，可分为

“auth:before”:{}“auth”:{}“auth:after”:{}

在一次请求中，这些阶段自上而下依次执行。我们可以举一个例子，来说明如何在这个文件中添加中间件。对于404错误，我们希望返回一个404页面。final 用来处理错误，因此可以在这个阶段，添加一个处理404错误的中间件。

"final": {
    "./error404.js":{}
  }

在同级目录下，新建这个文件，文件的内容为

module.exports = function(options) {
  return function raiseUrlNotFoundError(req, res, next) {
    var error = new Error('Cannot ' + req.method + ' ' + req.url);
    error.status = 404;
//------------------- max custom 404 ------//
   if (req.accepts('html, text/html')) {
        console.log( "404 ERR! " );
       return res.sendFile('404.html', { root: __dirname + './../client/public/html/' });
    }
//---------------------------------------//
    next(error);
  };
}

如此做之后，不要忘了在 client/public/html 目录下包含一个 404.html 的文件。

再比如，在解析请求体阶段，可以添加自动对 json 或 urlencoded 编码的字符串进行解析的中间件

"parse": {
    "body-parser#json": {},
    "body-parser#urlencoded": {"params": { "extended": true }}
    }

模型关系

在程序中可以定义很多模型，这些模型可能存在一些关系。例如一个用户可能在多处登录，因此可以存在多个有效的 Token信息。也就是说 User 模型的一个用户对应 AccessToken 模型的多份数据，而 AccessToken 中里面的任意一个元素只属于 User 中某一个用户。User 和 AccessToken 这两个模型是 LoopBack 自带的，我们可以进入 LoopBack 模块文件夹的 common/models 目录下，查看这两个模型的 json 文件，在 user.json 文件末尾，我们可以看到如下内容

"relations": {
  "accessTokens": {
	 "type": "hasMany",
	 "model": "AccessToken",
	 "foreignKey": "userId",
	 "options": {
	    "disableInclude": true
     }
  }
}

type 字段的 hasMany 代表 User 与 AccessToken 是一对多的关系，User 是主模型。foreignKey 代表了这两个模型之间的关联键。也就是 User 表的 id 作为 AccessToken 的外键，名称是 userId。access-token.json 文件末尾，我们看到类似的内容

"relations": {
    "user": {
      "type": "belongsTo",
      "model": "User",
      "foreignKey": "userId"
    }
  }

belongsTo 代表它是 User 的从模型，userId 作为外键，其值为对应 User 元素的 id。

一旦定义了模型之间的关系，LoopBack 会为我们自动生成一系列的 REST API 接口，例如可以使用 Ouser 模型中的接口，得到 AccessToken 模型的数据。下图显示了这些生成的接口

例如我们想获取某一个用户 id 的所有 Token 信息，就可以使用上图展示的第一个接口获取

[
  {
    "id": "9g9SCL6LAFPy20WLf7u0Q2KIAcgXv8Nfur3BxHs7xq1501UzBNcJYNlDRmbXSmrh",
    "ttl": 7257600,
    "created": "2016-05-22T08:43:56.380Z",
    "userId": "56e9853decfd499b641b82a1"
  },
  {
    "id": "BtFnIenOd003UmGmFxJs6f6bcaeIBvcyD5q94zpxoQ5nv9ojUQqmRJ3rAbH9oU5n",
    "ttl": 7257600,
    "created": "2016-05-22T08:44:38.014Z",
    "userId": "56e9853decfd499b641b82a1"
  }
]

使用 cluster 模式运行服务

因为 http 是无状态的，因此可以启动多个平行的服务进程并行处理 http 请求。cluster-works 模式的另一个好处是，主进程是所有 work 进程的父进程，work 的异常退出，主进程都可以捕获到，并报警。cluster 模块是 Node 原生支持的模块。我们在 server 目录下，添加一个文件 cluster.js，文件内容为

var cluster = require('cluster');
var workers = {};

var WorkersLen = function (){
  var len = 0;
  for(var id in workers){
     ++len;
  }
  return len;
};

var createWorker = function (){
    var worker = cluster.fork();
    workers[worker.id] = worker;
    worker.on('exit', function(code){
      delete workers[worker.id];
    });

    worker.on('message', function(msg){
      do {
          if(msg.cmd === 'suicide'){
            createWorker();
            break;
          }
      }while(false);
    });
};

function StartWorkers() {
    var n = 0;
    require('os').cpus().forEach(function(){
      createWorker();
    });
}

if(cluster.isMaster){
  StartWorkers();
  process.on('exit', function(){
    for(var id in workers){
      workers[id].kill();
    }
  });
}else{
  require('./server.js').start();
}

以上代码包含了 work 进程与主进程的通信。Node 进程之间使用 Unix 域套接字通信，这是一种非常高效的方式。主进程监听了 message 事件，回调函数的参数是一个 json 对象。可以根据这个 json 对象的内容，区分这个事件的不同类型，然后分别处理。

接下来还需要稍微修改一下 server.js 文件。在文件末尾，曾为 server.js 添加了如下代码

process.on('uncaughtException', function (err){
  console.error('uncaughtException: %s', err.message);
});

现在我们希望遇到这个未捕获异常，除了打印出异常信息之外，程序能够优雅的退出，而不是在某一个时刻崩溃掉。于是将上述代码修改为

process.on('uncaughtException', function (err){
  console.error('worker uncaughtException: %s', err.message);
  var worker = require('cluster').worker;
  if(worker){
    process.send({ cmd: 'suicide', stack: err.stack, message:err.message});
    Server.close(function(){
      process.exit(1);
    });
  }
});

当子进程收到一个未捕获异常时，就向父进程发送一个 message 事件，并附上异常信息，500毫秒之后退出。父进程收到这个类型为 suicide 的 message 事件之后，立即重启动一个 work。事实上，cluster.js 文件内还可以处理更多的逻辑。但无论如何，cluster.js 的代码都该越简单越好，它的稳定性应该与 Node 引擎一致。我们可以再结合 pm2 工具运行 cluster.js，pm2 可以保证 cluster.js 的运行，这样可以进一步提供服务健壮性。

顺便一提，2015年后半年，IBM 收购了 loopback

参考资料

LoopBack 官网 https://docs.strongloop.com/display/SL/Installing+StrongLoop

原文:https://cnodejs.org/topic/57e5b2859c495dce044f397c