त्वरित नोट: यदि आपने JWT प्रमाणीकरण पर मेरी पिछली पोस्ट देखी है और कुछ रेंडरिंग समस्याएं देखी हैं, तो उन्हें अब ठीक कर दिया गया है! इसे एक और रूप देना सुनिश्चित करें क्योंकि ये उदाहरण उस ट्यूटोरियल के शीर्ष पर बने हैं। :)

ठीक है दोस्तों, हमें अपना Go API चालू है, हमने JWT प्रमाणीकरण जोड़ा है, और हमने इसे PostgreSQL डेटाबेस से भी जोड़ा है। लेकिन हमने अभी तक काम पूरा नहीं किया है! इस सप्ताह, हम चीजों को एक पायदान ऊपर ले जा रहे हैं और लॉगिंग और त्रुटि प्रबंधन। मिडलवेयर फिर क्या है? ? मिडिलवेयर आपके पसंदीदा क्लब में बाउंसर की तरह है - यह आपके एपीआई एंडपॉइंट तक पहुंचने से पहले अनुरोधों को रोकता है। आपके पास मिडलवेयर हो सकता है जो प्रमाणीकरण की जांच करता है (जैसा कि हमने जेडब्ल्यूटी के साथ किया था), जानकारी लॉग करता है, या चीजें गलत होने पर त्रुटियों को संभालता है।

आज, हम ऐसा मिडलवेयर बनाने जा रहे हैं:

लॉग

: हर आने वाला अनुरोध, ताकि हम जान सकें कि हमारे एपीआई का दरवाजा कौन खटखटा रहा है।

• त्रुटियों को संभालता है: शालीनता से, ताकि आपके उपयोगकर्ता उन बदसूरत 500 त्रुटियों को न देखें।
• आइए इसमें गोता लगाएँ!

चरण 1: लॉगिंग मिडलवेयर बनाना?

जब डिबगिंग और आपके एपीआई में क्या हो रहा है, इसे समझने की बात आती है तो लॉगिंग आपका सबसे अच्छा दोस्त है। हम एक ऐसा मिडलवेयर बनाने जा रहे हैं जो आने वाले हर अनुरोध-विधि, यूआरएल और लगने वाले समय को लॉग करता है।

---

फंक लॉगिंग मिडलवेयर(अगला http.हैंडलर) http.हैंडलर { वापसी http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { प्रारंभ := समय.अभी() // विधि और अनुरोधित यूआरएल लॉग करें log.Printf("प्रारंभ %s %s", r.Method, r.URL.Path) // श्रृंखला में अगले हैंडलर को कॉल करें अगला.ServeHTTP(w, r) // लॉग करें कि इसमें कितना समय लगा log.Printf('%v में पूरा हुआ', time.Since(start)) }) }

उन लोगों के लिए जो लॉगिंग मिडलवेयर में गहराई से गोता लगाने में रुचि रखते हैं, मैं गो में लॉगिंग मिडलवेयर लिखने पर मैट सिल्वरलॉक की शानदार मार्गदर्शिका की जांच करने की सलाह देता हूं। वह बताता है कि प्रमाणीकरण, ट्रेसिंग और निश्चित रूप से लॉगिंग जैसे विभिन्न उपयोग के मामलों के लिए पुन: प्रयोज्य मिडलवेयर की संरचना कैसे की जाए!

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Log the method and the requested URL
        log.Printf("Started %s %s", r.Method, r.URL.Path)

        // Call the next handler in the chain
        next.ServeHTTP(w, r)

        // Log how long it took
        log.Printf("Completed in %v", time.Since(start))
    })
}

आइए त्रुटियों के बारे में बात करते हैं। त्रुटियाँ होती हैं, है ना? लेकिन उन्हें दुर्घटना का कारण बनने या अस्पष्ट त्रुटि संदेश भेजने की बजाय, आइए उन्हें शालीनता से संभालें।

func errorHandlingMiddleware(अगला http.Handler) http.Handler { वापसी http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { defer func() { यदि त्रुटि := पुनर्प्राप्त करें(); त्रुटि != शून्य { // त्रुटि लॉग करें और उपयोगकर्ता के अनुकूल संदेश भेजें log.Printf ("त्रुटि उत्पन्न हुई: %v", त्रुटि) http.Error(w, "आंतरिक सर्वर त्रुटि", http.StatusInternalServerError) } }() अगला.ServeHTTP(w, r) }) }

चरण 3: अपने एपीआई में मिडलवेयर को एकीकृत करना?

func errorHandlingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Log the error and send a user-friendly message
                log.Printf("Error occurred: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

अब जब हमने अपना लॉगिंग और एरर-हैंडलिंग मिडलवेयर बना लिया है, तो आइए उन्हें हमारे एपीआई से जोड़ दें। हम उन्हें विश्व स्तर पर लागू करेंगे ताकि प्रत्येक अनुरोध लॉग हो जाए और त्रुटियाँ पकड़ी जाएँ।

---

func मुख्य() { डीबी = कनेक्टडीबी() स्थगित करें db.बंद करें() आर := mux.NewRouter() // विश्व स्तर पर मिडलवेयर लागू करें r.उपयोग(लॉगिंगमिडलवेयर) r.Use(errorHandlingMiddleware) r.HandleFunc('/लॉगिन', लॉगिन).तरीके('पोस्ट') r.Handle("/books", प्रमाणित करें(http.HandlerFunc(getBooks))).तरीके("GET") r.Handle("/books", प्रमाणित करें(http.HandlerFunc(createBook))).तरीके("POST") fmt.Println('सर्वर पोर्ट पर प्रारंभ हुआ :8000'') लॉग.घातक(http.ListenAndServe(":8000", r)) }

चरण 4: इसका परीक्षण करना?

func errorHandlingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Log the error and send a user-friendly message
                log.Printf("Error occurred: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

यह सुनिश्चित करने के लिए कि सब कुछ काम कर रहा है, अपना एपीआई शुरू करें:

---

जाओ भागो main.go

अब, अपने किसी भी अंतिम बिंदु (जैसे /किताबें) पर पहुंचने का प्रयास करें और अपने टर्मिनल की जांच करें। आपको इस तरह के लॉग देखने चाहिए:

go run main.go

और यदि कोई त्रुटि है, तो आप देखेंगे:

Started GET /books
Completed in 1.2ms

लेकिन आपके उपयोगकर्ता को केवल एक साफ़ "500 आंतरिक सर्वर त्रुटि" संदेश दिखाई देगा। ?

func errorHandlingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Log the error and send a user-friendly message
                log.Printf("Error occurred: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

यह महत्वपूर्ण क्यों है?

---

लॉगिंग

आपको बग को ट्रैक करने और आपके एपीआई के व्यवहार की निगरानी करने में मदद करता है। यदि कुछ गलत होता है, तो आपको ठीक-ठीक पता चल जाएगा कि कौन सा समापन बिंदु हिट हुआ था और अनुरोध में कितना समय लगा।

1. त्रुटि प्रबंधन
कुछ अप्रत्याशित होने पर आपके एपीआई को क्रैश होने से रोकता है। इसके बजाय, यह शानदार ढंग से ठीक हो जाता है और क्लाइंट को एक साफ़ त्रुटि संदेश भेजता है।

2. आगे क्या होगा?

अगली बार, हम चीजों को अगले स्तर पर ले जाएंगे और

---

हमारे गो एपीआई को डॉकराइज करेंगे

! यह आपके ऐप को पोर्टेबल बना देगा और किसी भी मशीन या क्लाउड सेवा पर तैनाती के लिए तैयार हो जाएगा। कुछ कंटेनर जादू के लिए तैयार हो जाइए! ?