การใช้สถาปัตยกรรมที่สะอาดด้วย Nest.JS

บทความนี้เหมาะสำหรับผู้ที่ชื่นชอบการเขียนโค้ดที่สะอาด ปรับขนาดได้ และที่สำคัญกว่านั้นสามารถรีแฟกเตอร์ได้ จะให้แนวคิดเกี่ยวกับวิธีที่ Nest.JS สามารถช่วยเราเขียนโค้ดที่สะอาดและสถาปัตยกรรมพื้นฐานที่ใช้

การใช้สถาปัตยกรรมที่สะอาดด้วย Nest.JS จะทำให้เราต้องเข้าใจก่อนว่าเฟรมเวิร์กนี้คืออะไรและทำงานอย่างไร

Nest หรือ Nest.JS เป็นเฟรมเวิร์กสำหรับการสร้างแอปพลิเคชัน Node.js ที่มีประสิทธิภาพและปรับขนาดได้ (ฝั่งเซิร์ฟเวอร์) ที่สร้างด้วย TypeScript ใช้ Express หรือ Fastify และอนุญาตให้มีระดับนามธรรมเพื่อให้นักพัฒนาสามารถใช้โมดูลจำนวนมาก (บุคคลที่สาม) ภายในโค้ดของตนได้

มาเจาะลึกกันว่าสถาปัตยกรรมที่สะอาดตานี้เกี่ยวกับอะไร 

ทุกคนคงเคยใช้หรืออย่างน้อยก็เคยได้ยินเกี่ยวกับสถาปัตยกรรม MVC MVC ย่อมาจาก Model, View, Controller แนวคิดเบื้องหลังนี้คือการแยกโครงสร้างโครงการของเราออกเป็น 3 ส่วนที่แตกต่างกัน

1 แบบ: มันจะมีไฟล์อ็อบเจ็กต์ซึ่งแมปกับความสัมพันธ์/เอกสารในฐานข้อมูล

2. ตัวควบคุม: มันคือตัวจัดการคำขอและมีหน้าที่รับผิดชอบในการใช้งานตรรกะทางธุรกิจและการจัดการข้อมูลทั้งหมด

3. ดู: ส่วนนี้จะมีไฟล์ที่เกี่ยวข้องกับการแสดงข้อมูล ไม่ว่าจะเป็นไฟล์ HTML หรือไฟล์เอ็นจิ้นการสร้างเทมเพลตบางไฟล์

ในการสร้างแบบจำลอง เราจำเป็นต้องมีเครื่องมือ/โมดูล/ไลบรารี ORM/ODM บางประเภทเพื่อสร้างด้วย ตัวอย่างเช่น หากคุณใช้โมดูลโดยตรง สมมติว่า 'สร้างภาคต่อ' จากนั้นใช้สิ่งเดียวกันนี้เพื่อเข้าสู่ระบบในตัวควบคุมของคุณ และทำให้ตรรกะทางธุรกิจหลักของคุณขึ้นอยู่กับ 'ผลสืบเนื่อง' โดยรวมแล้ว สมมุติว่าหลังจาก 10 ปีที่ผ่านมา มีเครื่องมือที่ดีกว่าในตลาดที่คุณต้องการใช้ แต่ทันทีที่คุณแทนที่ Sequelize ด้วย คุณจะต้องเปลี่ยนโค้ดหลายบรรทัดเพื่อป้องกันไม่ให้ ทำลาย นอกจากนี้ คุณจะต้องทดสอบคุณลักษณะทั้งหมดอีกครั้งเพื่อตรวจสอบว่าใช้งานได้สำเร็จหรือไม่ ซึ่งอาจเสียเวลาและทรัพยากรอันมีค่าไปด้วย เพื่อเอาชนะความท้าทายนี้ เราสามารถใช้หลักการสุดท้ายของ SOLID ซึ่งเป็นหลักการผกผันการพึ่งพา และเทคนิคที่เรียกว่าการฉีดพึ่งพาเพื่อหลีกเลี่ยงความยุ่งเหยิงดังกล่าว

ยังสับสน? ให้ฉันอธิบายในรายละเอียด

ดังนั้นสิ่งที่ Dependency Inversion Principle กล่าวในคำง่ายๆ คือ คุณสร้างตรรกะทางธุรกิจหลักของคุณ แล้วสร้างการพึ่งพารอบๆ กล่าวอีกนัยหนึ่งคือ ปลดปล่อยตรรกะหลักและกฎเกณฑ์ทางธุรกิจของคุณจากการพึ่งพาใดๆ และแก้ไขเลเยอร์ภายนอกในลักษณะที่ขึ้นอยู่กับตรรกะหลักของคุณ แทนที่จะเป็นตรรกะของคุณที่ขึ้นอยู่กับสิ่งนี้ นั่นคือสิ่งที่สถาปัตยกรรมที่สะอาดเป็น มันดึงเอาการพึ่งพาจากตรรกะทางธุรกิจหลักของคุณออกไป และสร้างระบบรอบๆ ตัวในลักษณะที่ดูเหมือนว่าจะพึ่งพามันมากกว่าที่จะพึ่งพาพวกเขา

ลองทำความเข้าใจกับแผนภาพด้านล่าง

ที่มา: กรวยสถาปัตยกรรมที่สะอาด 

จะเห็นว่าเราได้แบ่งสถาปัตยกรรมของเราออกเป็น 4 ชั้น ดังนี้

1. นิติบุคคล: โดยพื้นฐานแล้ว เอนทิตีคือโมเดล (กฎขององค์กร) ที่กำหนดกฎองค์กรของคุณและบอกว่าแอปพลิเคชันเกี่ยวกับอะไร เลเยอร์นี้แทบจะไม่เปลี่ยนแปลงเมื่อเวลาผ่านไป และมักจะเป็นแบบนามธรรมและไม่สามารถเข้าถึงได้โดยตรง เช่น ทุกแอปพลิเคชันมี 'ผู้ใช้' ฟิลด์ทั้งหมดที่ผู้ใช้ควรจัดเก็บ ประเภท และความสัมพันธ์กับเอนทิตีอื่นๆ จะประกอบด้วยเอนทิตี

2. ใช้กรณี: มันบอกเราว่าเราจะนำกฎขององค์กรไปใช้ได้อย่างไร มาดูตัวอย่างผู้ใช้กันอีกครั้ง ตอนนี้เรารู้แล้วว่าข้อมูลใดที่ต้องดำเนินการ กรณีการใช้งานบอกเราถึงวิธีดำเนินการกับข้อมูลนี้ เช่น ผู้ใช้จะมีรหัสผ่านที่จำเป็นต้องเข้ารหัส ผู้ใช้จำเป็นต้องสร้าง และสามารถเปลี่ยนรหัสผ่านได้ทุกเมื่อ เวลาที่กำหนด เป็นต้น

3. ผู้ควบคุม/เกตเวย์: ช่องเหล่านี้เป็นช่องทางที่ช่วยให้เราใช้กรณีการใช้งานโดยใช้เครื่องมือและไลบรารีภายนอกโดยใช้การแทรกการพึ่งพา

4. เครื่องมือภายนอก: เครื่องมือและไลบรารีทั้งหมดที่เราใช้สร้างตรรกะจะอยู่ภายใต้เลเยอร์นี้ เช่น ORM, อีเมล, การเข้ารหัส ฯลฯ

เครื่องมือที่เราใช้จะขึ้นอยู่กับวิธีที่เราจัดช่องทางให้ใช้กรณีต่างๆ และในทางกลับกัน กรณีใช้งานจะขึ้นอยู่กับหน่วยงานซึ่งเป็นแกนหลักของธุรกิจของเรา วิธีนี้เราได้เปลี่ยนการพึ่งพาจากภายนอกสู่ภายใน นั่นคือสิ่งที่การผกผันการพึ่งพาของ SOLID บอกเป็นนัย

เอาล่ะ คุณได้รับส่วนสำคัญของ Nest.JS และเข้าใจว่าสถาปัตยกรรมที่สะอาดทำงานอย่างไร ทีนี้คำถามก็เกิดขึ้น ทั้งสองมีความเกี่ยวข้องกันอย่างไร?  

เรามาลองทำความเข้าใจว่า 3 องค์ประกอบสำคัญของ Nest.JS คืออะไร และแต่ละอันทำอะไร

1. โมดูล Nest.JS มีโครงสร้างเพื่อให้เราสามารถปฏิบัติต่อแต่ละคุณลักษณะเป็นโมดูลได้ ตัวอย่างเช่น สิ่งใดก็ตามที่เชื่อมโยงกับผู้ใช้ เช่น โมเดล ตัวควบคุม DTO ส่วนต่อประสาน ฯลฯ สามารถแยกออกเป็นโมดูลได้ โมดูลมีตัวควบคุมและผู้ให้บริการจำนวนมากที่มีฟังก์ชันการฉีด เช่น บริการ orm อีเมล ฯลฯ

2. ควบคุม: ตัวควบคุมใน Nest.JS เป็นส่วนต่อประสานระหว่างเครือข่ายและตรรกะของคุณ ใช้เพื่อจัดการคำขอและส่งคืนการตอบกลับไปยังฝั่งไคลเอ็นต์ของแอปพลิเคชัน (เช่น การเรียก API)

3. ผู้ให้บริการ (บริการ): ผู้ให้บริการคือบริการ/ฟังก์ชันที่ฉีดได้ ซึ่งเราสามารถใส่เข้าไปในตัวควบคุมและผู้ให้บริการรายอื่นๆ เพื่อมอบความยืดหยุ่นและฟังก์ชันการทำงานพิเศษ พวกเขาสรุปความซับซ้อนและตรรกะทุกรูปแบบ

เพื่อสรุป,

• เรามีตัวควบคุมที่ทำหน้าที่เป็นส่วนต่อประสาน (เลเยอร์ที่ 3 ของสถาปัตยกรรมที่สะอาด)
• เรามีผู้ให้บริการที่สามารถฉีดเพื่อให้การทำงานได้ (ชั้นที่ 4 ของสถาปัตยกรรมที่สะอาด: DB, อุปกรณ์ ฯลฯ)
• นอกจากนี้เรายังสามารถสร้างบริการและที่เก็บเพื่อกำหนดกรณีการใช้งานของเรา (ชั้นที่ 2)
• เราสามารถกำหนดเอนทิตีของเราโดยใช้ผู้ให้บริการ DB (ชั้นที่ 1)

สรุป:

Nest.JS เป็นเฟรมเวิร์ก Node.JS ที่ทรงพลังและเป็น typescript ที่เป็นที่รู้จักมากที่สุดในปัจจุบัน ตอนนี้คุณมีกรอบการทำงานที่ต่ำลงแล้ว คุณต้องสงสัยว่าเราจะใช้มันเพื่อสร้างโครงสร้างโปรเจ็กต์ด้วยสถาปัตยกรรมที่สะอาดได้หรือไม่ คำตอบคือ -ใช่! อย่างแน่นอน. ยังไง? ฉันจะอธิบายในชุดต่อไปของบทความนี้ 

ถึงตอนนั้น คอยติดตาม!

เกี่ยวกับผู้เขียน:

Junaid Bhat กำลังทำงานเป็น Tech Lead ใน Mantra Labs เขาเป็นผู้หลงใหลในเทคโนโลยีที่มุ่งมั่นที่จะเป็นวิศวกรที่ดียิ่งขึ้นทุกวันโดยปฏิบัติตามมาตรฐานอุตสาหกรรมและมุ่งไปสู่แนวทางที่มีโครงสร้างมากขึ้นในการแก้ปัญหา 

อ่านบล็อกล่าสุดของเรา: Golang-Beego Framework และการใช้งาน

สาระน่ารู้ที่จัดส่งให้ในอินบ็อกซ์ของคุณ