fx Go: पूर्ण गाइड उदाहरणों के साथ

यह लाइब्रेरी क्या है और क्यों ज़रूरी है

fx Go भाषा के लिए Uber द्वारा विकसित एक शक्तिशाली dependency injection (DI) फ्रेमवर्क है। यह Go एप्लिकेशन में डिपेंडेंसी प्रबंधन का एक सुंदर तरीका प्रदान करता है, ऑब्जेक्ट्स के निर्माण, जुड़ाव और जीवनचक्र को स्वचालित करता है।

पारंपरिक Go एप्लिकेशन में, डेवलपर्स को अक्सर "कंस्ट्रक्टर हेल" (constructor hell) की समस्या का सामना करना पड़ता है, जहां एक ऑब्जेक्ट बनाने के लिए कई डिपेंडेंसी पास करनी होती हैं। इससे होता है:

• मैन्युअल डिपेंडेंसी प्रबंधन वाला भारी-भरकम कोड
• टेस्टिंग में कठिनाइयाँ
• एप्लिकेशन आर्किटेक्चर बदलने में मुश्किलें

fx इन समस्याओं को हल करता है:

• ऑटोमैटिक डिपेंडेंसी इंजेक्शन — फ्रेमवर्क खुद तय करता है कि किन ऑब्जेक्ट्स की ज़रूरत है और उन्हें किस क्रम में बनाना है
• जीवनचक्र प्रबंधन — कम्पोनेंट्स का ऑटोमैटिक स्टार्ट और स्टॉप
• मॉड्यूलरिटी — एप्लिकेशन को स्वतंत्र मॉड्यूल में बांटा जा सकता है
• टेस्टेबिलिटी — वास्तविक डिपेंडेंसी को आसानी से mock ऑब्जेक्ट्स से बदला जा सकता है

fx विशेष रूप से उपयोगी है:

• माइक्रोसर्विसेज
• वेब एप्लिकेशन
• CLI टूल्स
• जटिल डिपेंडेंसी आर्किटेक्चर वाले किसी भी एप्लिकेशन में

इंस्टॉलेशन

fx की इंस्टॉलेशन Go लाइब्रेरी के मानक तरीके से go get के ज़रिए होती है:

go get go.uber.org/fx

नवीनतम संस्करण में अपडेट करने के लिए:

go get -u go.uber.org/fx

इंस्टॉल करने के बाद, अपने कोड में लाइब्रेरी को इम्पोर्ट करें:

import "go.uber.org/fx"

कोड जनरेशन के लिए fx यूटिलिटी इंस्टॉल करने की भी सलाह दी जाती है (वैकल्पिक):

go install go.uber.org/fx/cmd/fx@latest

कोड उदाहरण के साथ त्वरित शुरुआत

HTTP सर्वर बनाने के लिए fx का एक सरल उदाहरण देखें:

package main

import (
    "context"
    "fmt"
    "net/http"
    "go.uber.org/fx"
)

// NewHandler HTTP हैंडलर बनाता है
func NewHandler() http.Handler {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, fx!")
    })
    return mux
}

// NewServer HTTP सर्वर बनाता है
func NewServer(handler http.Handler) *http.Server {
    return &http.Server{
        Addr:    ":8080",
        Handler: handler,
    }
}

// StartServer सर्वर शुरू करता है
func StartServer(lc fx.Lifecycle, server *http.Server) {
    lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error {
            go server.ListenAndServe()
            fmt.Println("Server started on :8080")
            return nil
        },
        OnStop: func(ctx context.Context) error {
            return server.Shutdown(ctx)
        },
    })
}

func main() {
    app := fx.New(
        fx.Provide(NewHandler),
        fx.Provide(NewServer),
        fx.Invoke(StartServer),
    )
    app.Run()
}

यह उदाहरण fx की बुनियादी कार्यप्रणाली दिखाता है:

• fx.Provide — कंस्ट्रक्टर को रजिस्टर करता है
• fx.Invoke — उन फंक्शन को चलाता है जो डिपेंडेंसी का उपयोग करते हैं
• fx.Lifecycle — कम्पोनेंट्स के जीवनचक्र को प्रबंधित करता है

मुख्य मेथड्स/फंक्शन

1. fx.New

क्या करता है: एक नया fx एप्लिकेशन बनाता है जो डिपेंडेंसी को प्रबंधित करता है। यह फ्रेमवर्क का मुख्य एंट्री पॉइंट है।

पैरामीटर:

• options ...Option — एक वेरिएडिक फंक्शन जो एक या अधिक Option टाइप के पैरामीटर लेता है (fx.Provide, fx.Invoke, fx.Module आदि)

कार्यशील कोड उदाहरण:

package main

import (
    "go.uber.org/fx"
)

type Config struct {
    Port int
}

func NewConfig() *Config {
    retur