डॉक्स

गोफरलाइट

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

go get github.com/BrunoCiccarino/GopherLight/router
go get github.com/BrunoCiccarino/GopherLight/req

पहले से ही डाउनलोड किया हुआ? ओह! अब हम अपना पहला हैलो वर्ल्ड बना सकते हैं।

package main

import (
    "fmt"
    "github.com/BrunoCiccarino/GopherLight/router"
    "github.com/BrunoCiccarino/GopherLight/req"
)


func main() {
    app := router.NewApp()

    // Define a route that responds to a GET request at "/hello".
    app.Get("/hello", func(r *req.Request, w *req.Response) {
        w.Send("Hello, World!")
    })

    fmt.Println("Server listening on port 3333")
    app.Listen(":3333")
}

बहुत सरल, है ना? और गोफरलाइट के साथ हम और भी बहुत कुछ कर सकते हैं। HTTP विधियों और हमारे अनुरोध और प्रतिक्रिया टूल के पूर्ण विवरण के लिए पढ़ते रहें।

समर्थित HTTP तरीके
यहां HTTP विधियों की सूची दी गई है जिनका उपयोग आप राउटर.ऐप के साथ कर सकते हैं। इनमें से प्रत्येक आपको विभिन्न प्रकार के अनुरोधों को संभालने के लिए मार्ग स्थापित करने की अनुमति देता है। आइए गोता लगाएँ!

पाना

• उपयोग: ऐप.गेट(पथ, हैंडलर)

कुछ भी संशोधित किए बिना डेटा पुनर्प्राप्त करता है।
उदाहरण: वस्तुओं की सूची प्राप्त करना या उपयोगकर्ता विवरण पढ़ना।

डाक

• उपयोग: ऐप.पोस्ट(पथ, हैंडलर)

नया संसाधन बनाने के लिए डेटा भेजता है।
उदाहरण: एक फॉर्म सबमिट करना या किसी सूची में एक नया आइटम जोड़ना।

रखना

उपयोग: ऐप.पुट(पथ, हैंडलर)

किसी संसाधन को अद्यतन या प्रतिस्थापित करता है। यह एक "ओवरराइट" क्रिया है।
उदाहरण: पूर्ण उपयोगकर्ता प्रोफ़ाइल अपडेट करना।

मिटाना

उपयोग: ऐप.डिलीट(पथ, हैंडलर)

एक संसाधन हटाता है।
उदाहरण: किसी उपयोगकर्ता को हटाना या किसी पोस्ट को हटाना।

पैबंद

उपयोग: ऐप.पैच(पथ, हैंडलर)

सबकुछ बदले बिना किसी संसाधन को आंशिक रूप से अद्यतन करता है।
उदाहरण: उपयोगकर्ता प्रोफ़ाइल पर केवल ईमेल अपडेट करना।

विकल्प

उपयोग: ऐप.विकल्प(पथ, हैंडलर)

यूआरएल के लिए अनुमत HTTP तरीकों को लौटाता है, मुख्य रूप से CORS प्रीफ़्लाइट अनुरोधों के लिए।

सिर

उपयोग: ऐप.हेड(पथ, हैंडलर)

GET की तरह, लेकिन कोई प्रतिक्रिया निकाय नहीं। यह जांचने के लिए इसका उपयोग करें कि कोई संसाधन मौजूद है या नहीं।

कनेक्ट करें और ट्रेस करें

उपयोग: ऐप.कनेक्ट(पथ, हैंडलर), ऐप.ट्रेस(पथ, हैंडलर)

उन्नत तरीके: CONNECT एक सुरंग स्थापित करता है (SSL के लिए), और TRACE डिबगिंग के लिए है, जो अनुरोध को प्रतिध्वनित करता है।

Req.Request और req.Response के साथ कार्य करना

अब जब आपने मार्ग देख लिए हैं, तो आइए अनुरोध और प्रतिक्रिया ऑब्जेक्ट के बारे में बात करें, जो आने वाले अनुरोधों को संभालने और प्रतिक्रिया भेजने के लिए आपके सहायक हैं।

अनुरोध

प्रत्येक अनुरोध हैंडलर को आने वाले अनुरोध पर जानकारी के साथ एक अनुरोध ऑब्जेक्ट लोड किया जाता है। यहां बताया गया है कि आप इसके साथ क्या कर सकते हैं:

• क्वेरी पैरामीटर: .QueryParam("कुंजी") के साथ क्वेरी पैरामीटर प्राप्त करें।
• हेडर: .हेडर('कुंजी') का उपयोग करके हेडर तक पहुंचें।
• बॉडी को स्ट्रिंग के रूप में: अनुरोध बॉडी को .BodyAsString() से पकड़ें।

उदाहरण:

app.Get("/greet", func(r *req.Request, w *req.Response) {
    name := r.QueryParam("name")
    if name == "" {
        name = "stranger"
    }
    w.Send("Hello, "   name   "!")
})

प्रतिक्रिया

रिस्पांस ऑब्जेक्ट आपको क्लाइंट को उत्तर वापस भेजने में मदद करता है। यहां आप क्या कर सकते हैं:

• पाठ भेजें: .भेजें(डेटा स्ट्रिंग) सादा पाठ वापस लिखता है।
• स्थिति सेट करें: .स्थिति(कोड) HTTP स्थिति निर्धारित करता है।
• JSON भेजें: .JSON(डेटा) एक Go ऑब्जेक्ट को JSON पर क्रमबद्ध करता है और उसे भेजता है।
• हैंडल त्रुटियां: .JSONError(संदेश) एक JSON-स्वरूपित त्रुटि प्रतिक्रिया भेजता है।

उदाहरण:

app.Get("/user", func(r *req.Request, w *req.Response) {
    user := map[string]string{"name": "Gopher", "language": "Go"}
    w.JSON(user)
})

मिडलवेयर

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

प्रमाणीकरण मिडलवेयर (JWT)

हमारा ऑथमिडलवेयर JSON वेब टोकन (JWT) के साथ आपके मार्गों को सुरक्षित रखने में मदद करता है। यह लचीला है, जो आपको गुप्त कुंजी, त्रुटि प्रबंधन और टोकन निष्कर्षण विधि को अनुकूलित करने देता है।

स्थापित करना
आरंभ करने के लिए, JWTConfig का उपयोग करके अपनी JWT सेटिंग्स कॉन्फ़िगर करें:

• SecretKey: JWTs पर हस्ताक्षर करने की गुप्त कुंजी।
• साइनिंगमेथड: जेडब्ल्यूटी साइनिंग एल्गोरिदम।
• ErrorHandler: प्रमाणीकरण त्रुटियों को संभालने के लिए कस्टम त्रुटि हैंडलर (वैकल्पिक)।
• TokenExtractor: अनुरोध हेडर से टोकन निकालता है (वैकल्पिक)।

उदाहरण

import (
    "github.com/BrunoCiccarino/GopherLight/middleware"
)

config := middleware.JWTConfig{
    SecretKey: []byte("your_secret_key"),
}
app.Use(middleware.NewAuthMiddleware(config))

CORS मिडलवेयर

क्रॉस-ओरिजिन अनुरोधों को अनुमति देने की आवश्यकता है? कोई बात नहीं! हमारा CORSMiddleware आपके API को अन्य डोमेन से पहुंच योग्य बनाने के लिए क्रॉस-ओरिजिनल रिसोर्स शेयरिंग (CORS) सेटिंग्स को कॉन्फ़िगर करता है।

कॉन्फ़िगर विकल्प

• AllowOrigin: किसी भी मूल की अनुमति देने या डोमेन निर्दिष्ट करने के लिए "*" पर सेट करें (उदाहरण के लिए, "http://example.com")।
• AllowMethods: कौन सी HTTP विधियों की अनुमति है? सामान्य विकल्पों में "प्राप्त करें", "पोस्ट करें" आदि शामिल हैं।
• AllowHeaders: निर्दिष्ट करें कि ग्राहक कौन से हेडर का उपयोग कर सकते हैं।
• अनुमति दें: यदि आप कुकीज़ या HTTP प्रमाणीकरण को शामिल करना चाहते हैं तो सही पर सेट करें।
• एक्सपोज़हेडर: क्लाइंट को प्रतिक्रिया से विशिष्ट हेडर पढ़ने दें।
• अधिकतम आयु: उड़ान पूर्व अनुरोधों के लिए कैश समय (सेकंड में)।

उदाहरण

corsOptions := middleware.CORSOptions{
    AllowOrigin: "*",
    AllowMethods: []string{"GET", "POST"},
}
app.Use(middleware.CORSMiddleware(corsOptions))

सीएसआरएफ मिडलवेयर

हमारा CSRFMiddleware प्रत्येक अनुरोध के साथ भेजे गए CSRF टोकन को मान्य करके क्रॉस-साइट अनुरोध जालसाजी से बचाता है। सुरक्षित टोकन बनाने के लिए GenerateCSRFToken() का उपयोग करें, फिर इसे अपने स्वयं के isValidToken फ़ंक्शन से सत्यापित करें।

उदाहरण

app.Use(middleware.CSRFMiddleware(func(token string) bool {
    return token == "your_valid_token"
}))

और इसके साथ टोकन जनरेट करना न भूलें:

csrfToken := middleware.GenerateCSRFToken()

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

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

उदाहरण

app.Use(middleware.LoggingMiddleware)

प्रत्येक अनुरोध इस प्रकार लॉग किया जाएगा:

• प्रारंभ: अनुरोध प्रारंभ समय लॉग करता है।
• पूर्ण: अनुरोध समाप्त होने पर लॉग, अवधि सहित।

टाइमआउट मिडलवेयर

TimeoutMiddleware के साथ अनुरोध प्रसंस्करण पर समय सीमा निर्धारित करके उन अंतहीन प्रतीक्षाओं से बचें। यदि अनुरोध समय पर पूरा नहीं होता है तो यह मिडलवेयर क्लाइंट को 504 गेटवे टाइमआउट स्थिति भेजकर रद्द कर देगा।

उदाहरण

import (
    "time"
    "github.com/BrunoCiccarino/GopherLight/middleware"
)

timeout := 2 * time.Second
app.Use(middleware.TimeoutMiddleware(timeout))

प्लगइन इंटरफ़ेस

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

रजिस्टर विधि
यहां प्लगइन इंटरफ़ेस का जादुई हिस्सा है:

type Plugin interface {
    Register(route func(method, path string, handler func(req *req.Request, res *req.Response)))
}

रजिस्टर विधि एक रूट फ़ंक्शन को स्वीकार करती है जो आपको निर्दिष्ट करके अपने प्लगइन में नए मार्गों को परिभाषित करने देती है:

• विधि: HTTP विधि (उदाहरण के लिए, "प्राप्त करें", "पोस्ट करें", आदि)
• पथ: मार्ग पथ (जैसे, "/my-plugin-route")
• हैंडलर: रूट हिट होने पर निष्पादित किया जाने वाला फ़ंक्शन। यह फ़ंक्शन प्राप्त करता है:
  • req: क्वेरी पैरामीटर, हेडर और बॉडी तक पहुंच के साथ अनुरोध ऑब्जेक्ट।
  • res: क्लाइंट को डेटा वापस भेजने के लिए प्रतिक्रिया ऑब्जेक्ट।

उदाहरण प्लगइन

मान लीजिए कि आप एक प्लगइन बनाना चाहते हैं जो उपयोगकर्ताओं का स्वागत करने के लिए /hello-plugin पर एक सरल एंडपॉइंट जोड़ता है। यहां बताया गया है कि प्लगइन कैसा दिखेगा:

package main

import (
    "github.com/BrunoCiccarino/GopherLight/plugins"
    "github.com/BrunoCiccarino/GopherLight/req"
)

type HelloPlugin struct{}

// Register adds a new route for the HelloPlugin.
func (p *HelloPlugin) Register(route func(method, path string, handler func(req *req.Request, res *req.Response))) {
    route("GET", "/hello-plugin", func(req *req.Request, res *req.Response) {
        res.Send("Hello from the HelloPlugin!")
    })
}

अपने ऐप में प्लगइन जोड़ना

एक प्लगइन लोड करने के लिए, बस एक इंस्टेंस बनाएं और अपने मुख्य ऐप सेटअप में रजिस्टर पर कॉल करें:

package main

import (
    "github.com/BrunoCiccarino/GopherLight/router"
)

func main() {
    app := router.NewApp()
    helloPlugin := &HelloPlugin{}
    helloPlugin.Register(app.Route)

    app.Listen(":3333")
}

अपने प्लगइन्स को अनुकूलित करना

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