डूइंग गुड, डूइंग बैड: राइटिंग ईविल कोड विथ गो, पार्ट 2

एक जाओ प्रोग्रामर के लिए बुरी युक्तियाँ



प्रकाशन के पहले भाग में, मैंने बताया कि कैसे "दुर्भावनापूर्ण" जाओ प्रोग्रामर बनें। बुराई कई रूपों में आती है, लेकिन प्रोग्रामिंग में यह कोड को समझने और बनाए रखने की जानबूझकर कठिनाई में निहित है। बुराई कार्यक्रम तकनीक के पक्ष में भाषा के बुनियादी साधनों की अनदेखी करते हैं जो दीर्घकालिक समस्याओं के बदले अल्पकालिक लाभ प्रदान करते हैं। एक संक्षिप्त अनुस्मारक के रूप में, गो की बुराई "प्रथाओं" में शामिल हैं:

• नामांकित और संगठित पैकेज
• गलत तरीके से व्यवस्थित इंटरफेस
• अपने मूल्यों को पॉप्युलेट करने के लिए फ़ंक्शंस में वेरिएबल्स को पॉइंटर्स पास करना
• गलतियों के बजाय आतंक का उपयोग करना
• Init फ़ंक्शन और खाली आयात का उपयोग निर्भरता को कॉन्फ़िगर करने के लिए
• Init फ़ंक्शन का उपयोग करके कॉन्फ़िगरेशन फ़ाइलें डाउनलोड करें
• पुस्तकालयों के बजाय चौखटे का उपयोग करना

बुराई की बड़ी गेंद

यदि हम अपनी सभी बुरी प्रथाओं को एक साथ रख दें तो क्या होगा? हमारे पास एक फ्रेमवर्क होगा जो कई कॉन्फ़िगरेशन फ़ाइलों का उपयोग करेगा, पॉइंटर्स का उपयोग करके संरचना फ़ील्ड भरें, प्रकाशित प्रकारों का वर्णन करने के लिए इंटरफेस को परिभाषित करें, जब भी कोई समस्या होती है तो "जादू" कोड और आतंक पर भरोसा करें।

और मैंने कर दिया। यदि आप https://github.com/evil-go पर जाते हैं , तो आपको फ़ॉल , एक डीआई फ्रेमवर्क दिखाई देगा जो आपको किसी भी "बुराई" प्रथाओं को लागू करने की अनुमति देता है जो आप चाहते हैं। मैंने एक छोटे आउटबॉय वेब ढांचे के साथ पतन को हल किया है जो समान सिद्धांतों का पालन करता है।

आप पूछ सकते हैं कि वे कितने खलनायक हैं? आइए देखते हैं। मेरा सुझाव है कि एक सरल गो कार्यक्रम (सर्वोत्तम प्रथाओं का उपयोग करके) के लिए जा रहा है जो http समापन बिंदु प्रदान करता है। और फिर इसे Fall और Outboy का उपयोग करके फिर से लिखना।

सर्वोत्तम अभ्यास

हमारा कार्यक्रम अभिवादन नामक एक पैकेज में निहित है, जो हमारे समापन बिंदु को लागू करने के लिए सभी बुनियादी कार्यों का उपयोग करता है। चूंकि यह एक उदाहरण है, हम मेमोरी डीएओ में एक काम का उपयोग करते हैं, उन मूल्यों के लिए तीन फ़ील्ड जिनके साथ हम लौटेंगे। हमारे पास एक विधि भी होगी जो इनपुट के आधार पर, कॉल को हमारे डेटाबेस में बदल देती है और वांछित ग्रीटिंग लौटा देती है।

package greet type Dao struct { DefaultMessage string BobMessage string JuliaMessage string } func (sdi Dao) GreetingForName(name string) (string, error) { switch name { case "Bob": return sdi.BobMessage, nil case "Julia": return sdi.JuliaMessage, nil default: return sdi.DefaultMessage, nil } } 

आगे व्यापार तर्क है। इसे कार्यान्वित करने के लिए, हम आउटपुट डेटा संग्रहीत करने के लिए एक संरचना को परिभाषित करते हैं, यह बताने के लिए कि डेटा लॉजिक स्तर पर व्यावसायिक तर्क क्या है, और ग्रीटिंग फ़ाइंडर के लिए एक फ़ील्ड के साथ व्यावसायिक तर्क संग्रहीत करने के लिए एक संरचना का वर्णन करने के लिए एक ग्रीटिंग फ़ाइंडर इंटरफ़ेस। वास्तविक तर्क सरल है - यह सिर्फ GreetingFinder को कॉल करता है और हो सकने वाली किसी भी त्रुटि को हैंडल करता है।

 type Response struct { Message string } type GreetingFinder interface { GreetingForName(name string) (string, error) } type Service struct { GreetingFinder GreetingFinder } func (ssi Service) Greeting(name string)(Response, error) { msg, err := ssi.GreetingFinder.GreetingForName(name) if err != nil { return Response{}, err } return Response{Message: msg}, nil } 

फिर वेब लेयर आता है, और इस भाग के लिए हम Greeter इंटरफ़ेस को परिभाषित करते हैं, जो हमें आवश्यक सभी व्यावसायिक तर्क प्रदान करता है, साथ ही साथ http हैंडलर युक्त संरचना को Greeter के साथ कॉन्फ़िगर किया गया है। फिर हम http.Handler इंटरफ़ेस को लागू करने के लिए एक विधि बनाते हैं, जो http अनुरोध को विभाजित करता है, अभिवादन-ए (ग्रीटिंग) कहता है, त्रुटियों को संसाधित करता है, और परिणाम लौटाता है।

 type Greeter interface { Greeting(name string) (Response, error) } type Controller struct { Greeter Greeter } func (mc Controller) ServeHTTP(rw http.ResponseWriter, req *http.Request) { result, err := mc.Greeter.Greeting( req.URL.Query().Get("name")) if err != nil { rw.WriteHeader(http.StatusInternalServerError) rw.Write([]byte(err.Error())) return } rw.Write([]byte(result.Message)) } 

यह अभिवादन पैकेज का अंत है। अगला, हम देखेंगे कि कैसे "अच्छा" गो डेवलपर मुख्य रूप से इस पैकेज का उपयोग करने के लिए लिखेगा। मुख्य पैकेज में, हम विन्यास नामक एक संरचना को परिभाषित करते हैं, जिसमें वे गुण होते हैं जिन्हें हमें चलाने की आवश्यकता होती है। मुख्य कार्य 3 चीजें करता है।

• सबसे पहले, यह लोडप्रोपरेटी फ़ंक्शन को कॉल करता है, जो एक साधारण लाइब्रेरी ( https://github.com/evil-go/good-sample/blob/master/config/config.go ) का उपयोग करता है, जो संपीड़ित फ़ाइल से गुण लोड करता है और उन्हें रखता है। एक विन्यास की हमारी प्रति में। यदि कॉन्फ़िगरेशन डाउनलोड विफल हो जाता है, तो मुख्य फ़ंक्शन एक त्रुटि की रिपोर्ट करता है और बाहर निकलता है।
• दूसरे, मुख्य फ़ंक्शन ग्रीटिंग पैकेज में घटकों को बांधता है, स्पष्ट रूप से उन्हें कॉन्फ़िगरेशन से मान असाइन करना और निर्भरता स्थापित करना है।
• तीसरा, यह एक छोटा सर्वर लाइब्रेरी ( https://github.com/evil-go/good-sample/blob/master/server/server.go ) कहता है और पता, HTTP मेथड और http.Handler को एंडपॉइंट के लिए पास करता है प्रसंस्करण का अनुरोध करें। एक पुस्तकालय कॉल एक वेब सेवा का शुभारंभ करती है। और यह हमारा पूरा आवेदन है।

 package main type Config struct { DefaultMessage string BobMessage string JuliaMessage string Path string } func main() { c, err := loadProperties() if err != nil { fmt.Println(err) os.Exit(1) } dao := greet.Dao{ DefaultMessage: c.DefaultMessage, BobMessage: c.BobMessage, JuliaMessage: c.JuliaMessage, } svc := greet.Service{GreetingFinder: dao} controller := greet.Controller{Greeter: svc} err = server.Start(server.Endpoint{c.Path, http.MethodGet, controller}) if err != nil { fmt.Println(err) os.Exit(1) } } 

उदाहरण बहुत छोटा है, लेकिन यह दिखाता है कि गो कितना शांत लिखा गया है; कुछ चीजें अस्पष्ट हैं, लेकिन सामान्य तौर पर यह स्पष्ट है कि क्या हो रहा है। हम छोटे पुस्तकालयों को गोंद करते हैं जो विशेष रूप से एक साथ काम करने के लिए स्थापित किए जाते हैं। कुछ भी छिपा नहीं है; कोई भी इस कोड को ले सकता है, यह समझ सकता है कि इसके भाग एक साथ कैसे जुड़े हैं, और यदि आवश्यक हो तो उन्हें नए सिरे से फिर से बनाएँ।

काला धब्बा

अब हम फॉल और आउटबॉय के संस्करण पर विचार करेंगे। पहली चीज जो हम करते हैं, वह अभिवादन पैकेज को कई पैकेजों में तोड़ता है, जिनमें से प्रत्येक में एक अनुप्रयोग परत होती है। यहाँ DAO पैकेज है। यह फॉल, हमारे DI फ्रेमवर्क को आयात करता है, और जब से हम "दुष्ट" हैं और संबंधों को अन्य तरीकों से परिभाषित करते हैं, तो हम GreetDao नामक एक इंटरफेस को परिभाषित करेंगे। कृपया ध्यान दें - हमने त्रुटियों के सभी लिंक हटा दिए हैं; अगर कुछ गलत है, तो हम घबराते हैं। इस बिंदु पर, हमारे पास पहले से ही खराब पैकेजिंग, खराब इंटरफेस और खराब कीड़े हैं। शानदार शुरुआत!

हमने एक अच्छे उदाहरण से अपनी संरचना को थोड़ा नाम दिया। फ़ील्ड में अब संरचनात्मक टैग हैं; उनका उपयोग क्षेत्र में पंजीकृत मूल्य को गिराने के लिए किया जाता है। हमारे पास अपने पैकेज के लिए एक init फ़ंक्शन भी है, जिसके साथ हम "बुरी शक्ति" जमा करते हैं। पैकेज इनिट फ़ंक्शन में, हम दो बार फ़ॉल कहते हैं:

• एक बार एक विन्यास फाइल को पंजीकृत करने के लिए जो संरचना टैग के लिए मान प्रदान करता है।
• और दूसरा, संरचना के एक उदाहरण के लिए एक सूचक को पंजीकृत करने के लिए। फॉल हमारे लिए इन क्षेत्रों को भरने में सक्षम होगा और अन्य कोड द्वारा उपयोग के लिए डीएओ उपलब्ध कराएगा।

 package dao import ( "github.com/evil-go/fall" ) type GreetDao interface { GreetingForName(name string) string } type greetDaoImpl struct { DefaultMessage string `value:"message.default"` BobMessage string `value:"message.bob"` JuliaMessage string `value:"message.julia"` } func (gdi greetDaoImpl) GreetingForName(name string) string { switch name { case "Bob": return gdi.BobMessage case "Julia": return gdi.JuliaMessage default: return gdi.DefaultMessage } } func init() { fall.RegisterPropertiesFile("dao.properties") fall.Register(&greetDaoImpl{}) } 

सेवा पैकेज देखते हैं। यह डीएओ पैकेज आयात करता है क्योंकि इसे वहां परिभाषित इंटरफेस तक पहुंच की आवश्यकता होती है। सेवा पैकेज मॉडल पैकेज को भी आयात करता है, जिसे हमने अभी तक नहीं माना है - हम अपने डेटा प्रकारों को वहां संग्रहीत करेंगे। और हम पतन का आयात करते हैं, क्योंकि, सभी "अच्छे" ढांचे की तरह, यह हर जगह प्रवेश करता है। हम वेब लेयर तक पहुँच देने के लिए सेवा के लिए एक इंटरफ़ेस भी परिभाषित करते हैं। फिर, त्रुटि से निपटने के बिना।

हमारी सेवा के कार्यान्वयन में अब तार के साथ एक संरचनात्मक टैग है। फ़ील्ड चिह्नित तार स्वचालित रूप से अपनी निर्भरता को जोड़ता है जब संरचना पतन में पंजीकृत होती है। हमारे छोटे उदाहरण में, यह स्पष्ट है कि इस क्षेत्र को क्या सौंपा जाएगा। लेकिन एक बड़े कार्यक्रम में, आपको केवल यह पता होगा कि कहीं न कहीं यह ग्रीटडाउ इंटरफ़ेस लागू है, और यह फॉल में पंजीकृत है। आप निर्भरता व्यवहार को नियंत्रित नहीं कर सकते।

अगला हमारी सेवा का तरीका है, जिसे मॉडल पैकेज से ग्रीटस्प्रेसन संरचना प्राप्त करने के लिए थोड़ा संशोधित किया गया है, और जो किसी भी त्रुटि से निपटने को हटा देता है। अंत में, हमारे पास पैकेज में एक init फ़ंक्शन है जो फ़ॉल में एक सेवा उदाहरण को पंजीकृत करता है।

 package service import ( "github.com/evil-go/fall" "github.com/evil-go/evil-sample/dao" "github.com/evil-go/evil-sample/model" ) type GreetService interface { Greeting(string) model.GreetResponse } type greetServiceImpl struct { Dao dao.GreetDao `wire:""` } func (ssi greetServiceImpl) Greeting(name string) model.GreetResponse { return model.GreetResponse{Message: ssi.Dao.GreetingForName(name)} } func init() { fall.Register(&greetServiceImpl{}) } 

अब हम मॉडल पैकेज को देखते हैं। देखने के लिए विशेष रूप से कुछ भी नहीं है। यह देखा जा सकता है कि मॉडल को उस कोड से अलग किया गया है जो इसे बनाता है, केवल कोड को परतों में विभाजित करने के लिए।

 package model type GreetResponse struct { Message string } 

वेब पैकेज में हमारे पास एक वेब इंटरफेस है। यहाँ हम दोनों Fall और Outboy आयात करते हैं, और हम उस सर्विस पैकेज का भी आयात करते हैं जिस पर वेब पैकेज निर्भर करता है। क्योंकि फ्रेमवर्क केवल एक साथ अच्छी तरह से काम करते हैं जब वे बैकस्ट को एकीकृत करते हैं, फ़ॉल के पास यह सुनिश्चित करने के लिए विशेष कोड होता है कि यह और आउटबॉय एक साथ काम करते हैं। हम संरचना को भी बदल रहे हैं ताकि यह हमारे वेब एप्लिकेशन के लिए नियंत्रक बन जाए। उसके दो क्षेत्र हैं:

• पहले सर्विस पैकेज से GreetService इंटरफ़ेस के कार्यान्वयन के लिए फ़ॉल के माध्यम से जुड़ा हुआ है।
• दूसरा हमारे एकमात्र वेब समापन बिंदु के लिए पथ है। यह इस पैकेज के init फ़ंक्शन में पंजीकृत कॉन्फ़िगरेशन फ़ाइल से मान असाइन किया गया है।

हमारे http हैंडलर का नाम बदलकर गेटहेलो कर दिया गया है और यह अब एरर हैंडलिंग से मुक्त है। हमारे पास इनिट विधि (एक बड़े अक्षर के साथ) भी है, जिसे इनिट फ़ंक्शन के साथ भ्रमित नहीं होना चाहिए। Init एक जादुई विधि है जिसे सभी क्षेत्रों में भरने के बाद Fall में पंजीकृत संरचनाओं के लिए कहा जाता है। Init में, हम Outboy को उस कंट्रोलर और उसके समापन बिंदु को पंजीकृत करने के लिए कहते हैं, जो कि फॉल का उपयोग करके सेट किया गया था। कोड को देखते हुए, आपको पथ और हैंडलर दिखाई देगा, लेकिन HTTP विधि निर्दिष्ट नहीं है। आउटबॉय में, विधि नाम का उपयोग यह निर्धारित करने के लिए किया जाता है कि हैंडलर किस HTTP विधि का जवाब देता है। चूंकि हमारी विधि GetHello कहलाती है, इसलिए यह GET अनुरोधों का जवाब देती है। यदि आप इन नियमों को नहीं जानते हैं, तो आप यह नहीं समझ पाएंगे कि वह किन अनुरोधों का जवाब देता है। सच है, यह बहुत खलनायक है?

अंत में, हम फॉल फाइल और कंट्रोलर को फॉल में रजिस्टर करने के लिए इनिट फ़ंक्शन को कहते हैं।

 package web import ( "github.com/evil-go/fall" "github.com/evil-go/outboy" "github.com/evil-go/evil-sample/service" "net/http" ) type GreetController struct { Service service.GreetService `wire:""` Path string `value:"controller.path.hello"` } func (mc GreetController) GetHello(rw http.ResponseWriter, req *http.Request) { result := mc.Service.Greeting(req.URL.Query().Get("name")) rw.Write([]byte(result.Message)) } func (mc GreetController) Init() { outboy.Register(mc, map[string]string{ "GetHello": mc.Path, }) } func init() { fall.RegisterPropertiesFile("web.properties") fall.Register(&GreetController{}) } 

यह केवल यह दिखाने के लिए रहता है कि हम कार्यक्रम कैसे चलाते हैं। मुख्य पैकेज में, हम आउटबॉय और वेब पैकेज को पंजीकृत करने के लिए खाली आयात का उपयोग करते हैं। और मुख्य फ़ंक्शन कॉल गिरता है। संपूर्ण एप्लिकेशन लॉन्च करने के लिए स्टार्ट ()।

 package main import ( _ "github.com/evil-go/evil-sample/web" "github.com/evil-go/fall" _ "github.com/evil-go/outboy" ) func main() { fall.Start() } 

पूर्णांक का विघटन

और यहाँ यह एक पूरा कार्यक्रम है, जो हमारे सभी बुरे Go टूल्स का उपयोग करके लिखा गया है। यह एक बुरा सपना है। वह जादुई रूप से यह बताती है कि कार्यक्रम के कुछ हिस्सों को एक साथ कैसे फिट किया जाता है, और यह उसके काम को समझने में बहुत मुश्किल बनाता है।

और फिर भी, आपको यह स्वीकार करना चाहिए कि फॉल और आउटबॉय के साथ कोड लिखने के बारे में कुछ आकर्षक है। एक छोटे कार्यक्रम के लिए, आप यह भी कह सकते हैं कि यह एक सुधार है। देखें कि कॉन्फ़िगर करना कितना आसान है! मैं लगभग कोई कोड के साथ निर्भरता कनेक्ट कर सकते हैं! मैंने विधि के लिए एक हैंडलर पंजीकृत किया, बस उसके नाम का उपयोग किया! और किसी भी त्रुटि से निपटने के बिना, सब कुछ इतना साफ दिखता है!

इसी तरह बुराई काम करती है। पहली नज़र में, यह वास्तव में आकर्षक है। लेकिन जैसे-जैसे आपका कार्यक्रम बदलता है और बढ़ता है, यह सब जादू केवल हस्तक्षेप करना शुरू कर देता है, जो हो रहा है उसकी समझ को जटिल करता है। केवल जब आप पूरी तरह से बुराई से ग्रस्त होते हैं तो आप पीछे मुड़कर देखते हैं और महसूस करते हैं कि आप फंस गए हैं।

जावा डेवलपर्स के लिए, यह परिचित लग सकता है। इन तकनीकों को कई लोकप्रिय जावा फ्रेमवर्क में पाया जा सकता है। जैसा कि मैंने पहले उल्लेख किया है, मैं 1996 में 1.0.2 से शुरू होकर 20 वर्षों से जावा के साथ काम कर रहा हूं। कई मामलों में, जावा डेवलपर्स इंटरनेट युग में बड़े पैमाने पर उद्यम सॉफ्टवेयर लिखने में समस्याओं का सामना करने वाले पहले व्यक्ति थे। मुझे वह समय याद है जब सर्वलेट्स, ईजेबी, स्प्रिंग और हाइबरनेट बस दिखाई दिए। जावा डेवलपर्स ने उस समय जो निर्णय लिए वे समझ में आए। लेकिन वर्षों में, ये तकनीक उनकी उम्र दर्शाती है। नई भाषाओं, जैसे गो, को पुरानी तकनीकों का उपयोग करते समय पाए जाने वाले दर्द बिंदुओं को खत्म करने के लिए डिज़ाइन किया गया है। हालांकि, जैसा कि जावा डेवलपर्स गो सीखना शुरू करते हैं और इसके साथ कोड लिखना शुरू करते हैं, उन्हें याद रखना चाहिए कि जावा से पैटर्न को पुन: उत्पन्न करने की कोशिश करने से बुरे परिणाम सामने आएंगे।

गो को गंभीर प्रोग्रामिंग के लिए डिज़ाइन किया गया था - उन परियोजनाओं के लिए जो सैकड़ों डेवलपर्स और दर्जनों टीमों को फैलाते हैं। लेकिन यह करने के लिए जाओ, आपको इसे उसी तरह उपयोग करने की आवश्यकता है जिस तरह से यह सबसे अच्छा काम करता है। हम बुराई या अच्छा होना चुन सकते हैं। यदि हम बुराई चुनते हैं, तो हम युवा गो डेवलपर्स को गो को समझने से पहले उनकी शैली और तकनीकों को बदलने के लिए प्रोत्साहित कर सकते हैं। या हम अच्छा चुन सकते हैं। गो डेवलपर्स के रूप में हमारे काम का एक हिस्सा युवा गोफर्स (गोफर्स) को शिक्षित करना है, जिससे उन्हें उन सिद्धांतों को समझने में मदद मिल सके जो उनकी सर्वोत्तम प्रथाओं को समझते हैं।

अच्छे रास्ते पर चलने का एकमात्र दोष यह है कि आपको अपने भीतर की बुराई को व्यक्त करने के लिए दूसरे रास्ते की तलाश करनी होगी। शायद संघीय राजमार्ग पर 30 किमी / घंटा की गति से ड्राइविंग की कोशिश करें?