הבנת המבנה האדריכלי המשושה הקונבנציונלי עבור אפליקציות Go

הארכיטקטורה המשושה (או "יציאות ומתאמים") היא דפוס ארכיטקטורת תוכנה פופולרי שתוכל ליישם בזמן שאתה בונה את אפליקציות ה-Go שלך. באמצעותו תוכלו לשפר את יכולת ההרחבה, התחזוקה והבדיקה של האפליקציה שלכם.

ארכיטקטורה זו עוזרת להפריד את ההיגיון העסקי מתלות ותשתיות חיצוניות, מה שהופך את האפליקציה שלך לגמישה וקלה יותר לתחזוקה.

מהי הארכיטקטורה המשושה?

הארכיטקטורה המשושה מחלקת יישומים לשלוש שכבות עיקריות:

1. השכבת היישום מכיל את לוגיקה הליבה של האפליקציה ללא תלות בכל תלות של צד שלישי. שכבת היישום צריכה להכיל את ההיגיון העסקי שלך, מודלים של תחום ושירותי יישומים.
2. השכבת יציאות ומתאמים מכיל את המתאמים המקיימים אינטראקציה עם היישומים הקיימים. פורטים הם ממשקים שמגדירים את הפעולות עבור האפליקציה שלך, בעוד שמתאמים הם מימושים של הממשקים. מתאמים יכולים להיות מסדי נתונים, APIs HTTP, מתווכים להודעות או כל מערכת חיצונית אחרת.
3. שכבת התשתית מכיל את יישום המתאמים. שכבת התשתית צריכה לכלול מסדי נתונים, מתווכים של הודעות ומערכות חיצוניות אחרות.

יתרונות השימוש בארכיטקטורה המשושה

הארכיטקטורה המשושה פופולרית בזכות היתרונות הבאים שהיא מציעה.

יכולת מדרגיות ותחזוקה של הפרויקט

החלוקה של היישומים שלך מאפשרת בסיס קוד מודולרי ומנותק שמקל על קנה מידה ותחזוקה של האפליקציה שלך.

אתה יכול להסיר מתאמים מבלי להשפיע על לוגיקה הליבה ולשנות את לוגיקה הליבה מבלי להשפיע על המתאמים. זה אומר שאתה יכול בקלות להחליף מתאמים מבלי לשכתב את כל היישום שלך.

יכולת בדיקה וקלות אינטגרציה

הארכיטקטורה המשושה מקדמת יכולת בדיקה מכיוון שאתה יכול לכתוב בדיקות יחידות ללוגיקה הליבה ללא תלות חיצונית מדומה. אתה יכול להשתמש בכפילי מבחן, כגון זיופים או בולים, ללא צורך להקים מסד נתונים או מתווך הודעות.

הארכיטקטורה המשושה גם מקלה על שילוב האפליקציה שלך עם מערכות אחרות. מכיוון שהמתאמים נפרדים מהלוגיקה הליבה, אתה יכול לעשות בהם שימוש חוזר ביישומים אחרים או עבור שירותי מיקרו. אתה יכול גם לחשוף את ממשקי ה-API של יציאת האפליקציה שלך לצריכה במערכות אחרות.

גמישות והתאמה לדרישות משתנות

הארכיטקטורה המשושה מספקת גמישות והתאמה לדרישות המשתנות. מכיוון שהלוגיקת הליבה אינה תלויה במתאמים, אתה יכול בקלות לשנות או להרחיב את הפונקציונליות של היישום מבלי להשפיע על המתאמים.

אתה יכול לפתח את האפליקציה שלך לאורך זמן, ולהיצמד למערכות חיצוניות ספציפיות.

לך והארכיטקטורה המשושה

בליבה, הארכיטקטורה המשושה עוסקת בהפרדה בין ההיגיון העסקי הליבה של האפליקציה לבין תשתית כך אתה יכול להחליף תלות מבלי להשפיע על לוגיקה הליבה של היישום, מה שמקל על תחזוקה ובדיקת יישום.

היישום המשושה Go הטיפוסי משתמש בארבע ספריות עיקריות: cmd, פְּנִימִי, pkg, ו מוֹכֵר.

ה cmd הספרייה מכילה את היישומים העיקריים עבור הפרויקט. הקוד שאתה כותב כאן יקרא בדרך כלל לפונקציות מקבצים ב-pkg ובספריות הפנימיות.

ה פְּנִימִי הספרייה צריכה להכיל קוד יישום פרטי שאינך רוצה שמשתמשים ייבאו ליישום שלהם. המהדר של Go אוכף את תבנית הפריסה הפנימית, ותוכלו להחזיק מספריות פנימיות בספריות אחרות ככל שתרצו. אתה לא מוגבל לספרייה פנימית ברמה העליונה.

ה pkg הספרייה צריכה להכיל את קוד הספרייה שברצונך שיישומים חיצוניים ייבאו וישתמשו בהם. למרות השימוש ב pkg ספרייה היא נוהג נפוץ, היא אינה מקובלת או נאכפת ברחבי העולם.

ה מוֹכֵר ספרייה צריכה להכיל תלות של יישומים (מנוהלים באופן ידני או אוטומטי). אתה יכול להשתמש ב ללכת מוכר מוד פקודה ליצירת א /vendor ספרייה כדי למנף את הפונקציונליות ש-Go מספקת לספקים.

יישום האדריכלות המשושה בגו

מבנה הקבצים של הפרויקט שלך חשוב בעת יישום ארכיטקטורת משושה בכל שפה, כולל Go.

הנה דוגמה למבנה קבצים ליישום הארכיטקטורה המשושה ב-Go:

.
├── cmd
│ └── http
│ └── main.go
├── פנימי
│ ├── מתאמים
│ │ ├── API
│ │ │ └── api_adapter.go
│ │ └── מסד נתונים
│ │ └── db_adapter.go
אפליקציה │ ├──
│ │ ├── דומיין
│ │ │ ├── entity1.go
│ │ │ └── entity2.go
│ │ ├── יציאות
│ │ │ ├── קלט
│ │ │ │ ├── input_port1.go
│ │ │ │ └── input_port2.go
פלט │ │ │ └──
│ │ │ ├── output_port1.go
│ │ │ └── output_port2.go
│ │ └── מקרי שימוש
│ │ ├── usecase1.go
│ │ └── usecase2.go
├── חבילה
│ ├── קלט
│ │ ├── input1.go
│ │ └── input2.go
פלט │ └──
│ ├── output1.go
│ └── output2.go
└── ספק
 ├── מודול1
 │ ├── file1.go
 │ └── file2.go
 └── מודול2
 ├── file1.go
 └── file2.go

ה pkg הספרייה מכילה את יציאות הקלט והפלט של היישום שלך בדוגמה זו. אתה תגדיר ממשקים עבור יציאות קלט ופלט בקבצים אלה.

ה פְּנִימִי הספרייה מכילה את תחום היישום ומקרי שימוש. אתה תכתוב את ההיגיון העסקי של היישום שלך בקבצים אלה.

ה מתאמים הספרייה מכילה את קוד התשתית המחבר את האפליקציה שלך למסד הנתונים ול-API.

הגדרת מבנה קובץ הארכיטקטורה המשושה

הגדרת מבנה קובץ הארכיטקטורה המשושה של הפרויקט שלך יכולה להיות מסורבלת, אבל אתה יכול לכתוב סקריפט bash כדי להפוך את תהליך יצירת הספריות לאוטומטיות.

הפעל את הפקודה הזו בספריית העבודה של הפרויקט שלך אל ליצור תסריט bash, hexagonal.sh, ולהעניק לו הרשאות קריאה, כתיבה וביצוע:

touch hexagonal.sh && chmod 777 hexagonal.sh

הזן את קוד ה-bash הזה hexagonal.sh כדי ליצור את מבנה הקבצים בספריית העבודה הנוכחית שלך:

#!/bin/bash
# צור ספריות ברמה העליונה
mkdir cmd ספק pkg פנימי
# צור ספריית cmd/http
mkdir cmd/http
# צור ספריות פנימיות
mkdir פנימי/מתאמים פנימיים/אפליקציה פנימיים/אפליקציה/דומיין פנימי/אפליקציה/יציאות פנימיות/אפליקציה/יציאות/כניסה פנימית/אפליקציה/יציאות/פלט פנימי/אפליקציה/usecases
# צור ספריות פנימיות/מתאמים
mkdir internal/adapters/api internal/adapters/database
# צור ספריות פנימיות/אפליקציות/יציאות
mkdir internal/app/ports/input internal/app/ports/output
# צור ספריות ספקים
mkdir vendor/module1 vendor/module2
# הדפס הודעת הצלחה
הֵד"מבנה הספרייה נוצר בהצלחה."

אתה יכול להריץ את סקריפט ה-bash הזה עם הפקודה הבאה:

./hexagonal.sh

תוכנית bash יוצרת את התיקיות ואת תיקיות המשנה כך שתוכל להמשיך ליצור קבצים ולכתוב את ההיגיון העסקי עבור היישום שלך.

הארכיטקטורה המשושה שימושית לבניית יישומים מורכבים

הטמעת הארכיטקטורה המשושה עשויה להיות גוזלת זמן, אך היתרונות עולים על העלות בטווח הארוך. על ידי הפרדת חששות והפיכת הקוד שלך למודולרי יותר, אתה יכול בקלות לתחזק ולבדוק את היישומים שלך.

יש הרבה דפוסים אדריכליים אחרים, שלכל אחד מהם יתרונות וחסרונות לבניית יישומים גמישים ובעלי ביצועים. אלה כוללים את ארכיטקטורת MVC (מודל, תצוגה, בקר) הפופולרית ליצירת יישומי אינטרנט.