Háttér
Engedje meg, hogy a LoopBack csinálja: Áttekintés a Node API Framework-ről, amelyről már álmodott
Felesleges megemlíteni a Node.js növekvő népszerűségét az alkalmazásfejlesztés terén. Az eBay 2011 óta működtet egy termelő Node API szolgáltatást. A PayPal aktívan újjáépíti a Node-ban lévő kezelőfelületüket. A Walmart mobil oldala a forgalom szempontjából a legnagyobb Node alkalmazás lett. A hálaadás hétvégéjén 2014-ben A Walmart szerverek 1,5 milliárd kérelmet dolgoztak fel , Amelynek 70 százalékát mobilon keresztül és a Node.js szolgáltatta. A fejlesztési oldalon a Node csomagkezelő ( tengerszint felett ) továbbra is gyorsan növekszik, a közelmúltban meghaladja a 150 000 hosztolt modult.
Míg Rubynak van Rails és Piton rendelkezik a Django-val, a Node domináns alkalmazásfejlesztési keretrendszerét még ki kell alakítani. De van egy erős versenyző, aki gőzt szerez: LoopBack , egy nyílt forráskódú API-keretrendszert, amelyet a kaliforniai San Mateo épített StrongLoop . A StrongLoop fontos hozzájárulás a legújabbhoz Csomópont verzió , nem is beszélve a Expressz , a létező egyik legnépszerűbb Node keretrendszer.
Vizsgáljuk meg közelebbről a LoopBack-et és annak képességeit azáltal, hogy mindent átültetünk a gyakorlatba, és felépítünk egy példaalkalmazást.
Mi a LoopBack és hogyan működik a Node-tal?
A LoopBack a API-k létrehozása és összekapcsolja őket háttér-adatforrásokkal. Az Express tetejére építve megadhat egy adatmodell-meghatározást, és könnyen létrehozhat egy teljesen működőképes végpontok közötti végső REST API-t, amelyet bármely ügyfél meghívhat.
A LoopBack beépített klienssel érkezik, API Explorer . Ezt használni fogjuk, mivel ez megkönnyíti a munkánk eredményeinek megtekintését, és így példánk magának az API-nak a felépítésére összpontosíthat.
A követéshez természetesen szüksége lesz a számítógépére telepített Node-ra. Szerezd meg itt . Az npm vele jár, így könnyen telepítheti a szükséges csomagokat. Lássunk neki.
Hozzon létre egy csontvázat
Alkalmazásunk kezeli azokat az embereket, akik ajándékokat vagy olyan dolgokat szeretnének felajánlani, akiknek már nincs szükségük rájuk. Tehát a felhasználók donorok és befogadók lesznek. Az adományozó új ajándékot hozhat létre, és megtekintheti az ajándékok listáját. A vevő láthatja az összes felhasználó ajándékainak listáját, és igényelhet minden igényt. Természetesen felépíthetnénk az Adományozókat és a Vevőket külön szerepként ugyanarra az entitásra (Felhasználóra), de próbáljuk szétválasztani őket, hogy lássuk, hogyan építhetünk kapcsolatokat a LoopBack-ben. Ennek az úttörő alkalmazásnak a neve lesz Ad valaki .
Telepítse a StrongLoop parancssori eszközöket az npm-en keresztül:
$ npm install -g strongloop Ezután futtassa a LoopBack alkalmazásgenerátort:
$ slc loopback _-----_ | | .--------------------------. |--(o)--| | Let's create a LoopBack | `---------´ | application! | ( _´U`_ ) '--------------------------' /___A___ | ~ | __'.___.'__ ´ ` |° ´ Y ` ? What's the name of your application? Givesomebody Adjunk hozzá egy modellt. Az első modellünk neve Gift lesz. A LoopBack meg fogja kérni az adatforrást és az alaposztályt. Mivel még nem állítottuk be az adatforrást, beírhatjuk a db (memory) Az alaposztály automatikusan generált modellosztály, és a PersistedModel -t akarjuk használni ebben az esetben, mivel már tartalmazza az összes számunkra szokásos CRUD módszert. Ezután a LoopBack megkérdezi, hogy ki kell-e tüntetnie a modellt a REST-en keresztül (igen), és a REST szolgáltatás nevét. Nyomja meg az Enter billentyűt az alapértelmezett érték használatához, amely egyszerűen a modellnév többes száma (esetünkben gifts).
$ slc loopback:model ? Enter the model name: Gift ? Select the data-source to attach Gift to: (Use arrow keys) ❯ db (memory) ? Select model's base class: (Use arrow keys) Model ❯ PersistedModel ? Expose Gift via the REST API? (Y/n) Yes ? Custom plural form (used to build REST URL): Végül megadjuk a tulajdonságok nevét, azok adattípusait és a kötelező / nem kötelező jelzőket. Az ajándéknak name és description tulajdonságok:
Let's add some Gift properties now. Enter an empty property name when done. ? Property name: name invoke loopback:property ? Property type: (Use arrow keys) ❯ string ? Required? (y/N)Yes Adjon meg egy üres tulajdonságnevet, jelezve, hogy végzett a tulajdonságok meghatározásával.
A modellgenerátor két fájlt hoz létre, amelyek meghatározzák a modellt az alkalmazás common/models: gift.json és gift.js. A JSON fájl meghatározza az entitás összes metaadatát: tulajdonságokat, relációkat, érvényesítéseket, szerepeket és metódusneveket. A JavaScript-fájl további viselkedés meghatározására, valamint bizonyos műveletek (például létrehozás, frissítés vagy törlés) előtt vagy után meghívandó távoli horgok meghatározására szolgál.
A másik két modell entitás Donor és Receiver modellünk lesz. Ugyanazon eljárással hozhatjuk létre őket, kivéve, hogy ezúttal tegyük fel User mint alaposztály. Ez ad nekünk néhány tulajdonságot, például username, password, email a dobozból. Hozzáadhatunk például csak nevet és országot, hogy teljes entitásunk legyen. A vevőhöz hozzá akarjuk adni a kézbesítési címet is.
Projekt felépítése
Vessünk egy pillantást a létrehozott projekt felépítésére:
A három fő könyvtár: - /server - Csomópont alkalmazás szkripteket és konfigurációs fájlokat tartalmaz. - /client - .js, .html, .css és minden más statikus fájlt tartalmaz. - /common - Ez a mappa közös a szerver és az ügyfél számára egyaránt. A modellfájlok ide kerülnek.
Itt található az egyes könyvtárak tartalmának részletes bontása, a LoopBack dokumentáció :
| Fájl vagy könyvtár | Leírás | Hogyan érhető el kódban |
|---|---|---|
| Felső szintű alkalmazáskönyvtár | ||
package.json | Normál npm csomag specifikáció. Lát csomag.json | N / A |
| / kiszolgáló könyvtár - Csomópont alkalmazásfájlok | ||
server.js | Fő alkalmazásfájl. | N / A |
config.json | Alkalmazás beállítások. Lát config.json . | app.get('setting-name') |
datasources.json | Az adatforrás konfigurációs fájlja. Lát adatforrások.json .Például lásd Hozzon létre új adatforrást . | app.datasources['datasource-name'] |
model-config.json | Modell konfigurációs fájl. Lát model-config.json .További információ: Modellek összekapcsolása adatforrásokkal . | N / A |
middleware.json | Középprogram definíciós fájl. További információ: A köztes szoftver meghatározása . | N / A |
/boot Könyvtár | Adjon hozzá szkripteket az inicializálás és a beállítás elvégzéséhez. Lát boot szkriptek . | A szkriptek automatikusan végrehajtódnak ábécé sorrendben. |
| / kliens könyvtár - kliens alkalmazásfájlok | ||
README.md | A LoopBack generátorok üres README fájlt hoznak létre Markdown formátumban. | N / A |
| Egyéb | Adja hozzá HTML, CSS, kliens JavaScript fájljait. | |
| / közös könyvtár - megosztott alkalmazásfájlok | ||
/models Könyvtár | Egyéni modellfájlok:
| Csomópont: myModel = app.models.myModelName |
Kapcsolatok építése
Példánkban néhány fontos kapcsolatot kell modelleznünk. Az adományozó sok ajándékot adományozhat, ami megadja a kapcsolatot Az adományozónak sok ajándéka van . A vevő sok ajándékot is kaphat, tehát nekünk is megvan a kapcsolatunk A vevő sok ajándékkal rendelkezik . A másik oldalon, Az ajándék Donoré , és szintén a Vevőhöz tartoznak ha az átvevő úgy dönt, hogy elfogadja. Tegyük ezt a LoopBack nyelvére.
A javascript ezredmásodpercben kapja meg az időt
$ slc loopback:relation ? Select the model to create the relationship from: Donor ? Relation type: has many ? Choose a model to create a relationship with: Gift ? Enter the property name for the relation: gifts ? Optionally enter a custom foreign key: ? Require a through model? No Vegye figyelembe, hogy nincs átmenő modell; csak az Ajándékra való hivatkozást tartjuk.
Ha megismételjük a fenti eljárást a Vevő esetében, és adjunk hozzá kettőt tartozik valamihez az ajándékhoz való kapcsolataival, akkor a modelltervünket a hátoldalon fogjuk megvalósítani. A LoopBack automatikusan frissíti a modellek JSON fájljait, hogy az egyszerű dialógusok segítségével pontosan kifejezzék azt, amit éppen tettünk:
// common/models/donor.json ... 'relations': { 'gifts': { 'type': 'hasMany', 'model': 'Gift', 'foreignKey': '' } }, ... Adjon hozzá egy adatforrást
Most nézzük meg, hogyan csatolhat valódi adatforrást az összes alkalmazásadatunk tárolásához. E példa céljaira a következőket fogjuk használni MongoDB , de a LoopBack rendelkezik olyan modulokkal, amelyekkel kapcsolatba lehet lépni az Oracle, a MySQL, a PostgreSQL, a Redis és az SQL Server szerverekkel.
Először telepítse a csatlakozót:
$ npm install --save loopback-connector-mongodb Ezután adjon hozzá egy adatforrást a projektjéhez:
$ slc loopback:datasource ? Enter the data-source name: givesomebody ? Select the connector for givesomebody: MongoDB (supported by StrongLoop) A következő lépés az adatforrás beállítása a server/datasources.json -ban. Használja ezt a konfigurációt egy helyi MongoDB kiszolgálóhoz:
... 'givesomebody': { 'name': 'givesomebody', 'connector': 'mongodb', 'host': 'localhost', 'port': 27017, 'database': 'givesomebody', 'username': '', 'password': '' } ... Végül nyissa meg a server/model-config.json és változtassa meg a datasource minden entitás számára, amelyet meg akarunk tartani az adatbázisban a 'givesomebody'
{ ... 'User': { 'dataSource': 'givesomebody' }, 'AccessToken': { 'dataSource': 'givesomebody', 'public': false }, 'ACL': { 'dataSource': 'givesomebody', 'public': false }, 'RoleMapping': { 'dataSource': 'givesomebody', 'public': false }, 'Role': { 'dataSource': 'givesomebody', 'public': false }, 'Gift': { 'dataSource': 'givesomebody', 'public': true }, 'Donor': { 'dataSource': 'givesomebody', 'public': true }, 'Receiver': { 'dataSource': 'givesomebody', 'public': true } } A REST API tesztelése
Ideje megnézni, mit építettünk eddig! Használni fogjuk a félelmetes beépített eszközt, API Explorer , amely az imént létrehozott szolgáltatás klienseként használható. Próbáljuk meg tesztelni REST API hívások.
Indítsa el a MongoDB programot egy külön ablakban:
$ mongod Futtassa az alkalmazást a következőkkel:
$ node . Böngészőjében lépjen a http://localhost:3000/explorer/ Megtekintheti az entitásokat az elérhető műveletek listájával. Próbáljon meg hozzáadni egy adományozót POST-tal /Donors hívás.
API Explorer nagyon intuitív; válassza ki az expozíciós módszerek bármelyikét, és a megfelelő modellséma megjelenik a jobb alsó sarokban. A data -ban szöveges területre, lehetőség van egyedi HTTP kérés írására. A kérelem kitöltése után kattintson a „Próbálja ki” gombra, és a kiszolgáló válasza alább jelenik meg.
Felhasználói hitelesítés
Mint fentebb említettük, az egyik entitás, amely a LoopBack segítségével előre fel van építve, a User osztály. A felhasználó rendelkezik bejelentkezési és kijelentkezési módszerekkel, és egy AccessToken entitáshoz köthető, amely megőrzi az adott felhasználó tokent. Valójában egy teljes felhasználói hitelesítési rendszer készen áll a dobozból való kilépésre. Ha megpróbáljuk felhívni /Donors/login keresztül API Explorer , itt van a válasz:
{ 'id': '9Kvp4zc0rTrH7IMMeRGwTNc6IqNxpVfv7D17DEcHHsgcAf9Z36A3CnPpZJ1iGrMS', 'ttl': 1209600, 'created': '2015-05-26T01:24:41.561Z', 'userId': '' } A id valójában az AccessToken értéke, automatikusan generálódik és fennmarad az adatbázisban. Amint itt látható, lehetőség van hozzáférési token beállítására és felhasználására minden további kéréshez.
Távoli módszerek
A távoli módszer a modell statikus módszere, amelyet egy egyedi REST végponton keresztül tesznek közzé. Távoli módszerek használhatók olyan műveletek végrehajtására, amelyeket nem a LoopBack szabványos modellje, a REST API biztosít.
A dobozból kikerülő CRUD módszerek mellett annyi egyéni metódust adhatunk hozzá, amennyit csak akarunk. Mindegyiküknek be kell mennie a [model].js fájl. Esetünkben adjunk hozzá egy távoli módszert az ajándék modellhez annak ellenőrzésére, hogy az ajándékot már lefoglaltuk-e, és egyet a nem lefoglalt ajándékok felsorolásával.
Először adjunk hozzá egy további tulajdonságot a reserved nevű modellhez. Csak adja hozzá ezt a gift.json tulajdonságokhoz:
... 'reserved': { 'type': 'boolean' } ... A távoli módszer a gift.js -ban valami ilyennek kell kinéznie:
module.exports = function(Gift) { // method which lists all free gifts Gift.listFree = function(cb) { Gift.find({ fields: { reserved: false } }, cb); }; // expose the above method through the REST Gift.remoteMethod('listFree', { returns: { arg: 'gifts', type: 'array' }, http: { path: '/list-free', verb: 'get' } }); // method to return if the gift is free Gift.isFree = function(id, cb) { var response; Gift.find({ fields: { id: id } }, function(err, gift) { if (err) return cb(err); if (gift.reserved) response = 'Sorry, the gift is reserved'; else response = 'Great, this gift can be yours'; }); cb(null, response); }; // expose the method through REST Gift.remoteMethod('isFree', { accepts: { arg: 'id', type: 'number' }, returns: { arg: 'response', type: 'string' }, http: { path: '/free', verb: 'post' } }); }; Tehát, hogy megtudja, rendelkezésre áll-e egy adott ajándék, az ügyfél most POST kérést küldhet a /api/Gifts/free címre, átadva a id a szóban forgó ajándék.
Távoli horgok
Néha szükség van valamilyen módszer végrehajtására a távoli módszer előtt vagy után. Kétféle távoli horgot határozhat meg:
beforeRemote()távoli módszer előtt fut.afterRemote()távoli módszer után fut.
Mindkét esetben két argumentumot ad meg: egy karakterláncot, amely megfelel annak a távoli metódusnak, amelyhez a funkciót „összekapcsolni” szeretné, és a visszahívási funkciót. A távoli horgok erejének nagy része abban rejlik, hogy a karakterlánc tartalmazhat helyettesítő karaktereket, így bármilyen illesztési módszer váltja ki.
Esetünkben állítsunk horgot az információk kinyomtatására a konzolba, valahányszor új donor jön létre. Ennek megvalósításához adjunk hozzá egy „létrehozás előtt” kampót a donor.js
module.exports = function(Donor) { Donor.beforeRemote('create', function(context, donor, next) { console.log('Saving new donor with name: ', context.req.body.name); next(); }); }; A kérést a megadott context és a next() visszahívást a köztes programokban (az alábbiakban tárgyaljuk) a horog lefutása után hívjuk meg.
Hozzáférés-vezérlők
A LoopBack alkalmazások modelleken keresztül férnek hozzá az adatokhoz, így az adatokhoz való hozzáférés ellenőrzése a modellekre vonatkozó korlátozások meghatározását jelenti; vagyis annak meghatározása, hogy ki vagy mi olvashatja és írhatja az adatokat, vagy hajthatja végre a módszereket a modelleken. A LoopBack hozzáférés-vezérléseket a hozzáférés-vezérlési listák vagy ACL-ek határozzák meg.
Engedjük meg, hogy a be nem jelentkező adományozók és fogadók megtekinthessék az ajándékokat, de csak a bejelentkezett adományozók hozhatják létre és törölhetik azokat.
$ slc loopback:acl Először is tagadjuk meg, hogy mindenki hozzáférjen az összes végponthoz.
? Select the model to apply the ACL entry to: Gift ? Select the ACL scope: All methods and properties ? Select the access type: All (match all types) ? Select the role: All users ? Select the permission to apply: Explicitly deny access Ezután engedje meg, hogy mindenki olvashasson az ajándék modellekből:
$ slc loopback:acl ? Select the model to apply the ACL entry to: Gift ? Select the ACL scope: All methods and properties ? Select the access type: Read ? Select the role: All users ? Select the permission to apply: Explicitly grant access Ezután engedélyezni szeretnénk a hitelesített felhasználóknak, hogy ajándékokat készítsenek:
$ slc loopback:acl ? Select the model to apply the ACL entry to: Gift ? Select the ACL scope: A single method ? Enter the method name: create ? Select the role: Any authenticated user ? Select the permission to apply: Explicitly grant access Végül engedjük meg, hogy az ajándék tulajdonosa bármilyen változtatást hajtson végre:
$ slc loopback:acl ? Select the model to apply the ACL entry to: Gift ? Select the ACL scope: All methods and properties ? Select the access type: Write ? Select the role: The user owning the object ? Select the permission to apply: Explicitly grant access Most, amikor átnézzük a gift.json -t, mindennek a helyén kell lennie:
'acls': [ { 'accessType': '*', 'principalType': 'ROLE', 'principalId': '$everyone', 'permission': 'DENY' }, { 'accessType': 'READ', 'principalType': 'ROLE', 'principalId': '$everyone', 'permission': 'ALLOW' }, { 'accessType': 'EXECUTE', 'principalType': 'ROLE', 'principalId': '$authenticated', 'permission': 'ALLOW', 'property': 'create' } ], Egy fontos megjegyzés itt: $authenticated egy előre definiált szerep, amely megfelel a rendszer összes felhasználójának (mind az adományozóknak, mind a befogadóknak), de csak azt szeretnénk engedélyezni, hogy az adományozók új ajándékokat készíthessenek. Ezért szükségünk van egy egyedi szerepre. Mivel a Role még egy entitás, amelyet kikerülünk a dobozból, kihasználhatjuk API hívását a $authenticatedDonor szerepet a rendszerbetöltési funkcióban, majd csak módosítsa a pricipalId a gift.json -ban.
Szükség lesz egy új fájl létrehozására, server/boot/script.js, és a következő kód hozzáadásával:
Role.create({ name: 'authenticatedDonor' }, function(err, role) { if (err) return debug(err); }) A RoleMapping entitás leképezi a szerepeket a felhasználókra. Győződjön meg arról, hogy a Role és a RoleMapping egyaránt ki vannak téve a REST-en keresztül. A server/model-config.json mezőben ellenőrizze, hogy 'public' értéke true a Role entitáshoz. Ezután a donor.js -ban írhatunk egy „létrehozás előtt” kampót, amely feltérképezi a userID és roleID a RoleMapping POST API hívásban.
Középprogram
A köztes szoftver olyan funkciókat tartalmaz, amelyek akkor kerülnek végrehajtásra, amikor a REST végponthoz kérelmet nyújtanak be. Mivel a LoopBack az Express-en alapul, az Express middleware-t használja, egy további koncepcióval, az úgynevezett „middleware fázisokkal”. A fázisok segítségével egyértelműen meghatározható a sorrend, amelyben a köztes szoftverekben lévő funkciókat meghívják.
Itt található az előre definiált fázisok listája, a LoopBack dokumentumok szerint:
- a kezdeti - Az első pont, amikor a köztes szoftver futtatható.
- ülés - Készítse elő a session objektumot.
- hiteles - Kezelje a hitelesítést és az engedélyezést.
- elemzés - A kérelem szervének elemzése.
- útvonalak - HTTP-útvonalak, amelyek megvalósítják az alkalmazás logikáját. Az Express API app.use, app.route, app.get (és más HTTP igék) útján regisztrált köztes szoftver ennek a fázisnak a kezdetén fut. Használja ezt a fázist olyan alalkalmazásokhoz is, mint a loopback / szerver / middleware / rest vagy loopback-explorer.
- fájlokat - Statikus eszközök kiszolgálása (a kérések itt érik a fájlrendszert).
- végső - Az ismeretlen URL-ekkel kapcsolatos hibák és kérések kezelése.
Minden fázisnak három alfázisa van. Például a kezdeti szakasz alfázisai a következők:
- kezdőbetű: előtt
- a kezdeti
- kezdőbetű: utána
Vessünk egy gyors pillantást az alapértelmezett middleware.json-ra:
{ 'initial:before': { 'loopback#favicon': {} }, 'initial': { 'compression': {}, 'cors': { 'params': { 'origin': true, 'credentials': true, 'maxAge': 86400 } } }, 'session': { }, 'auth': { }, 'parse': { }, 'routes': { }, 'files': { }, 'final': { 'loopback#urlNotFound': {} }, 'final:after': { 'errorhandler': {} } } A kezdeti szakaszban loopback.favicon() -t hívunk (| loopback#favicon az a hívás köztes azonosítója). Ezután harmadik fél npm moduljai compression és cors hívjuk (paraméterekkel vagy anélkül). Az utolsó szakaszban még két hívásunk van. urlNotFound egy LoopBack hívás, és errorhandler harmadik féltől származó modul. Ez a példa bemutatja, hogy sok beépített hívás használható, akárcsak a külső npm modulok. És természetesen mindig létrehozhatunk saját köztes szoftvert, és ezen a JSON fájlon keresztül hívhatjuk őket.
loopback-boot
Összefoglalásképpen említsünk meg egy modult, amely a boot() -t exportálja funkció, amely inicializálja az alkalmazást. A server/server.js -ban a következő kódrészletet találja meg, amely elindítja az alkalmazást:
boot(app, __dirname, function(err) { if (err) throw err; // start the server if `$ node server.js` if (require.main === module) app.start(); }); Ez a szkript a server/boot mappába, és töltse be az ott talált összes szkriptet ábécé sorrendbe. Így a server/boot -ban megadhatunk bármilyen szkriptet, amelyet az elején futtatnunk kell. Ilyen például a explorer.js, amely fut API Explorer , az API teszteléséhez használt kliens.
Következtetés
Mielőtt elhagylak, szeretném megemlíteni StrongLoop Arc , egy grafikus felhasználói felület, amely a slc alternatívájaként használható parancssori eszközök. Tartalmaz továbbá eszközöket a Node alkalmazások felépítéséhez, profilozásához és megfigyeléséhez. Azok számára, akik nem rajonganak a parancssorért, mindenképpen érdemes kipróbálni. A StrongLoop Arc azonban hamarosan megszűnik, és funkcionalitását integrálják az IBM API Connect Developer Toolkit .
Általánosságban elmondható, hogy a LoopBack sok kézi munkát takaríthat meg, mivel rengeteg dolgot kap ki a dobozból. Ez lehetővé teszi, hogy az alkalmazás-specifikus problémákra és az üzleti logikára koncentráljon. Ha a jelentkezésed az CRUD műveletek alapján és előre definiált entitások manipulálása, ha már nem tudja átírni a felhasználó hitelesítési és engedélyezési infrastruktúráját, amikor rengeteg fejlesztő írta ezt Ön előtt, vagy ha egy olyan nagyszerű webes keret előnyeit szeretné kihasználni, mint az Express, akkor építse fel a REST API-t A LoopBack megvalósíthatja álmait. Ez egy darab sütemény!
