Go वेब डेवलपमेंट मास्टरी: मिडलवेयर, टेम्पलेटिंग, डेटाबेस और अधिक

इस श्रृंखला के पिछले लेख में, हमने Go net/http पैकेज पर विस्तृत चर्चा की थी और कैसे इसका उपयोग प्रोडक्शन-रेडी वेब एप्लिकेशन के लिए किया जा सकता है। हमने ज्यादातर रूटिंग पहलू और http.ServeMux प्रकार की अन्य विशेषताओं और फीचर्स पर ध्यान केंद्रित किया था।

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

Go में मिडलवेयर

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

Go में मिडलवेयर लागू करने के लिए, आपको यह सुनिश्चित करना होगा कि आपके पास एक प्रकार है जो http.Handler इंटरफ़ेस को संतुष्ट करता है। आमतौर पर, इसका मतलब है कि आपको ServeHTTP(http.ResponseWriter, *http.Request) सिग्नेचर के साथ एक मेथड को प्रकार से जोड़ने की आवश्यकता है। इस मेथड का उपयोग करते समय, कोई भी प्रकार http.Handler इंटरफ़ेस को संतुष्ट करेगा।

यहां एक सरल उदाहरण है:

package main
import "net/http"
type helloHandler struct {
    name string
}
func (h helloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello " + h.name))
}
func main() {
    mux := http.NewServeMux()
    helloJohn := helloHandler{name: "John"}
    mux.Handle("/john", helloJohn)
    http.ListenAndServe(":8080", mux)
} 

/john रूट पर भेजा गया कोई भी अनुरोध सीधे helloHandler.ServeHTTP मेथड को पास किया जाएगा। आप सर्वर शुरू करके और https://localhost:8080/john पर जाकर इसे क्रिया में देख सकते हैं।

हर बार जब आप http.Handler लागू करना चाहते हैं तो कस्टम प्रकार में ServeHTTP मेथड जोड़ना काफी थकाऊ होगा, इसलिए net/http पैकेज http.HandlerFunc प्रकार प्रदान करता है, जो सामान्य फंक्शन्स को HTTP हैंडलर्स के रूप में उपयोग करने की अनुमति देता है।

आपको बस यह सुनिश्चित करने की आवश्यकता है कि आपके फंक्शन में निम्न सिग्नेचर है: func(http.ResponseWriter, *http.Request); फिर, इसे http.HandlerFunc प्रकार में बदलें।

package main
import "net/http"
func helloJohnHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello John"))
}
func main() {
    mux := http.NewServeMux()
    mux.Handle("/john", http.HandlerFunc(helloJohnHandler))
    http.ListenAndServe(":8080", mux)
} 

आप main फंक्शन में mux.Handle लाइन को mux.HandleFunc से भी बदल सकते हैं और फंक्शन को सीधे इसमें पास कर सकते हैं। हमने पिछले लेख में विशेष रूप से इस पैटर्न का उपयोग किया था।

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/john", helloJohnHandler)
    http.ListenAndServe(":8080", mux)
} 

इस बिंदु पर, नाम स्ट्रिंग में हार्डकोडेड है, पहले के विपरीत जब हम main फंक्शन में हैंडलर को कॉल करने से पहले नाम सेट करने में सक्षम थे। इस सीमा को दूर करने के लिए, हम अपने हैंडलर लॉजिक को क्लोजर में रख सकते हैं, जैसा कि नीचे दिखाया गया है:

package main
import "net/http"
func helloHandler(name string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello " + name))
    })
}
func main() {
    mux := http.NewServeMux()
    mux.Handle("/john", helloHandler("John"))
    http.ListenAndServe(":8080", mux)
} 

helloHandler फंक्शन स्वयं http.Handler इंटरफ़ेस को संतुष्ट नहीं करता, लेकिन यह एक अनाम फंक्शन बनाता है और लौटाता है जो करता है। यह फंक्शन name पैरामीटर पर क्लोजर करता है, जिसका अर्थ है कि जब भी इसे कॉल किया जाता है तो यह इसे एक्सेस कर सकता है। इस बिंदु पर, helloHandler फंक्शन को आवश्यकतानुसार कई अलग-अलग नामों के लिए पुन: उपयोग किया जा सकता है।

तो, इस सब का मिडलवेयर से क्या लेना-देना है? खैर, मिडलवेयर फंक्शन बनाना ठीक उसी तरह किया जाता है जैसा हमने ऊपर देखा है। क्लोजर में एक स्ट्रिंग पास करने के बजाय (उदाहरण में जैसा), हम चेन में अगले हैंडलर को आर्गुमेंट के रूप में पास कर सकते हैं।

यहां पूरा पैटर्न है:

func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // मिडलवेयर लॉजिक यहां जाता है...
        next.ServeHTTP(w, r)
    })
} 

उपरोक्त middleware फंक्शन एक हैंडलर स्वीकार करता है और एक हैंडलर लौटाता है। ध्यान दें कि हम अनाम फंक्शन को http.HandlerFunc प्रकार में कास्ट करके http.Handler इंटरफ़ेस को संतुष्ट करने में सक्षम हैं। अनाम फंक्शन के अंत में, ServeHTTP() मेथड को इनवोक करके कंट्रोल को next हैंडलर को ट्रांसफर किया जाता है। यदि आपको हैंडलर्स के बीच मान पास करने की आवश्यकता है, जैसे प्रमाणित उपयोगकर्ता की आईडी, तो आप Go 1.7 में पेश किए गए http.Request.Context() मेथड का उपयोग कर सकते हैं।

आइए एक मिडलवेयर फंक्शन लिखें जो केवल इस पैटर्न को प्रदर्शित करता है। यह फंक्शन रिक्वेस्ट ऑब्जेक्ट में requestTime नामक एक प्रॉपर्टी जोड़ता है, जिसे बाद में helloHandler द्वारा अनुरोध के टाइमस्टैम्प को प्रदर्शित करने के लिए उपयोग किया जाता है।

package main
import (
    "context"
    "net/http"
    "time"
)
func requestTime(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        ctx = context.WithValue(ctx, "requestTime", time.Now().Format(time.RFC3339))
        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)
    })
}
func helloHandler(name string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        responseText := "<h1>Hello " + name + "</h1>"
        if requestTime := r.Context().Value("requestTime"); requestTime != nil {
            if str, ok := requestTime.(string); ok {
                responseText = responseText + "\n<small>Generated at: " + str + "</small>"
            }
        }
        w.Write([]byte(responseText))
    })
}
func main() {
    mux := http.NewServeMux()
    mux.Handle("/john", requestTime(helloHandler("John")))
    http.ListenAndServe(":8080", mux)
} 

चूंकि हमारा मिडलवेयर फंक्शन http.Handler प्रकार को स्वीकार करता है और लौटाता है, इसलिए मिडलवेयर फंक्शन्स की एक अनंत श्रृंखला बनाना संभव है जो एक दूसरे के अंदर नेस्टेड हैं।

उदाहरण के लिए,

mux := http.NewServeMux()
mux.Handle("/", middleware1(middleware2(appHandler))) 

आप उपरोक्त निर्माण को अधिक पठनीय रूप में बदलने के लिए Alice जैसी लाइब्रेरी का उपयोग कर सकते हैं:

alice.New(middleware1, middleware2).Then(appHandler) 

टेम्पलेटिंग

हालांकि सिंगल-पेज एप्लिकेशन के आगमन के साथ टेम्पलेट्स का उपयोग कम हो गया है, यह एक पूर्ण वेब डेवलपमेंट समाधान का एक महत्वपूर्ण पहलू बना हुआ है।

Go आपकी सभी टेम्पलेटिंग जरूरतों के लिए दो पैकेज प्रदान करता है: text/template और html/template। दोनों का इंटरफ़ेस समान है, लेकिन बाद वाला कोड इंजेक्शन एक्सप्लॉइट्स के खिलाफ सुरक्षा के लिए पर्दे के पीछे कुछ एन्कोडिंग करेगा।

हालांकि Go टेम्पलेट्स वहां सबसे अधिक अभिव्यंजक नहीं हैं, वे काम ठीक से पूरा करते हैं और प्रोडक्शन एप्लिकेशन के लिए उपयोग किए जा सकते हैं। वास्तव में, यह वही है जिस पर ह्यूगो, लोकप्रिय स्टैटिक साइट जनरेटर, अपने टेम्पलेटिंग सिस्टम को आधारित करता है।

आइए जल्दी से देखें कि html/template पैकेज का उपयोग वेब अनुरोध के प्रतिक्रिया के रूप में HTML आउटपुट भेजने के लिए कैसे किया जा सकता है।

टेम्पलेट बनाना

अपने main.go फाइल के समान डायरेक्टरी में एक index.html फाइल बनाएं और फाइल में निम्न कोड जोड़ें:

<ul> {{ range .TodoItems }} <li>{{ . }}</li> {{ end }} </ul> 

अब, अपने main.go फाइल में निम्न कोड जोड़ें:

package main
import (
    "html/template"
    "log"
    "os"
)
func main() {
    t, err := template.ParseFiles("index.html")
    if err != nil {
        log.Fatal(err)
    }
    todos := []string{"Watch TV", "Do homework", "Play games", "Read"}
    err = t.Execute(os.Stdout, todos)
    if err != nil {
        log.Fatal(err)
    }
} 

यदि आप उपरोक्त प्रोग्राम को go run main.go के साथ निष्पादित करते हैं। आपको निम्न आउटपुट देखना चाहिए:

<ul> <li>Watch TV</li> <li>Do homework</li> <li>Play games</li> <li>Read</li> </ul> 

बधाई हो! आपने अपना पहला Go टेम्पलेट बना लिया। यहां टेम्पलेट फाइल में हमारे द्वारा उपयोग किए गए सिंटैक्स का संक्षिप्त विवरण है:

• Go डेटा मूल्यांकन और कंट्रोल स्ट्रक्चर्स (जिन्हें एक्शन्स के रूप में जाना जाता है) को टेम्पलेट्स में सीमांकित करने के लिए डबल ब्रेसेस ({{ और }}) का उपयोग करता है।
• range एक्शन है जिससे हम स्लाइस जैसे डेटा स्ट्रक्चर्स पर पुनरावृति करने में सक्षम होते हैं।
• . वर्तमान संदर्भ को दर्शाता है। range एक्शन में, वर्तमान संदर्भ todos का स्लाइस है। ब्लॉक के अंदर, {{ . }} स्लाइस में प्रत्येक तत्व को संदर्भित करता है।

main.go फाइल में, template.ParseFiles मेथड का उपयोग एक या अधिक फाइलों से एक नया टेम्पलेट बनाने के लिए किया जाता है। इस टेम्पलेट को बाद में template.Execute मेथड का उपयोग करके निष्पादित किया जाता है; यह एक io.Writer और डेटा लेता है, जिसे टेम्पलेट पर लागू किया जाएगा।

उपरोक्त उदाहरण में, टेम्पलेट को स्टैंडर्ड आउटपुट पर निष्पादित किया जाता है, लेकिन हम इसे किसी भी गंतव्य पर निष्पादित कर सकते हैं, जब तक कि यह io.Writer इंटरफ़ेस को संतुष्ट करता है। उदाहरण के लिए, यदि आप आउटपुट को वेब अनुरोध के हिस्से के रूप में वापस करना चाहते हैं, तो आपको बस टेम्पलेट को ResponseWriter इंटरफ़ेस पर निष्पादित करने की आवश्यकता है, जैसा कि नीचे दिखाया गया है।

package main
import (
    "html/template"
    "log"
    "net/http"
)
func main() {
    t, err := template.ParseFiles("index.html")
    if err != nil {
        log.Fatal(err)
    }
    todos := []string{"Watch TV", "Do homework", "Play games", "Read"}
    http.HandleFunc("/todos", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        err = t.Execute(w, todos)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
        }
    })
    http.ListenAndServe(":8080", nil)
} 

यह खंड केवल Go के टेम्पलेट पैकेजेस का एक त्वरित परिचय है। यदि आप अधिक जटिल उपयोग के मामलों में रुचि रखते हैं तो text/template और html/template के डॉक्यूमेंटेशन को अवश्य देखें।

यदि आप Go के टेम्पलेटिंग के तरीके के प्रशंसक नहीं हैं, तो विकल्प मौजूद हैं, जैसे Plush लाइब्रेरी।

JSON के साथ काम करना

यदि आपको JSON ऑब्जेक्ट्स के साथ काम करने की आवश्यकता है, तो आप यह जानकर प्रसन्न होंगे कि Go की स्टैंडर्ड लाइब्रेरी में encoding/json पैकेज के माध्यम से JSON को पार्स और एन्कोड करने के लिए आवश्यक सब कुछ शामिल है।

डिफ़ॉल्ट प्रकार

Go में JSON ऑब्जेक्ट को एन्कोड या डिकोड करते समय, निम्न प्रकारों का उपयोग किया जाता है:

• JSON बूलियन्स के लिए bool,
• JSON नंबर्स के लिए float64,
• JSON स्ट्रिंग्स के लिए string,
• JSON null के लिए nil,
• JSON ऑब्जेक्ट्स के लिए map[string]interface{}, और
• JSON एरेज़ के लिए []interface{}।

एन्कोडिंग

डेटा स्ट्रक्चर को JSON के रूप में एन्कोड करने के लिए, json.Marshal फंक्शन का उपयोग किया जाता है। यहां एक उदाहरण है:

package main
import (
    "encoding/json"
    "fmt"
)
type Person struct {
    FirstName string
    LastName string
    Age int
    email string
}
func main() {
    p := Person{
        FirstName: "Abraham",
        LastName: "Freeman",
        Age: 100,
        email: "abraham.freeman@hey.com",
    }
    json, err := json.Marshal(p)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(json))
} 

उपरोक्त प्रोग्राम में, हमारे पास चार अलग-अलग फील्ड्स के साथ एक Person स्ट्रक्चर है। main फंक्शन में, Person का एक इंस्टेंस सभी फील्ड्स इनिशियलाइज़्ड के साथ बनाया जाता है। json.Marshal मेथड का उपयोग तब p स्ट्रक्चर को JSON में बदलने के लिए किया जाता है। यह मेथड बाइट्स का एक स्लाइस या एक त्रुटि लौटाता है, जिसे JSON डेटा तक पहुंचने से पहले हमें संभालना होगा।

Go में बाइट्स के स्लाइस को स्ट्रिंग में बदलने के लिए, हमें टाइप कन्वर्जन करने की आवश्यकता होती है, जैसा कि ऊपर दिखाया गया है। इस प्रोग्राम को चलाने से निम्न आउटपुट मिलेगा:

{"FirstName":"Abraham","LastName":"Freeman","Age":100} 

जैसा कि आप देख सकते हैं, हमें एक वैध JSON ऑब्जेक्ट मिलता है जिसे हम किसी भी तरह से उपयोग कर सकते हैं। ध्यान दें कि email फील्ड परिणाम से बाहर रह गया है। ऐसा इसलिए है क्योंकि यह लोअरकेस अक्षर से शुरू होने के कारण Person ऑब्जेक्ट से एक्सपोर्ट नहीं किया गया है।

डिफ़ॉल्ट रूप से, Go स्ट्रक्चर में समान प्रॉपर्टी नामों का उपयोग परिणामी JSON ऑब्जेक्ट में फील्ड नामों के रूप में करता है। हालांकि, स्ट्रक्चर फील्ड टैग्स के उपयोग के माध्यम से इसे बदला जा सकता है।

type Person struct {
    FirstName string `json:"first_name"`
    LastName string `json:"last_name"`
    Age int `json:"age"`
    email string `json:"email"`
} 

उपरोक्त स्ट्रक्चर फील्ड टैग्स निर्दिष्ट करते हैं कि JSON एन्कोडर को स्ट्रक्चर में FirstName प्रॉपर्टी को JSON ऑब्जेक्ट में first_name फील्ड पर मैप करना चाहिए और इसी तरह। पिछले उदाहरण में यह परिवर्तन निम्न आउटपुट उत्पन्न करता है:

{"first_name":"Abraham","last_name":"Freeman","age":100} 

डिकोडिंग

json.Unmarshal फंक्शन का उपयोग JSON ऑब्जेक्ट को Go स्ट्रक्चर में डिकोड करने के लिए किया जाता है। इसका निम्न सिग्नेचर है:

func Unmarshal(data []byte, v interface{}) error 

यह JSON डेटा का एक बाइट स्लाइस और डिकोडेड डेटा को स्टोर करने के लिए एक स्थान स्वीकार करता है। यदि डिकोडिंग सफल होती है, तो लौटी त्रुटि nil होगी।

मान लें हमारे पास निम्न JSON ऑब्जेक्ट है,

json := "{"first_name":"John","last_name":"Smith","age":35, "place_of_birth": "London", gender:"male"}" 

हम इसे Person स्ट्रक्चर के एक इंस्टेंस में डिकोड कर सकते हैं, जैसा कि नीचे दिखाया गया है:

func main() {
    b := `{"first_name":"John","last_name":"Smith","age":35, "place_of_birth": "London", "gender":"male", "email": "john.smith@hmail.com"}`
    var p Person
    err := json.Unmarshal([]byte(b), &p)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("%+v\n", p)
} 

और आपको निम्न आउटपुट मिलता है:

{FirstName:John LastName:Smith Age:35 email:} 

Unmarshal केवल उन फील्ड्स को डिकोड करता है जो डेस्टिनेशन प्रकार में पाए जाते हैं। इस मामले में, place_of_birth और gender को नजरअंदाज कर दिया जाता है क्योंकि वे Person में किसी भी स्ट्रक्चर फील्ड पर मैप नहीं करते। इस व्यवहार का उपयोग बड़े JSON ऑब्जेक्ट से केवल कुछ विशिष्ट फील्ड्स को चुनने के लिए किया जा सकता है। पहले की तरह, डेस्टिनेशन स्ट्रक्चर में अनएक्सपोर्टेड फील्ड्स अप्रभावित रहते हैं भले ही JSON ऑब्जेक्ट में उनका संबंधित फील्ड हो। इसीलिए email आउटपुट में एक खाली स्ट्रिंग रह जाता है भले ही यह JSON ऑब्जेक्ट में मौजूद हो।

डेटाबेस

database/sql पैकेज SQL (या SQL-जैसे) डेटाबेस के चारों ओर एक जेनेरिक इंटरफ़ेस प्रदान करता है। इसका उपयोग डेटाबेस ड्राइवर के साथ संयोजन में किया जाना चाहिए, जैसे कि यहां सूचीबद्ध हैं। डेटाबेस ड्राइवर आयात करते समय, आपको इसे अंडरस्कोर _ से प्रीफिक्स करने की आवश्यकता होती है ताकि इसे इनिशियलाइज़ किया जा सके।

उदाहरण के लिए, यहां database/sql के साथ MySQL ड्राइवर पैकेज का उपयोग करने का तरीका बताया गया है:

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
) 

हुड के तहत, ड्राइवर खुद को database/sql पैकेज के लिए उपलब्ध के रूप में रजिस्टर करता है, लेकिन इसका उपयोग सीधे हमारे कोड में नहीं किया जाएगा। यह हमें एक विशिष्ट ड्राइवर पर निर्भरता कम करने में मदद करता है ताकि इसे न्यूनतम प्रयास के साथ दूसरे के लिए आसानी से बदला जा सके।

डेटाबेस कनेक्शन खोलना

डेटाबेस तक पहुंचने के लिए, आपको एक sql.DB ऑब्जेक्ट बनाने की आवश्यकता है, जैसा कि नीचे दिखाया गया है:

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/hello")
    if err != nil {
        log.Fatal(err)
    }
} 

sql.Open मेथड बाद में उपयोग के लिए डेटाबेस अब्स्ट्रैक्शन तैयार करता है। यह डेटाबेस से कनेक्शन स्थापित नहीं करता या कनेक्शन पैरामीटर्स को मान्य नहीं करता। यदि आप तुरंत सुनिश्चित करना चाहते हैं कि डेटाबेस उपलब्ध और सुलभ है, तो db.Ping() मेथड का उपयोग करें:

err = db.Ping()
if err != nil {
    log.Fatal(err)
} 

डेटाबेस कनेक्शन बंद करना

डेटाबेस कनेक्शन बंद करने के लिए, आप db.Close() का उपयोग कर सकते हैं। आमतौर पर, आप डेटाबेस कनेक्शन खोलने वाले फंक्शन के अंत तक, आमतौर पर main फंक्शन तक डेटाबेस को बंद करने को defer करना चाहेंगे:

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/hello")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
} 

sql.DB ऑब्जेक्ट को लंबे समय तक चलने के लिए डिज़ाइन किया गया है, इसलिए आपको इसे बार-बार खोलना और बंद नहीं करना चाहिए। यदि आप ऐसा करते हैं, तो आप समस्याओं का अनुभव कर सकते हैं, जैसे कनेक्शन्स के खराब पुन: उपयोग और साझाकरण, उपलब्ध नेटवर्क संसाधनों की कमी, या छिटपुट विफलताएं। sql.DB मेथड को पास करना या इसे वैश्विक रूप से उपलब्ध कराना और केवल तभी बंद करना सबसे अच्छा है जब प्रोग्राम उस डेटास्टोर को एक्सेस करना समाप्त कर दे।

डेटाबेस से डेटा प्राप्त करना

टेबल को क्वेरी करना तीन चरणों में किया जा सकता है। पहला, db.Query() कॉल करें। फिर, पंक्तियों पर पुनरावृति करें। अंत में, प्रत्येक पंक्ति को वेरिएबल्स में निकालने के लिए rows.Scan() का उपयोग करें। यहां एक उदाहरण है:

var (
    id int
    name string
)
rows, err := db.Query("select id, name from users where id = ?", 1)
if err != nil {
    log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
    err := rows.Scan(&id, &name)
    if err != nil {
        log.Fatal(err)
    }
    log.Println(id, name)
}
err = rows.Err()
if err != nil {
    log.Fatal(err)
} 

यदि कोई क्वेरी एक सिंगल पंक्ति लौटाती है, तो आप लंबे बॉयलरप्लेट कोड से बचने के लिए db.Query के बजाय db.QueryRow मेथड का उपयोग कर सकते हैं:

var (
    id int
    name string
)
err = db.QueryRow("select id, name from users where id = ?", 1).Scan(&id, &name)
if err != nil {
    log.Fatal(err)
}
fmt.Println(id, name) 

NoSQL डेटाबेस

Go का NoSQL डेटाबेस, जैसे Redis, MongoDB, Cassandra, आदि के लिए भी अच्छा समर्थन है, लेकिन यह उनके साथ काम करने के लिए एक स्टैंडर्ड इंटरफ़ेस प्रदान नहीं करता। आपको विशिष्ट डेटाबेस के लिए ड्राइवर पैकेज पर पूरी तरह से भरोसा करना होगा। कुछ उदाहरण नीचे सूचीबद्ध हैं।

• https://github.com/go-redis/redis (Redis ड्राइवर)।
• https://github.com/mongodb/mongo-go-driver (MongoDB ड्राइवर)।
• https://github.com/gocql/gocql (Cassandra ड्राइवर)।
• https://github.com/Shopify/sarama (Apache Kafka ड्राइवर)

समापन

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

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

पढ़ने के लिए धन्यवाद, और हैप्पी कोडिंग!