Go और Hexagonal आर्किटेक्चर: ऐसा कोड लिखना जिसे बदलने में डर न लगे

परिचय: आपका कोड बाहरी दुनिया से अलग-थलग

क्या आपने कभी केवल इसलिए बिज़नेस लॉजिक को फिर से लिखा है क्योंकि आपने डेटाबेस को PostgreSQL से MongoDB में बदल दिया? या क्या आप इस सोच से ठंडे पसीने में जागे हैं कि एक नया HTTP एंडपॉइंट जोड़ना है, जबकि पूरा एप्लिकेशन 3000 लाइनों का एक विशाल main.go है?

यदि हाँ — तो क्लब में आपका स्वागत है। यदि नहीं — तो आप या तो हाल ही में Go में लिख रहे हैं, या पहले से ही Hexagonal आर्किटेक्चर (जिसे Ports & Adapters भी कहा जाता है) का उपयोग कर रहे हैं।

इस लेख में, हम समझेंगे कि Go में ऐसा एप्लिकेशन कैसे बनाया जाए जो बदलावों से न डरे। न डेटाबेस बदलना, न REST से gRPC पर स्विच करना, न ही कोई नया फ्रेमवर्क आपको सिस्टम के कोर को फिर से लिखने पर मजबूर करेगा। केवल कोड। केवल Go। बिना किसी फालतू बात के।

सरल शब्दों में Hexagonal आर्किटेक्चर क्या है

कल्पना करें कि आपका एप्लिकेशन एक अंतरिक्ष यान है। केंद्र में नियंत्रण कक्ष (बिज़नेस लॉजिक) है। चारों ओर डॉकिंग पोर्ट हैं। पोर्ट के माध्यम से आप विभिन्न मॉड्यूल जोड़ते हैं: इंजन (डेटाबेस), सेंसर (HTTP अनुरोध), पृथ्वी से संचार (मैसेज क्यू)।

यदि आप इंजन बदलने का निर्णय लेते हैं — तो आप बस पुराने को अलग करते हैं और नए को जोड़ते हैं। नियंत्रण कक्ष को बदलाव का पता भी नहीं चलेगा। यही है Hexagonal आर्किटेक्चर।

मुख्य अवधारणाएँ:

\n
• Port (पोर्ट) — एक इंटरफ़ेस जो परिभाषित करता है कि बाहरी दुनिया कोर के साथ कैसे इंटरैक्ट कर सकती है। उदाहरण के लिए, UserRepository जिसमें Save और FindByID विधियाँ हैं।
\n
• Adapter (एडेप्टर) — पोर्ट का एक विशिष्ट कार्यान्वयन। एक पोर्ट में कई एडेप्टर हो सकते हैं: PostgreSQLAdapter, InMemoryAdapter, परीक्षण के लिए MockAdapter।
\n
• Core (कोर) — बिज़नेस लॉजिक, जो बाहरी दुनिया के बारे में कुछ नहीं जानता। यह केवल पोर्ट के माध्यम से काम करता है।
\n

यह दृष्टिकोण तीन सुपरपावर देता है: परीक्षण क्षमता (बिना DB के कोर), लचीलापन (किसी भी भाग को बदलना), और जिम्मेदारी की स्पष्ट सीमाएँ।

Go Hexagonal के लिए आदर्श क्यों है

Go OOP को थोपता नहीं है, लेकिन इंटरफ़ेस प्रदान करता है — Ports & Adapters के लिए केवल यही आवश्यक है। Go में इंटरफ़ेस अंतर्निहित हैं: एक संरचना स्वचालित रूप से इंटरफ़ेस को संतुष्ट करती है यदि वह उसके तरीकों को लागू करती है। इसका मतलब है कि आप कोर में एक भी लाइन बदले बिना एडेप्टर को बदल सकते हैं।

साथ ही, Go एक बाइनरी में कंपाइल होता है, जो आर्किटेक्चर को माइक्रोसर्विसेज के लिए विशेष रूप से उपयोगी बनाता है। और बिल्ट-इन टेस्टिंग और बेंचमार्क आपको तुरंत घटकों के अलगाव की जांच करने देते हैं।

प्रोजेक्ट संरचना: फ़ोल्डर कैसे व्यवस्थित करें

कोई एकल मानक नहीं है, लेकिन यहाँ एक सिद्ध योजना है जिसका उपयोग प्रोडक्शन प्रोजेक्ट्स में किया जाता है:

myapp/\n├── cmd/\n│   └── app/\n│       └── main.go          # प्रवेश बिंदु, निर्भरता निर्माण\n├── internal/\n│   ├── core/\n│   │   ├── domain/          # एंटिटी, value objects\n│   │   ├── ports/           # इंटरफ़ेस (पोर्ट)\n│   │   └── services/        # बिज़नेस लॉजिक (use cases)\n│   └── adapters/\n│       ├── api/             # HTTP/gRPC एडेप्टर\n│       ├── db/              # रिपॉजिटरी कार्यान्वयन\n│       └── mq/              # मैसेज क्यू\n└── go.mod\n

महत्वपूर्ण: internal फ़ोल्डर बाहर से आयात को प्रतिबंधित करता है — कोर की सुरक्षा के लिए आदर्श। एडेप्टर अलग से रहते हैं और आसानी से बदले जा सकते हैं।

कोड लिखना: इंटरफ़ेस से कार्यान्वयन तक

आइए उपयोगकर्ताओं के साथ काम करने के लिए एक सरल सेवा बनाएँ। हम कोर से शुरू करते हैं।

चरण 1. डोमेन और पोर्ट

// internal/core/domain/user.go\npackage domain\n\nimport "time"\n\ntype User struct {\n    ID        string\n    Email     string\n    Name      string\n    CreatedAt time.Time\n}\n\n// internal/core/ports/repositories.go\npackage ports\n\nimport "myapp/internal/core/domain"\n\ntype UserRepository interface {\n    Save(user domain.User) error\n    FindByID(id string) (domain.User, error)\n    FindByEmail(email string) (domain.User, error)\