ให้ LoopBack ทำมัน: บทสรุปของ Node API Framework ที่คุณเคยฝันถึง

ไม่จำเป็นต้องพูดถึงความนิยมที่เพิ่มขึ้นของ Node.js สำหรับการพัฒนาแอปพลิเคชัน eBay ใช้บริการ Node API เวอร์ชันที่ใช้งานจริงมาตั้งแต่ปี 2011 PayPal กำลังสร้าง front-end ใหม่ใน Node ไซต์บนมือถือของ Walmart ได้กลายเป็นแอปพลิเคชัน Node ที่ใหญ่ที่สุดในแง่ของการรับส่งข้อมูล ในช่วงสุดสัปดาห์วันขอบคุณพระเจ้าในปี 2014 เซิร์ฟเวอร์ของ Walmart ได้ประมวลผลคำขอ 1.5 พันล้านคำขอ โดย 70 เปอร์เซ็นต์ส่งผ่านมือถือและขับเคลื่อนโดย Node.js ในด้านการพัฒนา Node package manager (npm) ยังคงเติบโตอย่างรวดเร็ว โดยล่าสุดมีมากกว่า 150,000 โมดูลที่โฮสต์

ในขณะที่ Ruby มี Rails และ Python มี Django เฟรมเวิร์กการพัฒนาแอปพลิเคชันที่โดดเด่นสำหรับ Node ยังไม่ได้มีการจัดตั้งขึ้น แต่มีคู่แข่งรายหนึ่งที่มีพลังดึงดูด: LoopBack ซึ่งเป็นเฟรมเวิร์ก API แบบโอเพ่นซอร์สที่สร้างโดย San Mateo รัฐแคลิฟอร์เนีย บริษัท StrongLoop StrongLoop เป็นผู้สนับสนุนที่สำคัญใน Node เวอร์ชันล่าสุด ไม่ต้องพูดถึงผู้ดูแล Express มาเป็นเวลานาน ซึ่งเป็นหนึ่งใน Node framework ที่ได้รับความนิยมมากที่สุด

มาดูรายละเอียดของ LoopBack และความสามารถของมันกันดีกว่า โดยเปลี่ยนทุกอย่างให้กลายเป็นการปฏิบัติ และสร้างแอปพลิเคชันตัวอย่าง

LoopBack คืออะไรและทำงานอย่างไรกับโหนด

LoopBack เป็นเฟรมเวิร์กสำหรับสร้าง API และเชื่อมต่อกับแหล่งข้อมูลแบ็กเอนด์ สร้างขึ้นบน Express ซึ่งสามารถกำหนดรูปแบบข้อมูลและสร้าง REST API แบบ end-to-end ที่ทำงานได้อย่างสมบูรณ์ซึ่งไคลเอ็นต์สามารถเรียกใช้ได้

LoopBack มาพร้อมกับไคลเอนต์ในตัว API Explorer เราจะใช้สิ่งนี้เพราะจะทำให้เห็นผลงานของเราได้ง่ายขึ้น และเพื่อให้ตัวอย่างของเรามุ่งเน้นไปที่การสร้าง API ได้เอง

คุณจะต้องติดตั้ง Node บนเครื่องของคุณเพื่อติดตาม รับที่นี่ npm มาพร้อมกับมัน ดังนั้นคุณจึงสามารถติดตั้งแพ็คเกจที่จำเป็นได้อย่างง่ายดาย มาเริ่มกันเลย.

สร้างโครงกระดูก

แอปพลิเคชันของเราจะจัดการผู้ที่ต้องการบริจาคของขวัญ หรือสิ่งที่พวกเขาไม่ต้องการอีกต่อไป ให้กับบุคคลที่อาจต้องการ ดังนั้นผู้ใช้จะเป็นผู้บริจาคและผู้รับ ผู้บริจาคสามารถสร้างของขวัญใหม่และดูรายการของขวัญได้ ผู้รับสามารถดูรายการของขวัญจากผู้ใช้ทั้งหมด และสามารถอ้างสิทธิ์ใดๆ ที่ไม่มีการอ้างสิทธิ์ได้ แน่นอน เราสามารถสร้างผู้บริจาคและผู้รับเป็นบทบาทที่แยกจากกันในเอนทิตีเดียวกัน (ผู้ใช้) แต่มาลองแยกกันเพื่อให้เราเห็นว่าจะสร้างความสัมพันธ์ใน LoopBack ได้อย่างไร ชื่อของแอปพลิเคชั่นที่ก้าวล้ำนี้จะเป็น Givesomebody

ติดตั้งเครื่องมือบรรทัดคำสั่ง StrongLoop ผ่าน npm:

 $ npm install -g strongloop

จากนั้นเรียกใช้ตัวสร้างแอปพลิเคชันของ LoopBack:

 $ slc loopback _-----_ | | .--------------------------. |--(o)--| | Let's create a LoopBack | `--------- | application! | ( _U`_ ) '--------------------------' /___A___\ | ~ | __'.___.'__ ` |° Y ` ? What's the name of your application? Givesomebody

มาเพิ่มโมเดลกันเถอะ รุ่นแรกของเราจะเรียกว่าของขวัญ LoopBack จะขอแหล่งข้อมูลและคลาสฐาน เนื่องจากเรายังไม่ได้ตั้งค่าแหล่งข้อมูล เราจึงสามารถใส่ db (memory) ได้ คลาสพื้นฐานเป็นคลาสโมเดลที่สร้างขึ้นโดยอัตโนมัติ และเราต้องการใช้ PersistedModel ในกรณีนี้ เนื่องจากมีเมธอด CRUD ปกติทั้งหมดสำหรับเราอยู่แล้ว ถัดไป LoopBack จะถามว่าควรเปิดเผยโมเดลผ่าน REST (ใช่) และชื่อของบริการ REST หรือไม่ กด Enter ที่นี่เพื่อใช้ค่าเริ่มต้น ซึ่งเป็นเพียงพหูพจน์ของชื่อรุ่น (ในกรณีของเราคือ 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):

สุดท้าย เราให้ชื่อของคุณสมบัติ ชนิดข้อมูล และแฟล็กที่จำเป็น/ไม่จำเป็น ของขวัญจะมีคุณสมบัติ name และ description :

 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

ป้อนชื่อคุณสมบัติว่างเพื่อระบุว่าคุณกำหนดคุณสมบัติเสร็จแล้ว

ตัวสร้างโมเดลจะสร้างไฟล์สองไฟล์ซึ่งกำหนดโมเดลใน common/models ของแอปพลิเคชัน: gift.json และ gift.js ไฟล์ JSON ระบุข้อมูลเมตาทั้งหมดเกี่ยวกับเอนทิตี: คุณสมบัติ ความสัมพันธ์ การตรวจสอบ บทบาท และชื่อเมธอด ไฟล์ JavaScript ใช้เพื่อกำหนดลักษณะการทำงานเพิ่มเติม และเพื่อระบุ hooks ระยะไกลที่จะเรียกก่อนหรือหลังการดำเนินการบางอย่าง (เช่น สร้าง อัปเดต หรือลบ)

อีกสองเอนทิตีโมเดลจะเป็นโมเดลผู้บริจาคและผู้รับของเรา เราสามารถสร้างมันได้โดยใช้กระบวนการเดียวกัน ยกเว้นคราวนี้เราจะใส่ User เป็นคลาสพื้นฐาน มันจะให้คุณสมบัติบางอย่างแก่เราเช่น username , password , email จากกล่อง เราเพิ่มแค่ชื่อและประเทศได้ เช่น เพื่อให้มีเอนทิตีแบบเต็ม สำหรับผู้รับ เราต้องการเพิ่มที่อยู่ในการจัดส่งด้วย

โครงสร้างโครงการ

มาดูโครงสร้างโครงการที่สร้างขึ้น:

ไดเร็กทอรีหลักสามไดเร็กทอรีคือ: - /server – ประกอบด้วยสคริปต์แอปพลิเคชันโหนดและไฟล์คอนฟิกูเรชัน - /client – ​​ประกอบด้วย .js, .html, .css และไฟล์สแตติกอื่นๆ ทั้งหมด - /common – โฟลเดอร์นี้ใช้ร่วมกันสำหรับทั้งเซิร์ฟเวอร์และไคลเอนต์ ไฟล์รุ่นไปที่นี่

นี่คือรายละเอียดโดยละเอียดของเนื้อหาของแต่ละไดเร็กทอรี ซึ่งนำมาจากเอกสารประกอบของ LoopBack:

สร้างสัมพันธ์

ในตัวอย่างของเรา เรามีความสัมพันธ์ที่สำคัญสองสามประการในการสร้างแบบจำลอง ผู้บริจาคสามารถบริจาคของขวัญได้มากมาย ซึ่งทำให้ความสัมพันธ์ ผู้บริจาคมีของขวัญ มากมาย ผู้รับยังสามารถได้รับของขวัญมากมาย ดังนั้นเราจึงมีความสัมพันธ์ ผู้รับมีของขวัญ มากมาย ในอีกด้านหนึ่ง ของขวัญเป็นของผู้บริจาค และยังสามารถ เป็นของผู้รับ ได้หากผู้รับเลือกที่จะยอมรับ มาใส่สิ่งนี้เป็นภาษาของ LoopBack

 $ 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

โปรดทราบว่าไม่มีโมเดลผ่าน เราแค่ถือการอ้างอิงถึงของขวัญ

หากเราทำซ้ำขั้นตอนข้างต้นสำหรับผู้รับ และเพิ่มสองเกี่ยวข้อง กับ ความสัมพันธ์กับของขวัญ เราจะทำการออกแบบแบบจำลองของเราให้สำเร็จที่ส่วนหลัง LoopBack อัปเดตไฟล์ JSON สำหรับโมเดลโดยอัตโนมัติเพื่อแสดงสิ่งที่เราเพิ่งทำผ่านกล่องโต้ตอบง่ายๆ เหล่านี้:

 // common/models/donor.json ... "relations": { "gifts": { "type": "hasMany", "model": "Gift", "foreignKey": "" } }, ...

เพิ่มแหล่งข้อมูล

ตอนนี้เรามาดูวิธีการแนบแหล่งข้อมูลจริงเพื่อเก็บข้อมูลแอปพลิเคชันทั้งหมดของเรา สำหรับจุดประสงค์ของตัวอย่างนี้ เราจะใช้ MongoDB แต่ LoopBack มีโมดูลสำหรับเชื่อมต่อกับ Oracle, MySQL, PostgreSQL, Redis และ SQL Server

ขั้นแรก ติดตั้งตัวเชื่อมต่อ:

 $ npm install --save loopback-connector-mongodb

จากนั้น เพิ่มแหล่งข้อมูลในโครงการของคุณ:

 $ slc loopback:datasource ? Enter the data-source name: givesomebody ? Select the connector for givesomebody: MongoDB (supported by StrongLoop)

ขั้นตอนต่อไปคือการกำหนดค่าแหล่งข้อมูลของคุณใน server/datasources.json ใช้การกำหนดค่านี้สำหรับเซิร์ฟเวอร์ MongoDB ภายในเครื่อง:

 ... "givesomebody": { "name": "givesomebody", "connector": "mongodb", "host": "localhost", "port": 27017, "database": "givesomebody", "username": "", "password": "" } ...

สุดท้าย เปิด server/model-config.json และเปลี่ยน datasource สำหรับเอนทิตีทั้งหมดที่เราต้องการคงอยู่ในฐานข้อมูลเป็น "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 } }

การทดสอบ REST API ของคุณ

ถึงเวลาที่จะได้เห็นสิ่งที่เราสร้างขึ้นมาจนถึงตอนนี้! เราจะใช้เครื่องมือในตัวที่ยอดเยี่ยม API Explorer ซึ่งสามารถใช้เป็นไคลเอนต์สำหรับบริการที่เราเพิ่งสร้างขึ้น มาลองทดสอบการเรียก REST API กัน

ในหน้าต่างแยกต่างหาก เริ่ม MongoDB ด้วย:

 $ mongod

เรียกใช้แอปพลิเคชันด้วย:

 $ node .

ในเบราว์เซอร์ของคุณ ไปที่ http://localhost:3000/explorer/ คุณสามารถดูเอนทิตีของคุณด้วยรายการการดำเนินงานที่พร้อมใช้งาน ลองเพิ่มผู้บริจาคหนึ่งรายด้วยการเรียก POST /Donors

API Explorer นั้นใช้งานง่ายมาก เลือกวิธีการเปิดเผยใดๆ และสคีมาแบบจำลองที่เกี่ยวข้องจะแสดงที่มุมล่างขวา ในพื้นที่ข้อความ data เป็นไปได้ที่จะเขียนคำขอ HTTP ที่กำหนดเอง เมื่อกรอกคำขอแล้ว ให้คลิกปุ่ม "ลองใช้" แล้วการตอบกลับของเซิร์ฟเวอร์จะปรากฏขึ้นด้านล่าง

การตรวจสอบผู้ใช้

ดังที่กล่าวไว้ข้างต้น หนึ่งในเอนทิตีที่สร้างไว้ล่วงหน้าด้วย LoopBack คือคลาสผู้ใช้ ผู้ใช้มีวิธีการเข้าสู่ระบบและออกจากระบบ และสามารถเชื่อมโยงกับเอนทิตี AccessToken ซึ่งเก็บโทเค็นของผู้ใช้เฉพาะไว้ อันที่จริง ระบบตรวจสอบสิทธิ์ผู้ใช้แบบสมบูรณ์พร้อมที่จะออกจากกล่อง หากเราลองโทร /Donors/login ผ่าน API Explorer นี่คือคำตอบที่เราได้รับ:

 { "id": "9Kvp4zc0rTrH7IMMeRGwTNc6IqNxpVfv7D17DEcHHsgcAf9Z36A3CnPpZJ1iGrMS", "ttl": 1209600, "created": "2015-05-26T01:24:41.561Z", "userId": "" }

จริง ๆ แล้ว id เป็นค่าของ AccessToken ซึ่งสร้างและคงอยู่ในฐานข้อมูลโดยอัตโนมัติ ดังที่คุณเห็นในที่นี้ คุณสามารถตั้งค่าโทเค็นเพื่อการเข้าถึงและใช้สำหรับคำขอที่ตามมาในแต่ละครั้ง

วิธีการทางไกล

วิธีระยะไกลเป็นวิธีการแบบคงที่ของโมเดล โดยเปิดเผยผ่านปลายทาง REST ที่กำหนดเอง สามารถใช้เมธอดระยะไกลเพื่อดำเนินการที่ไม่ได้มาจาก REST API รุ่นมาตรฐานของ LoopBack

นอกจากวิธีการ CRUD ที่เรานำมาใช้แล้ว เรายังเพิ่มวิธีการที่กำหนดเองได้มากเท่าที่ต้องการ ทั้งหมดควรไปที่ไฟล์ [model].js ในกรณีของเรา ให้เพิ่มวิธีระยะไกลให้กับโมเดลของขวัญเพื่อตรวจสอบว่าของขวัญถูกจองไว้แล้วหรือไม่ และอีกวิธีหนึ่งจะแสดงรายการของขวัญทั้งหมดที่ไม่ได้จองไว้

ขั้นแรก ให้เพิ่มคุณสมบัติเพิ่มเติมให้กับโมเดลที่เรียกว่า reserved เพียงเพิ่มสิ่งนี้ไปยังคุณสมบัติใน gift.json :

 ... "reserved": { "type": "boolean" } ...

วิธีการระยะไกลใน gift.js ควรมีลักษณะดังนี้:

 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' } }); };

ดังนั้น หากต้องการทราบว่าของขวัญชิ้นใดมีอยู่หรือไม่ ขณะนี้ลูกค้าสามารถส่งคำขอ POST ไปที่ /api/Gifts/free โดยส่ง id ของของขวัญที่เป็นปัญหา

ตะขอระยะไกล

บางครั้งมีความจำเป็นสำหรับการดำเนินการของวิธีการบางอย่างก่อนหรือหลังวิธีการระยะไกล คุณสามารถกำหนด hooks ระยะไกลได้สองประเภท:

• beforeRemote() ทำงานก่อนเมธอดรีโมต
• afterRemote() ทำงานหลังจากวิธีการระยะไกล

ในทั้งสองกรณี คุณระบุอาร์กิวเมนต์สองอย่าง: สตริงที่ตรงกับเมธอดรีโมตที่คุณต้องการ "เชื่อมต่อ" ฟังก์ชันของคุณ และฟังก์ชันเรียกกลับ พลังส่วนใหญ่ของ hooks ระยะไกลคือสตริงสามารถรวม wildcard ได้ ดังนั้นมันจึงถูกทริกเกอร์โดยวิธีการจับคู่ใดๆ

ในกรณีของเรา เรามาตั้งค่าให้พิมพ์ข้อมูลไปที่คอนโซลทุกครั้งที่มีการสร้างผู้บริจาคใหม่ เพื่อให้บรรลุสิ่งนี้ ให้เพิ่มเบ็ด “ก่อนสร้าง” ใน 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(); }); };

คำขอถูกเรียกด้วย context ที่กำหนด และการเรียกกลับ next() ในมิดเดิลแวร์ (ที่กล่าวถึงด้านล่าง) จะถูกเรียกหลังจากที่เบ็ดทำงาน

การควบคุมการเข้าถึง

แอปพลิเคชัน LoopBack เข้าถึงข้อมูลผ่านโมเดล ดังนั้นการควบคุมการเข้าถึงข้อมูลหมายถึงการกำหนดข้อจำกัดบนโมเดล กล่าวคือ การระบุว่าใครหรือสิ่งใดสามารถอ่านและเขียนข้อมูลหรือดำเนินการเมธอดบนตัวแบบได้ การควบคุมการเข้าถึง LoopBack ถูกกำหนดโดยรายการควบคุมการเข้าถึงหรือ ACL

อนุญาตให้ผู้บริจาคและผู้รับที่ไม่ได้เข้าสู่ระบบเพื่อดูของขวัญ แต่เฉพาะผู้บริจาคที่เข้าสู่ระบบเท่านั้นที่จะสร้างและลบออก

 $ 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: All (match all types) ? Select the role: All users ? Select the permission to apply: Explicitly deny access

ต่อไป ให้ทุกคนอ่านจากโมเดลของขวัญ:

 $ 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

จากนั้น เราต้องการอนุญาตให้ผู้ใช้ที่ตรวจสอบสิทธิ์สร้างของขวัญ:

 $ 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

และสุดท้าย ให้เจ้าของของขวัญทำการเปลี่ยนแปลง:

 $ 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

ตอนนี้เมื่อเราตรวจสอบ gift.json ทุกอย่างควรเข้าที่:

 "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" } ],

หมายเหตุสำคัญประการหนึ่ง: $authenticated คือบทบาทที่กำหนดไว้ล่วงหน้าซึ่งสอดคล้องกับผู้ใช้ทั้งหมดในระบบ (ทั้งผู้บริจาคและผู้รับ) แต่เราต้องการอนุญาตให้ผู้บริจาคสร้างของขวัญใหม่เท่านั้น ดังนั้นเราจึงต้องการบทบาทที่กำหนดเอง เนื่องจาก Role เป็นเอนทิตีอีกหนึ่งอย่างที่เราทำได้ตั้งแต่เริ่มต้น เราสามารถใช้ประโยชน์จากการเรียก API เพื่อสร้างบทบาท $authenticatedDonor ในฟังก์ชันการบูต จากนั้นเพียงแค่แก้ไข pricipalId ใน gift.json

จำเป็นต้องสร้างไฟล์ใหม่ server/boot/script.js และเพิ่มรหัสต่อไปนี้:

 Role.create({ name: 'authenticatedDonor' }, function(err, role) { if (err) return debug(err); })

เอนทิตี RoleMapping แมปบทบาทกับผู้ใช้ ตรวจสอบให้แน่ใจว่าทั้ง Role และ RoleMapping เปิดเผยผ่าน REST ใน server/model-config.json ให้ตรวจสอบว่าตั้งค่า "public" เป็น true สำหรับเอนทิตีบทบาท จากนั้นใน donor.js เราสามารถเขียน hook "ก่อนสร้าง" ที่จะจับ roleID userID การเรียก RoleMapping POST API

มิดเดิลแวร์

มิดเดิลแวร์มีฟังก์ชันที่ดำเนินการเมื่อมีการร้องขอไปยังปลายทาง REST เนื่องจาก LoopBack ทำงานบน Express จึงใช้มิดเดิลแวร์ Express พร้อมแนวคิดเพิ่มเติมหนึ่งแนวคิด เรียกว่า “ระยะมิดเดิลแวร์” เฟสใช้เพื่อกำหนดลำดับการเรียกใช้ฟังก์ชันในมิดเดิลแวร์อย่างชัดเจน

นี่คือรายการของเฟสที่กำหนดไว้ล่วงหน้า ตามที่ให้ไว้ในเอกสาร LoopBack:

1. เริ่มต้น - จุดแรกที่มิดเดิลแวร์สามารถเรียกใช้ได้
2. เซสชัน - เตรียมวัตถุเซสชัน
3. auth - จัดการการพิสูจน์ตัวตนและการอนุญาต
4. parse - แยกวิเคราะห์เนื้อหาที่ร้องขอ
5. เส้นทาง - เส้นทาง HTTP ที่ใช้ตรรกะของแอปพลิเคชันของคุณ มิดเดิลแวร์ที่ลงทะเบียนผ่าน Express API app.use, app.route, app.get (และกริยา HTTP อื่นๆ) จะทำงานเมื่อเริ่มต้นเฟสนี้ ใช้เฟสนี้สำหรับแอปย่อยเช่น loopback/server/middleware/rest หรือ loopback-explorer ด้วย
6. ไฟล์ - ให้บริการสินทรัพย์คงที่ (คำขอกำลังส่งถึงระบบไฟล์ที่นี่)
7. สุดท้าย - จัดการกับข้อผิดพลาดและคำขอสำหรับ URL ที่ไม่รู้จัก

แต่ละเฟสมีสามเฟสย่อย ตัวอย่างเช่น เฟสย่อยของเฟสเริ่มต้นคือ:

1. ชื่อย่อ: before
2. อักษรย่อ
3. ชื่อย่อ:หลัง

มาดูค่า default ของ Middleware.json กัน:

 { "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": {} } }

ในระยะเริ่มต้น เราเรียก loopback.favicon() ( loopback#favicon คือรหัสมิดเดิลแวร์สำหรับการโทรนั้น) จากนั้นจะเรียก compression โมดูล cors ของบริษัทอื่นและคอร์ (มีหรือไม่มีพารามิเตอร์) ในระยะสุดท้าย เรามีการโทรเพิ่มอีกสองครั้ง urlNotFound คือการโทรแบบวนซ้ำ และ errorhandler คือโมดูลของบริษัทอื่น ตัวอย่างนี้ควรแสดงให้เห็นว่าสามารถใช้การเรียกในตัวจำนวนมากได้เช่นเดียวกับโมดูล npm ภายนอก และแน่นอน เราสามารถสร้างมิดเดิลแวร์ของเราเองและเรียกใช้ผ่านไฟล์ JSON นี้ได้

loopback-boot

ในการสรุป ให้พูดถึงโมดูลที่ส่งออกฟังก์ชัน boot() ที่เริ่มต้นแอปพลิเคชัน ใน server/server.js คุณจะพบโค้ดต่อไปนี้ ซึ่งจะบูตแอปพลิเคชัน:

 boot(app, __dirname, function(err) { if (err) throw err; // start the server if `$ node server.js` if (require.main === module) app.start(); });

สคริปต์นี้จะค้นหาโฟลเดอร์ server/boot และโหลดสคริปต์ทั้งหมดที่พบตามลำดับตัวอักษร ดังนั้นใน server/boot เราสามารถระบุสคริปต์ใด ๆ ที่ควรรันเมื่อเริ่มต้น ตัวอย่างหนึ่งคือ explorer.js ซึ่งเรียก ใช้ API Explorer ซึ่งเป็นไคลเอ็นต์ที่เราใช้ในการทดสอบ API ของเรา

บทสรุป

ก่อนที่ฉันจะจากคุณไป ฉันอยากจะพูดถึง StrongLoop Arc ซึ่งเป็น UI แบบกราฟิกที่สามารถใช้เป็นทางเลือกแทนเครื่องมือบรรทัดคำสั่ง slc นอกจากนี้ยังมีเครื่องมือสำหรับการสร้าง การทำโปรไฟล์ และตรวจสอบแอปพลิเคชันโหนด สำหรับผู้ที่ไม่ชอบบรรทัดคำสั่งนี่คุ้มค่าที่จะลอง อย่างไรก็ตาม StrongLoop Arc กำลังจะเลิกใช้ และฟังก์ชันการทำงานกำลังถูกรวมเข้ากับ IBM API Connect Developer Toolkit

โดยทั่วไปแล้ว LoopBack สามารถช่วยคุณประหยัดงานด้วยตนเองได้มาก เนื่องจากคุณได้รับสิ่งต่างๆ มากมายจากกล่อง ช่วยให้คุณมุ่งเน้นไปที่ปัญหาเฉพาะแอปพลิเคชันและตรรกะทางธุรกิจ หากแอปพลิเคชันของคุณใช้การดำเนินการ CRUD และจัดการเอนทิตีที่กำหนดไว้ล่วงหน้า หากคุณเบื่อที่จะเขียนโครงสร้างพื้นฐานการพิสูจน์ตัวตนและการอนุญาตของผู้ใช้ใหม่เมื่อมีนักพัฒนาจำนวนมากเขียนสิ่งนั้นต่อหน้าคุณ หรือหากคุณต้องการใช้ประโยชน์จากข้อดีทั้งหมดของกรอบงานเว็บที่ยอดเยี่ยม เช่น Express จากนั้นสร้าง REST API ด้วย LoopBack สามารถทำให้ความฝันของคุณเป็นจริงได้ มันเป็นเค้กชิ้นหนึ่ง!