गो आइरिस रूटिंग

The iris framework में रूट बाइंडिंग के लिए दो तरीके हैं, एक कार्यात्मक और दूसरा MVC है। कार्यात्मक तरीका एक निर्धारित URL पथ पर एक हैंडलिंग फ़ंक्शन को बाइंड करता है, जबकि MVC तरीका एक कंट्रोलर को एक URL पथ से जोड़ता है। Framework स्वचालित रूप से कंट्रोलर मेथड्स के नामनिर्धारण नियमों पर आधारित URL पथ को उत्पन्न करता है, और सम्बंधित कंट्रोलर फ़ंक्शन को स्वचालित रूप से जोड़ता है।

कार्यात्मक रूट बाइंडिंग

Iris framework में सबसे सरल रूटिंग मॉडल, जहां आप किसी भी URL से किसी फ़ंक्शन को बाइंड कर सकते हैं।

func main() {
    // Default middleware के साथ एक iris एप्लिकेशन बनाएं:
    // डिफ़ॉल्ट रूप से, इस्में "debug" लॉग स्तर का उपयोग किया जाता है।
    // यह "./locales" निर्देशिका के तहत स्थानांतरण का समर्थन करता है।
    // HTML टेम्पलेट्स "./views" या "./templates" निर्देशिकाओं के तहत स्थित हैं।
    // पहुंच लॉग "./access.log" में सहेजे जाते हैं,
    // और बिना ज्ञापन के अक्षमीकरण (क्रैश होने) और अनुरोध आईडी मिडलवेयर पहले से ही जुड़े हुए हैं।
    app := iris.Default()

    // सिर्फ़ अनुरोध विधि और पथ के आधार पर रूट फ़ंक्शन को बाइंड करें, जैसा की Gin, echo, और अन्य frameworks में रूटिंग तंत्र के समान है।
    app.Get("/someGet", getting)
    app.Post("/somePost", posting)
    app.Put("/somePut", putting)
    app.Delete("/someDelete", deleting)
    app.Patch("/somePatch", patching)
    app.Header("/someHead", head)
    app.Options("/someOptions", options)

    // पोर्ट पर सुनें
    app.Listen(":8080")
}

func main() {
    app := iris.Default()

    // यह हैंडलर /user/john के साथ मिलेगा लेकिन /user/ या /user के साथ नहीं मिलेगा
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("नमस्ते %s", name)
    })
    
    // हालांकि, यह हैंडलर /user/john/ और /user/john/send के साथ मिलेगा
    // अगर कोई अन्य रूट /user/john से मेल नहीं खाता है, तो यह /user/john/ पर पुनर्प्रेषित करेगा
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        message := name + " " + action + " है"
        ctx.WriteString(message)
    })
    
    // हर मिले हुए अनुरोध के लिए, Context रूट की परिभाषा को रखेगा
    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
        ctx.GetCurrentRoute().Tmpl().Src == "/user/{name:string}/{action:path}" // true
    })
    
    app.Listen(":8080")
}

पारमीटर प्रकार उपलब्ध निर्मित पारमीटर इस प्रकार हैं:

## समूह रूटिंग

कभी-कभी, API संस्करण प्रबंधन की आवश्यकता होती है, या बड़े मॉड्यूल की रूटिंग के लिए एक समानिक प्रिफ़िक्स सेट किया जाता है। यहां समूह रूटिंग की क्षमता का उपयोग होता है।

```go
func main() {
    app := iris.Default()

    // सरल समूह: v1
    v1 := app.Party("/v1")
    {
        v1.Post("/login", loginEndpoint)
        v1.Post("/submit", submitEndpoint)
        v1.Post("/read", readEndpoint)
    }
    
    // सरल समूह: v2
    v2 := app.Party("/v2")
    {
        v2.Post("/login", loginEndpoint)
        v2.Post("/submit", submitEndpoint)
        v2.Post("/read", readEndpoint)
    }
    
    app.Listen(":8080")
}

MVC रूटिंग

Go Iris फ़्रेमवर्क MVC आर्किटेक्चर का समर्थन करता है, निश्चित नियमों के माध्यम से मानचित्रण रूटिंग को विशिष्ट कंट्रोलर फ़ंक्शनों से मैप करता है।

package main

import (
	"strings"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/middleware/logger"
	"github.com/kataras/iris/v12/middleware/recover"
	"github.com/kataras/iris/v12/mvc"
)

// एक iris अनुप्रयोग बनाएँ
func newApp() *iris.Application {
	app := iris.New()
	// दो मिडलवेयर सेट करें
	// रिकवर पैनिक त्रुटियों को रोकने के लिए उपयोग किया जाता है
	// लॉगर अनुरोध को लोग करने के लिए उपयोग किया जाता है
	app.Use(recover.New())
	app.Use(logger.New())

	// यहां कंट्रोलर को "/" मूल रूट पर पंजीकृत करें।
	mvc.New(app).Handle(new(ExampleController))
	
	// इसे रूट समूह की सहायता से एक विशिष्ट पथ पर पंजीकृत किया जा सकता है
	// उदाहरण: "/books" पथ के तहत कंट्रोलर को पंजीकृत करें
	// mvc.New(app.Party("/books")).Handle(new(ExampleController))
}

func main() {
	// अनुप्रयोग बनाएँ
	app := newApp()

	// http://localhost:8080
	// http://localhost:8080/ping
	// http://localhost:8080/hello
	// http://localhost:8080/custom_path
	app.Listen(":8080")
}

// "/" , "/ping", और "/hello" के लिए अनुरोधों को संभालने के लिए ExampleController को परिभाषित करें।
type ExampleController struct{}

// GET अनुरोध संभालना
// अनुरोध URL: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>स्वागत</h1>",
	}
}

// GetPing सेवा
// विधि:   GET
// अनुरोध URL: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "पंग"
}

// GetHello सेवा
// विधि:   GET
// अनुरोध URL: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"संदेश": "नमस्ते Iris!"}
}

// GetHelloWorld सेवा
// विधि:   GET
// अनुरोध URL: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"संदेश": "नमस्ते Iris! डिफ़ॉल्टपथ"}
}

MVC रूटिंग और कंट्रोलर फ़ंक्शनों के नामकरण नियम के बीच संबंध।

रूट पता: रूट समूह + HTTP विधि का नाम + फ़ंक्शन का नाम (लोअरकेस)

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

func (c *ExampleController) GetPing() string {
	return "पंग"
}

क्योंकि कोई रूट समूह सेट नहीं है, तो इस फ़ंक्शन से http://localhost:8080/ping के लिए GET अनुरोध संभाल सकता है।