वेब डेवलपमेंट इन गो:मिडलवेयर, टेम्प्लेटिंग, डेटाबेस और परे

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

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

गो में मिडलवेयर

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

गो में मिडलवेयर को लागू करने के लिए, आपको यह सुनिश्चित करने की आवश्यकता है कि आपके पास एक प्रकार है जो 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 पर जाकर इसे क्रिया में देख सकते हैं।

ServeHTTPजोड़ना होगा हर बार जब आप http.Handler . को लागू करना चाहते हैं तो कस्टम प्रकार के लिए विधि काफी थकाऊ होगा, इसलिए 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)
}

आप mux.Handle . को भी बदल सकते हैं main . में पंक्ति ऊपर 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) {
    // Middleware logic goes here...
    next.ServeHTTP(w, r)
  })
}

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

आइए एक मिडलवेयर फ़ंक्शन लिखें जो केवल इस पैटर्न को प्रदर्शित करता है। यह फ़ंक्शन 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.New(middleware1, middleware2).Then(appHandler)

टेम्पलेट करना

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

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

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

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

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

एक index.html बनाएं उसी निर्देशिका में फ़ाइल करें जिसमें आपका main.go . है फ़ाइल करें और फ़ाइल में निम्न कोड जोड़ें:

<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 डबल ब्रेसिज़ का उपयोग करता है ({{ और }} ) डेटा मूल्यांकन और नियंत्रण संरचनाओं (क्रियाओं . के रूप में जाना जाता है) को परिसीमित करने के लिए ) टेम्प्लेट में।
• द range कार्रवाई यह है कि हम स्लाइस जैसे डेटा संरचनाओं पर कैसे पुनरावृति करने में सक्षम हैं।
• . वर्तमान संदर्भ का प्रतिनिधित्व करता है। range . में क्रिया, वर्तमान संदर्भ todos . का टुकड़ा है . ब्लॉक के अंदर, {{ . }} स्लाइस में प्रत्येक तत्व को संदर्भित करता है।

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

उपरोक्त उदाहरण में, टेम्प्लेट को मानक आउटपुट के लिए निष्पादित किया जाता है, लेकिन हम इसे किसी भी गंतव्य पर निष्पादित कर सकते हैं, जब तक कि यह 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)
}

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

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

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

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

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

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

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

एन्कोडिंग

डेटा संरचना को 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:     "[email protected]",
    }

    json, err := json.Marshal(p)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(json))
}

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

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

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

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

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

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

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

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

डिकोडिंग

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

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": "[email protected]"}`
    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 के साथ MySQLdriver पैकेज का उपयोग करने का तरीका बताया गया है :

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

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

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

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

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() . का उपयोग कर सकते हैं . आम तौर पर, आप defer करना चाहते हैं डेटाबेस का समापन तब तक होता है जब तक कि डेटाबेस कनेक्शन खोलने वाला फ़ंक्शन समाप्त नहीं हो जाता, आमतौर पर main समारोह:

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.QueryRow . का उपयोग कर सकते हैं db.Query . के बजाय विधि और पिछले कोडनिपेट में कुछ लंबे बॉयलरप्लेट कोड से बचें:

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 (कैसंड्रा ड्राइवर)।
• https://github.com/Shopify/sarama (अपाचे काफ्का ड्राइवर)

रैपिंग अप

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

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

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