StrongLoop

http://loopback.io/getting-started/

 

使用 StrongLoop 創建 Node.js MySQL 應用程序

StrongLoop 是 IBM 的一家子公司，StrongLoop API Platform 構建於開源的 LoopBack.io 之上，后者是一個高度可擴展的 Node.js API 框架。借助 LoopBack，您可以快速創建可擴展的 API 和數據庫映射。StrongLoop 還擁有內置的移動后端即服務 (MBaaS) 特性，比如推送和離線同步，而且擁有一些圖形工具，可用來集群化、分析和監視 Node 應用程序。StrongLoop 在 Express Node.js Web 應用程序框架之上運行，而且符合 Swagger 2.0 規范。

0 評論：

Arpitha Myla, 雲計算技術專家, IBM

2015 年 10 月 20 日

• 內容

在 IBM Bluemix 雲平台上開發並部署您的下一個應用。

開始您的試用

這篇簡短教程將展示使用 StrongLoop API 將來自 MySQL 數據庫的數據與 Node.js 相集成的步驟。我們不要求掌握命令行以外的任何工具！完成本教程后，您將能夠瀏覽生成的 API：

在這里，您能夠使用 StrongLoop API Explorer 來 POST 數據，並在所選的數據庫瀏覽器中檢查結果。

開始之前

除了命令行之外，下面是一些必備工具：

• 一個本地 Node.js 安裝（參見 Node.js 下載，或者如果您更喜歡 Eclipse 環境，請參見 Nodeclipse 下載）
• Node.js 可執行 npm，用於 Node.js 的包管理器

當然，您還需要一個 Bluemix 帳戶。

在應用程序中使用 StrongLoop 之前，必須安裝 StrongLoop 命令行工具。這些工具包括 slc、StrongLoop Process Manager 的命令 shell、strong-pm 和 LoopBack API 框架（包含 CLI 和 GUI）。要安裝 StrongLoop 工具，請執行下面這條 npm 命令：

npm install -g strongloop

要驗證 LoopBack 是否安裝成功，可鍵入

slc -v

它應該顯示了您的 StrongLoop 安裝的版本。

 

回頁首

創建一個骨架 LoopBack 應用程序

切換到您的開發目錄。

cd <development_directory>

使用下面這條命令，創建一個名為“<alias>-loopback-example”的新應用程序（比如 amyla-loopback-example）。

slc loopback  <alias>-loopback-example

輸入應用程序名稱和安裝目錄，以便完成新 StrongLoop 項目的初始化。您現在已經有一個完整的 Node.js StrongLoop 應用程序。嘗試運行您的應用程序並打開資源管理器頁面。

cd <alias>-loopback-example
node server/server.js

如果發生類似“Cannot find module ‘loopback'”的錯誤，可運行 npm install 將所需的模塊安裝在 node_modules 目錄中。單擊 show/hide 鏈接顯示您的新應用程序隨帶的 StrongLoop API：

 

回頁首

安裝 StrongLoop MySQL 連接器

接下來，我們將通過安裝 LoopBack MySQL 連接器，向項目添加對 MySQL 數據庫的支持。運行下面這條命令來安裝 StrongLoop MySQL 連接器：

cd <alias>-loopback-example
npm install --save loopback-connector-mysql

 

回頁首

配置數據源

現在我們已經添加了適當的數據庫支持，您必須為數據源配置數據庫連接。創建和配置一個名為“AccountDb”的新數據源。

slc loopback:datasource AccountDb

接受默認數據源名稱。對於數據庫類型，選擇 MySQL。

 

回頁首

創建一個 Node.js 應用程序和 MySQL 服務

現在我們已有一個在 localhost 上運行的有效的 StrongLoop 應用程序，我們將向應用程序添加一個 MySQL 連接，因此必須先創建一個想要連接到的 MySQL 實例。

如果已有一個想要使用的現有的 MySQL 數據庫實例，您可以跳過這一步，使用您現有的服務的 MySQL 憑據。

我將在 Bluemix 中創建一個新 MySQL 數據庫實例。如果沒有 Bluemix 帳戶，請注冊一個免費的 Bluemix 試用版帳戶。

• 登錄到 Bluemix 控制台：console.ng.bluemix.net。
• 轉到儀表板。
• 在“Cloud Foundry Apps”下，單擊“CREATE APP”。
• 選擇“WEB”。
• 選擇“SDK for Node.js”並單擊“CONTINUE”。
• 在“APP NAME”上輸入應用程序名稱“<alias>-loopback-example”並單擊“FINISH”。

等待應用程序完成暫存。

• 顯示消息“Your app is running”后，單擊 Overview 頁面。
• 單擊“ADD A SERVICE OR API”，或者如果已創建了 MySQL 服務，單擊“BIND A SERVICE OR API”。
• 搜索“MySQL”或向下滾動到 Data & Analytics 服務。
• 找到並選擇“ClearDB MySQL Database”服務。
• 接受默認設置或重命名該服務，按“USE”並確認“重新暫存”應用程序。

在創建服務后，在應用程序細節頁面的左側菜單中，轉到“Environmental Variables”來查看 MySQL 服務憑據。或者轉到 Overview 頁，在 service 窗口中單擊“Show Credentials”鏈接。

 

回頁首

配置數據源

在應用程序目錄中，打開 server/datasources.json 文件，添加您的數據源配置。復制 ClearDB MySQL 服務的憑據，或使用您自己的 MySQL 數據庫憑據。

{
"cleardb":[
{
"name":"MyClearDBMySQLDatabase-5y",
"label":"cleardb",
"plan":"spark",
"credentials":{
"jdbcUrl":"jdbc:mysql://<database_subdomain>.cleardb.net/<database>?user=<username>&password=<password>",
"uri":"mysql://<username>:<password>@<database_subdomain>.cleardb.net:3306/<database>?reconnect=true",
"name":"<database>",
"hostname":"<database_subdomain>.cleardb.net",
"port":"3306",
"username":"<username>",
"password":"<password>"
}
}
]
}

將憑據添加到 server/datasources.json 文件中。

{
"db":{
"name":"db",
"connector":"memory"
},
"AccountDb":{
"host":"<database_subdomain>.cleardb.net",
"port":3306,
"database":"<database>",
"password":"<password>",
"name":"AccountDb",
"user":"<username>",
"connector":"mysql"
}
}

 

回頁首

創建數據模型

現在數據庫已成功添加且配置了數據源，可以開始創建數據模型了。數據模型描述您應用程序中的模式或數據對象。每個數據對象將在 StrongLoop 中擁有自己的模型。完整的模式是模型的集合。在這里，我們為 Account 對象創建了一個數據模型。

slc loopback:model Account

按照提示配置該數據模型。對於模型的“base class”，使用“PersistedModel”並選擇通過 REST API 公開該模型。添加模型屬性如下：

Name:Account 
Datasource:AccountDb
Base class:PersistedModel
Expose via REST:Yes
Custom plural form:Leave blank

對於數據模型上的屬性，創建以下 3 個屬性。

Property name: email 
Property type: string
Required?Not required
Property name: createdAt 
Property type: date
Required?Not required
Property name: lastModifiedAt 
Property type: date
Required?Not required

我們現在已擁有數據庫支持、數據源和數據模型。有了這些，我們就可以使用對象關系映射 (ORM)，使用 StrongLoop 中的自動遷移工具，在 MySQL 中從數據模型生成數據庫模式。

 

回頁首

添加腳本來創建數據庫中的模式

在您項目的根目錄下的 ./server 文件夾中創建一個 bin 目錄。

cd server
mkdir bin

在 server/bin 目錄中，使用以下代碼創建一個名為 automigrate.js 的文件。

var app = require('../server');

var accounts = [
{
email:'[e-mail]',
createdAt: new Date(),
lastModifiedAt: new Date()
},
{
email:'[e-mail]',
createdAt: new Date(),
lastModifiedAt: new Date()
}
];

// this loads the accountDb configuration in ~/server/datasources.json
var dataSource = app.dataSources.AccountDb;

// this automigrates the Account model 
dataSource.automigrate('Account', function(err) {
if (err) throw err;

// this loads the Account model from ~/common/models/Account.json
var Account = app.models.Account;
var count = accounts.length;
accounts.forEach(function(account) {
// insert new records into the Account table
Account.create(account, function(err, record) {
if (err) return console.log(err);

console.log('Record created:', record);

count--;

if (count === 0) {
console.log('done');
dataSource.disconnect();
}
});
});
});

 

回頁首

創建 MySQL 模式

使用下面的命令運行 automigrate.js 腳本來在 MySQL 中創建一個表。

node server/bin/automigrate.js

運行上述腳本后，使用您最喜歡的 MySQL 客戶端連接到您的 MySQL 數據庫，您應看到表“account”包含 3 列：“email”、“createdAt”和“lastModifiedAt”。StrongLoop 還添加了一個“id”列。該表包含我們在腳本中創建的兩個條目的數據，這兩個條目是用來插入數據的：

 

回頁首

運行該應用程序

slc run
或
node server/server.js

並瀏覽到 http://localhost:3000/explorer。StrongLoop 向您的應用程序添加了一系列兼容 Swagger 的 API，用於訪問帳戶資源：

我們還可以使用資源管理器頁面來測試每個 API。單擊“POST /Accounts”鏈接插入新數據。輸入一條新 JSON 記錄並按下“Try it out!”。

{
"email":"[e-mail]",
"createdAt":"2015-09-01",
"lastModifiedAt":"2015-09-01"
}

您管理帳戶的 StrongLoop 應用程序已完成！我們只需將它上傳並部署到 Bluemix。

 

回頁首

將 StrongLoop 應用程序部署到 Bluemix

• 轉到 Bluemix 儀表板並單擊（您之前創建的）項目。
• 單擊 start coding。
• 將 Bluemix 中的 Starter 應用程序的代碼下載到您的 localhost，或者將 Git 存儲庫克隆到您的 localhost。
• 將 Bluemix Starter 應用程序的 manifest.yml 文件復制到您的本地 StrongLoop 應用程序“<alias>-loopback-example”的根目錄下。此文件包含 Cloud Foundry 用來將 Node.js 應用程序部署到 Bluemix 的信息。
• 將隱藏的 .cfignore 文件復制到您的本地 StrongLoop 應用程序“<alias>-loopback-example”的根目錄下。
• 修改本地 StrongLoop 的“package.json”文件來添加“cfenv”依賴項，並更改啟動腳本參數（參見下面的代碼段）
• 修改本地 StrongLoop 應用程序的 server/server.js 文件，使之包含 cfenv 要讀取的主機和端口。Bluemix 以環境變量形式提供這些參數。在下面的代碼段中，我修改了 StrongLoop 生成的 server.js 來反映這些更改。
• 從您的本地 StrongLoop 應用程序的根目錄刪除 node_modules 文件夾。

package.json 的代碼段：

"scripts":{
"start":"node server/server.js",
"pretest":"jshint ."
 },
"dependencies":{ 
..
"cfenv":"1.0.x"
..

server/server.js 的代碼段：

var loopback = require('loopback');
var boot = require('loopback-boot');
// cfenv provides access to your Cloud Foundry environment
// for more info, see: https://www.npmjs.com/package/cfenv
var cfenv = require('cfenv');
// get the app environment from Cloud Foundry
var appEnv = cfenv.getAppEnv();

var app = module.exports = loopback();
app.start = function() {
// start the web server
return app.listen(appEnv.port, appEnv.bind, function() {
app.emit('started');
console.log('Web server listening at:%s', app.get('url'));
});
};

// 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();
});

連接並登錄到 Bluemix：

cf api https://api.ng.bluemix.net
cf login -u <alias> -o <organization> -s <space>

使用 cf push 命令將您的應用程序推送到 Bluemix：

cf push <alias>-loopback-example

cf push 應在 Bluemix 上啟動一次 git 提交、git 推送，構建和部署。檢查您的 Bluemix 儀表板或 JazzHub “Build & Deploy” 頁面，確認您的應用程序現在已成功在 Bluemix 上運行！

http://www.ibm.com/developerworks/cn/cloud/blogs/strongloop-to-mysql-app/index.html

 

Node.js LoopBack 框架和 IBM Cloudant 入門

Node.js 是一個快速構建高性能的、可擴展的后端系統的優秀工具，它是使用大多數前端開發人員都已熟悉的核心語言 JavaScript 開發的。Node.js 正積極地進軍企業領域，許多重要企業正在 Node.js 基礎架構之上構建他們完整的 Web 系統和 API 服務。

StrongLoop 的 LoopBack 框架使您能夠輕松地連接數據並將數據公開為 REST 服務。它能夠在圖形（或命令行）界面中以可視方式創建數據模型，可以使用這些模型自動生成 REST API - 從而為您的 REST 服務層生成 CRUD 操作，無需編寫任何代碼。

為什么這很重要？它使 API 開發變得更容易，並顯著減少了從概念到實現所需的時間。觀看下面的視頻，了解它能為您做什么。

IBM Cloudant 是 IBM 的 NoSQL 數據庫即服務，它提供了大規模可伸縮性、強大的搜索特性、高可用性，可以幫助您更快交付解決方案，降低維護成本。

盡管對 StrongLoop 的收購仍只是“熱門新聞”，但您現在可以結合使用 LoopBack 和 Cloudant 來加速高度安全的 REST 應用層的開發。將這一點與 IBM MobileFirst 平台相結合，您將擁有一個更全面、更安全的移動應用程序解決方案。事實上，StrongLoop/LoopBack 和 Cloudant 現在都是 MobileFirst Platform 的一部分，但您仍能夠以獨立服務的形式在 IBM Bluemix 上獲取它們。

在本文中，我們將介紹如何借助 LoopBack 框架和 Strongloop Arc 工具，利用 IBM Cloudant 作為后端數據存儲。

在 LoopBack 框架中，是通過所謂的“數據連接器”來獲取和持久化數據。StrongLoop 維護着多個數據連接器，擁有針對開發人員社區所提供的更多后端數據存儲的連接器。

Cloudant 是一個 DBaaS 服務，是一個衍生的 Apache CouchDB，所以將 LoopBack 連接器連接到 Cloudant 很簡單，只需在您應用程序中使用現有的社區驅動的 CouchDB LoopBack Connector。我們來了解一下如何為您自己的應用程序執行此設置。

設置 IBM Cloudant

設置 Cloudant 很簡單。MobileFirst Platform Foundation Server 提供了 Cloudant 的一個有限的內部部署許可，或者您可以將 Cloudant 服務添加到 Bluemix 上的任何應用程序：您可以通過 REST 接口單獨使用 Cloudant，或者使用 Node.js/Cloudant Web Starter 模板來獲得 Node.js + Cloudant 多層解決方案。

我們來了解一下如何使用 Bluemix Starter 模板設置 Cloudant。在瀏覽器中導航到 Node.js/Cloudant Web Starter 模板，然后輸入一個應用程序名稱和應用程序主機（此信息將用在應用程序的 URL 前綴中），然后點擊“Create”按鈕。

圖 1.Node.js Cloudant Starter模板

點擊“Create”按鈕會創建一個 Cloudant NoSQL 數據庫實例以及 Bluemix 上的一個 Node.js 服務實例，我們以后可以將應用程序部署到該實例上。在您的應用程序正常運行后，會顯示一條消息。

您的服務在 Bluemix 上正常運行后，您將能夠直接使用 Cloud Foundry 命令行工具部署 Node.js 應用程序，使用 IBM Devops Services 或Bluemix Live Sync & GIT 進行部署，或者使用 Eclipse Tools for Bluemix。

接下來，我們需要創建我們的 Cloudant 數據庫實例，以便將它用於我們的 Node.js/LoopBack 應用程序。在您的 Bluemix 儀表板中，單擊“Cloudant NoSQL DB”服務鏈接來查看細節，然后單擊右上角的“Launch”按鈕來查看 Cloudant 儀表板。

進入 Cloudant 儀表板中后，您需要創建一個用於該應用程序的數據庫實例。選擇右上角的“Add New Database”鏈接。系統會提示您輸入一個數據庫名稱，然后點擊“Create”。

圖 2.創建一個新 Cloudant 數據庫

創建數據庫后，就可以設置您的本地開發環境並開始構建應用程序了。

 

回頁首

本地開發環境

如果還沒有安裝以下工具，需要下載並安裝它們：

• Node.js - 轉到 nodejs.org，按照說明安裝 Node.js。
• LoopBack - 接下來轉到 loopback.io，按照說明下載 LoopBack API 框架。您可能還希望查閱入門指南和文檔，了解有關的更多信息。
• Cloud Foundry CLI - Cloud Foundry 命令行界面用於手動將您的應用程序部署到 Bluemix。按照這些說明將 CF CLI 安裝在您的本地機器上。

 

回頁首

設置 Node.js/LoopBack App

在安裝了您環境所需的軟件后，現在可以開始創建您的 API 應用程序了。

我們需要做的第一件事是從命令行終端使用 LoopBack 應用程序生成器設置應用程序。您需要指定應用程序名稱和將創建該應用程序的子目錄。

$ slc loopback

_-----_
| | .--------------------------.
|--(o)--| |  Let's create a LoopBack |
`---------?′ | application! |
( _?′U`_ ) '--------------------------'
/___A___\
|  ~  |
__'.___.'__
 ?′ `  |?° ?′ Y `
?What's the name of your application? business-directory
?Enter name of the directory to contain the project: business-directory

創建應用程序后，下一步是創建連接器，使 LoopBack 框架能夠將數據存儲在 Cloudant 數據庫中。因為 Cloudant 是 CouchDB 的衍生產品，所以我們將使用 Community Connectors 下的 Apache CouchDB LoopBack 連接器。

在終端窗口中，使用 cd 命令進入剛生成的項目目錄中，然后使用 npm 安裝 loopback-couch-connector。

$ cd business-directory
$ npm install loopback-connector-couch

安裝連接器后，需要將 Cloudant 配置為可用於 LoopBack 框架的數據源。可以通過編程方式完成此設置，以便從環境配置中提取憑據。但是，為了簡便起見，我將展示該配置以及 datasource.json 配置文件中的憑據。

使用 JavaScript/text 編輯器打開 server/datasources.json 文件，添加“cloudant”，如下所示。您需要指定您的 Cloudant 主機 URL，以及訪問數據庫所需的身份驗證憑據。

{
"db":{
"name":"db",
"connector":"memory"
},
"cloudant":{
"host":"your-database-host-bluemix.cloudant.com",
"port":443,
"name":"cloudant",
"connector":"couch",
"db":"business-directory",
"protocol":"https",
"auth":{
"admin":{
"username":"your Cloudant admin user name",
"password":"your admin password"
},
"reader":{
"username":"your reader user name",
"password":"your reader password"
},
"writer":{
"username":"your writer username",
"password":"your writer password"
}
}
}
}

您可以查看 GitHub 上的 LoopBack CouchDB Connector 項目，了解更多的配置和使用信息。

LoopBack 框架擁有兩種構建數據模型的方式：命令行界面和 Arc Composer，后者是一種構建數據模型和 API 的圖形界面。

首先，我們將使用命令行工具設置一個數據模型。使用 slc loopback:model 生成器，執行以下步驟，在數據模型中創建一個“Company”條目。

$ slc loopback:model
?Enter the model name:Company
?Select the data-source to attach Company to: cloudant (couch)
?Select model's base class:PersistedModel
?Expose Company via the REST API?Yes
?Custom plural form (used to build REST URL):Companies
Let's add some Company properties now.
Enter an empty property name when done.
?Property name: name
?Property type: string
?Required?Yes
Let's add another Company property.
Enter an empty property name when done.
?Property name: address
?Property type: string
?Required?Yes
Let's add another Company property.
Enter an empty property name when done.
?Property name: city
?Property type: string
?Required?Yes
Let's add another Company property.
Enter an empty property name when done.
?Property name: state
?Property type: string
?Required?Yes
Let's add another Company property.
Enter an empty property name when done.
?Property name: zip
?Property type: string
?Required?Yes

這將生成數據模型的 Company.json 配置和 Company.js 類，您能夠擴展該類來添加自己的自定義邏輯。

Company.json：

{
"name":"Company",
"plural":"Companies",
"base":"PersistedModel",
"idInjection": true,
"options":{
"validateUpsert": true
},
"properties":{
"name":{
"type":"string",
"required": true
},
"address":{
"type":"string",
"required": true
},
"city":{
"type":"string",
"required": true
},
"state":{
"type":"string",
"required": true
},
"zip":{
"type":"string",
"required": true
}
},
"validations":[],
"relations":{},
"acls":[],
"methods":{}
}

Company.js：

module.exports = function(Company) {
//add your custom extension logic here
};

接下來，使用 Arc Composer 界面在我們的數據模型中創建更多的類。從終端窗口運行下面這個命令：

$ slc arc

這將啟動 StrongLoop Arc 圖形界面來與 LoopBack API/應用程序交互，然后為本地服務打開一個瀏覽器窗口。瀏覽器窗口打開后，單擊“Composer”圖標進入 GUI 來管理您的數據模型。

圖3

在 Composer 界面中，單擊“Add New Model”鏈接開始構建下一個類。輸入一個模型名稱“Employee”和復數形式“Employees”，然后確保選中了“PersistedModel”作為基礎模型，並選擇“cloudant”作為數據源。

接下來，將以下 3 個屬性添加到 Employee 模型中：

• name, string, required
• title, string, required
• company, string, required

保存模型后，將會生成兩個 JavaScript 文件：Employee.json 和 Employee.js。就像從命令行創建的 Company 模型一樣（上文），這兩個文件表示數據模型定義，以及一個可用來擴展模型來添加自己的自定義邏輯或行為的類。

Employee.json：

{
"name":"Employee",
"base":"PersistedModel",
"strict": false,
"idInjection": false,
"options":{
"validateUpsert": true
},
"properties":{
"name":{
"type":"string",
"required": true
},
"title":{
"type":"string",
"required": true
},
"companyId":{
"type":"number",
"required": true
}
},
"validations":[],
"relations":{},
"acls":[],
"methods":[]
}

Employee.js:

module.exports = function(Employee) {
//add your custom extension logic here
};

現在我們已經創建了兩個數據對象定義，接下來要在兩個對象之間定義一種關系。在命令行上，使用“slc loopback:relation”生成器命令創建一種關系。

slc loopback:relation
?Select the model to create the relationship from:Company
?Relation type: has many
?Choose a model to create a relationship with:Employee
?Enter the property name for the relation: employees
?Optionally enter a custom foreign key: company
?Require a through model?No

現在我們已經定義了數據並定義了一種關系，接下來開始與從數據模型自動生成的 REST API 交互。

如果您想知道這些關系的工作原理，因為我們沒有在模型中定義 id 值，所以這些 id 屬性會自動生成。

 

回頁首

與數據/服務交互

LoopBack 框架自動為您數據模型中的所有對象生成 REST 端點。它還會自動生成 Swagger API 文檔。這將為您項目生成的所有服務提供一個簡單易用的界面。我們現在來看一下生成的文檔……

在瀏覽器中返回到 Arc Composer 界面，單擊“App Controller”按鈕（右上角的三角形“play”按鈕）並啟動您的應用程序。運行您的應用程序后，在一個新瀏覽器窗口中打開 API 文檔：http://localhost:3000/explorer/（使用默認的本地配置）。

圖 4.自動生成的 Swagger 交互式文檔

從生成的文檔中，您可以看到所有已公開的與數據模型交互的 REST 方法。在這里，您還可以直接與這些服務交互和測試它們。單擊“Get /Companies”條目展開服務細節。使用“Try it out!”按鈕調用此服務。但是，您需要先使用“POST /Companies”方法插入一些數據，然后才能查詢它。

您可以轉到“POST /Companies”服務來插入一條包含以下數據的新記錄：

{
"name":"IBM",
"address":"1 New Orchard Road",
"city":"Armonk",
"state":"NY",
"zip":"10504"
}

這個服務可直接使用 REST 請求進行調用。

現在，我們查詢該數據，確保它已插入到數據庫中。從命令行終端，輸入下面的命令來查看 /Companies 查詢的輸出：

$ curl http://localhost:3000/api/Companies

您會看到與下面的結果類似的查詢結果，除了 id 和 _rev 值會有所不同。

[{"name":"IBM","address":"1 New Orchard Road","city":"Armonk","state":"NY",
"zip":"10504","id":"a5bee38b6ce94b163de664fd5b7bc9f0","_rev":"1-646f0565f4abc14a3bc6876e05f23ef0"}]

接下來，使用“POST /Companies/{id}/employees”方法添加一些員工。您可以使用資源管理器來提交數據，或者直接向 REST 服務提交數據。在本例中，我直接使用 curl 向 API 插入數據，但我將“{id}”替換成了數據庫實際生成的公司 ID。

$ curl -H "Content-Type: application/json"  -X POST -d 
'[{ "name":"Andrew Trice","title":"Developer Advocate"},
{ "name":"Ray Camden","title":"Developer Advocate"},
{ "name":"Marek Sadowski","title":"Developer Advocate"},
{ "name":"Kevin Hoyt","title":"Developer Advocate"},
{ "name":"Ken Parmelee","title":"Program Director"}]' 
http://localhost:3000/api/Companies/a5bee38b6ce94b163de664fd5b7bc9f0/employees

這些服務可用作 RESTful 端點，也可由任何應用程序使用，無論是移動應用程序、桌面應用程序，還是基於 Web 的應用程序。

 

回頁首

查詢和過濾數據

您可以調用 GET /Companies 來查詢所有公司，調用 GET /Employees 來查詢所有員工，或者調用 /Companies/{id}/employees 來查詢某個特定公司的所有員工，但 99.99% 的時間您都不希望這么做 - 它太一般化了，會返回太多數據，而且在邏輯或區分化的結構中沒有必要。

所以讓我們使用 LoopBack 框架的過濾器來縮小搜索結果范圍。LoopBack 框架支持使用 [where] 過濾器來縮小返回的記錄范圍，使用 [limit] 過濾器限制返回的結果數量，使用 [fields] 過濾器限制返回的一個對象的屬性，使用 [order] 確定結果順序，使用 [include] 過濾器包含相關模型，並使用 [skip] 過濾器跳過結果（用於數據分頁）。所有這些都可作為 REST 請求的參數來指定。

我們看看一些例子。

首先，返回所有頭銜為“Developer Advocate”的員工：

$ curl -g 'http://localhost:3000/api/employees?filter[where][title]=Developer%20Advocate'

[{"name":"Andrew Trice","title":"Developer Advocate","company":"a5bee38b6ce94b163de664fd5b7bc9f0",
"id":"31c71d93e2ff40c1f789e4d46cd7f2a0","_rev":"1-582ef49e3963af0f0ab6f4d97f1038c6"},
{"name":"Marek Sadowski","title":"Developer Advocate","company":"a5bee38b6ce94b163de664fd5b7bc9f0",
"id":"63d7631797106ddfafcae31d2bc70ced","_rev":"1-0967f7cb1b26f9ee619e8c76e3e08e74"},
{"name":"Kevin Hoyt","title":"Developer Advocate","company":"a5bee38b6ce94b163de664fd5b7bc9f0",
"id":"732ad7d6c368579caea6aa7caea89e4b","_rev":"1-8e220575e11c3973a2b6a3bca02658d5"},
{"name":"Ray Camden","title":"Developer Advocate","company":"a5bee38b6ce94b163de664fd5b7bc9f0",
"id":"8436dee94003f63667657b2a78b2170c","_rev":"1-c0d797c65fec2e2e2cc3497a589ef2f2"}]

但是，這些數據對我當前的需求而言太多了。讓我們僅返回同一個結果集中的 name 字段：

$curl -g 'http://localhost:3000/api/employees?filter[fields][name]=true
&filter[where][title]=Developer%20Advocate'
[{"name":"Andrew Trice"},
{"name":"Marek Sadowski"},
{"name":"Kevin Hoyt"},
{"name":"Ray Camden"}]

現在，想想您可能希望進一步限制返回的記錄數量：

$ curl -g 'http://localhost:3000/api/employees?filter[fields][name]=true
&filter[where][title]=Developer%20Advocate&filter[limit]=3'
[{"name":"Andrew Trice"},
{"name":"Marek Sadowski"},
{"name":"Kevin Hoyt"}]

如果您希望以不同順序排列這些結果，該怎么辦？我們可添加過濾器來提供按名稱的升序重新排列后的前 3 個結果：

curl -g 'http://localhost:3000/api/employees?filter[fields][name]=true
&filter[where][title]=Developer%20Advocate&filter[limit]=3&filter[order]=name%20DESC'
[{"name":"Ray Camden"},
{"name":"Marek Sadowski"},
{"name":"Kevin Hoyt"}]

 

回頁首

更新數據

可以向 API/id 發送 PUT 請求來輕松地更新數據。所以，如果您希望更新一位員工，可以向 /employees/{id} 發送一個僅包含您想要更新的值的 PUT 請求。

我們假設我想更新我的員工條目中的名稱……在本例中，我僅將包含“name”屬性的新值的 PUT 請求發送給 /Employees/{id}：

$ curl -H "Content-Type: application/json" -X PUT -g -d '{"name":"Andy Trice"}' 
'http://localhost:3000/api/Employees/31c71d93e2ff40c1f789e4d46cd7f2a0'
{"name":"Andy Trice","title":"Developer Advocate","company":"a5bee38b6ce94b163de664fd5b7bc9f0",
"id":"31c71d93e2ff40c1f789e4d46cd7f2a0","_rev":"6-88e83684b52cde686c08a84555e36d34"}

 

回頁首

遷移到雲

目前為止，我們已在本地開發機器上測試了所有代碼。如果您管理着自己的 Node.js 服務器，那么可以簡單地將您的代碼部署到生產環境。

我們還可以通過多種選擇將此應用程序遷移到雲中。首先讓我們來看看 Node.js 即時運行時，它包含在本文之前使用的 Cloudant 應用程序模板中。我們還可以選擇將此 API 部署到在 Bluemix 上一個容器中運行的 StrongLoop Process Manager。

Node.js 即時運行時

因為在本文開頭我們在 Bluemix 上創建了一個應用程序，所以我們繼續將它部署到該 Bluemix 即時運行時。

我們將使用 Cloud Foundry 命令行 API 將 Node.js 應用程序部署到 Bluemix，但需要先對 package.json 文件進行一些細微更改。在代碼編輯器中打開 package.json 后，添加“dependencies”和“bundle dependencies”，如下面的示例 package.json 所示：

{
"name":"business-directory",
"version":"1.0.0",
"main":"server/server.js",
"scripts":{
"pretest":"jshint ."
},
"dependencies":{
"compression":"^1.0.3",
"cors":"^2.5.2",
"errorhandler":"^1.1.1",
"loopback":"^2.14.0",
"loopback-boot":"^2.6.5",
"loopback-datasource-juggler":"^2.19.0",
"serve-favicon":"^2.0.1",
"loopback-connector-couch":"*",
"cfenv":"1.0.x"
},
"optionalDependencies":{
"loopback-explorer":"^1.1.0"
},
"devDependencies":{
"jshint":"^2.5.6"
},
"repository":{
"type":"",
"url":""
},
"description":"business-directory",
"bundleDependencies":[
"compression",
"cors",
"errorhandler",
"loopback",
"loopback-boot",
"loopback-connector-couch",
"loopback-datasource-juggler",
"loopback-explorer",
"serve-favicon"
]
}

接下來，我們需要在終端窗口中使用 CF CLI 登錄：

$ cf login

按照提示登錄到 Bluemix。

接下來，使用“cf push {app name}”將應用程序部署到 Bluemix。請注意“-c”選項，它會告訴節點從哪個命令開始。需要指定此選項是因為，它與默認的 Bluemix Node.js 應用程序配置稍微不同：

$ cf push LoopBack-Directory -c "node server/server.js"

將應用程序部署到 Bluemix 后，您會看到一個類似下文的摘要：

requested state: started
instances:1/1
usage:512M x 1 instances
urls: loopback-directory.mybluemix.net
last uploaded:Wed Aug 26 03:48:50 UTC 2015
stack: lucid64
buildpack:SDK for Node.js(TM) (ibm-node.js-0.12.7)
state since cpu memory disk details
#0 running 2015-08-25 11:50:29 PM 0.1% 120.5M of 512M 119.8M of 1G

在將應用程序部署到 Bluemix 后，就可以將 API 服務用在您的應用程序中。您可以自行查看 API 資源管理器和 API 端點：loopback-directory.mybluemix.net/explorer

備注：我限制了寫入訪問，所以您只能讀取數據。

 

回頁首

StrongLoop Process Manager

將 LoopBack 應用程序部署到生產中的第二個選擇是，使用 Bluemix 上的 StrongLoop Process Manager 容器。首先，導航到 Bluemix Catalog 並選擇“ibm-node-strong-pm”鏡像。

在獲得提示時，輸入一個容器名稱，然后確保請求並綁定了一個公共 IP，然后選擇應用程序要使用的端口。您需要使用端口 8701（由 Process Manager 使用），您的應用程序運行時默認情況下使用的端口為 3001，但您可以在 server/config.json 文件中配置您應用程序的端口。

圖 5.StrongLoop Process Manager 容器創建

確保請求的容器端口與 config.json 中應用程序使用的端口匹配，否則您無法訪問部署后的應用程序。這可能是像 HTTP 端口 80 這樣的標准端口，或者是像默認的 3001 這樣的一次性端口，后者一般用於開發。

在創建容器后，您就能夠使用本地機器上的 StrongLoop Process Manager 工具將應用程序部署到 Bluemix 上的遠程實例。

如果瀏覽器中仍打開着 StrongLoop Arc/Composer 工具，現在轉到該工具。如果沒有運行它，可以轉到命令行終端，並從您應用程序的目錄運行“slc arc”。

$ cd business-directory
$ slc arc

Arc 工具會自動在瀏覽器中啟動。接下來，我們需要為我們的遠程容器設置一個 PM 主機。轉到“Process Manager”視圖，選擇“Add PM Host”選項來按 IP 地址和端口添加新創建的容器。

圖 6.添加新 PM 主機

您可以在 Bluemix 儀表板中查看您的容器鏡像來獲得該 IP 地址和驗證綁定的端口。

圖 7.新建的 Docker Container 信息

接下來，轉到 Arc 工具中的 Build & Deploy 模塊。從這里選擇或構建一個您想要部署的歸檔文件，然后選擇您想要將應用程序部署到哪個主機。點擊“Deploy”按鈕后，就會部署該應用程序。

圖 8.使用 StrongLoop Arc 進行構建和部署

部署您的應用程序后，即可在指定的 IP 和端口上使用它。如果無法直接點擊您的應用程序，您可能需要跳回到 Process Manager 模塊來確保它的實例在正常運行。

 

回頁首

后續步驟

在將您應用程序的 API 應用到生產中后，您可以在任何可使用 REST 服務的應用程序中使用它，無論是移動應用程序、桌面應用程序，還是基於 Web 的應用程序。

LoopBack 和 IBM MobileFirst

我在上面已提到，您已經能夠利用 IBM MobileFirst 將 LoopBack 框架生成的 API 與應用程序集成。請查閱“使用LoopBack 構建的IBM MobileFirst 和Node.js API 入門”，更詳細地了解如何配置 MobileFirst Platform Foundation 服務器和 LoopBack/Node.js 應用程序，讓 MobileFirst 能夠管理身份驗證和對 Node.js API 的訪問，並捕獲將在 MobileFirst Analytics 控制台中報告的分析信息。

 

http://www.ibm.com/developerworks/cn/cloud/blogs/getting-started-node-js-loopback-framework-ibm-cloudant/index.html