1. परियोजना संरचना

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

उदाहरण संरचना:

go-rest-api/
|-- main.go
|-- config/
|   |-- config.go
|-- handlers/
|   |-- user.go
|-- models/
|   |-- user.go
|-- routes/
|   |-- routes.go
|-- middlewares/
|   |-- logging.go
|-- utils/
|   |-- helpers.go

2. पर्यावरण विन्यास

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

config/config.go:

package config

import (
    "github.com/spf13/viper"
    "log"
)

type Config struct {
    Port string
    DB   struct {
        Host     string
        Port     string
        User     string
        Password string
        Name     string
    }
}

var AppConfig Config

func LoadConfig() {
    viper.SetConfigName("config")
    viper.AddConfigPath(".")
    viper.AutomaticEnv()

    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("Error reading config file, %s", err)
    }

    err := viper.Unmarshal(&AppConfig)
    if err != nil {
        log.Fatalf("Unable to decode into struct, %v", err)
    }
}

3. त्रुटि प्रबंधन

त्रुटियों को हमेशा उचित तरीके से संभालें। सार्थक त्रुटि संदेश और HTTP स्थिति कोड लौटाएँ।

handlers/user.go:

func GetUserHandler(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, err := strconv.Atoi(params["id"])
    if err != nil {
        http.Error(w, "Invalid user ID", http.StatusBadRequest)
        return
    }

    user, err := findUserByID(id)
    if err != nil {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

4. मिडलवेयर

लॉगिंग, प्रमाणीकरण और अन्य क्रॉस-कटिंग चिंताओं के लिए मिडलवेयर का उपयोग करें।

middlewares/logging.go:

package middlewares

import (
    "log"
    "net/http"
    "time"
)

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %s", r.Method, r.RequestURI, time.Since(start))
    })
}

मुख्य.गो या मार्गों/मार्गों.गो में:

r.Use(middlewares.LoggingMiddleware)

5. JSON हैंडलिंग

उचित JSON एन्कोडिंग और डिकोडिंग का उपयोग करें। यह सुनिश्चित करने के लिए आने वाले JSON डेटा को सत्यापित करें कि यह अपेक्षित संरचना को पूरा करता है।

handlers/user.go:

func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "Invalid input", http.StatusBadRequest)
        return
    }

    // Validate user data...

    users = append(users, user)

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

6. डेटाबेस एक्सेस

अपना डेटा संग्रहीत करने के लिए डेटाबेस का उपयोग करें। कच्चे SQL प्रश्नों के लिए ORM या sqlx के लिए gorm जैसे पैकेज का उपयोग करें।

models/user.go:

package models

import "gorm.io/gorm"

type User struct {
    gorm.Model
    Name  string `json:"name"`
    Email string `json:"email"`
}

main.go:

package main

import (
    "github.com/yourusername/go-rest-api/config"
    "github.com/yourusername/go-rest-api/routes"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "log"
    "net/http"
)

func main() {
    config.LoadConfig()

    dsn := "host="   config.AppConfig.DB.Host  
        " user="   config.AppConfig.DB.User  
        " password="   config.AppConfig.DB.Password  
        " dbname="   config.AppConfig.DB.Name  
        " port="   config.AppConfig.DB.Port  
        " sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatalf("Could not connect to the database: %v", err)
    }

    r := routes.NewRouter(db)

    log.Println("Starting server on port", config.AppConfig.Port)
    log.Fatal(http.ListenAndServe(":" config.AppConfig.Port, r))
}

7. लॉगिंग

बेहतर लॉगिंग के लिए लॉगरस या जैप जैसी संरचित लॉगिंग लाइब्रेरी का उपयोग करें।

middlewares/logging.go:

package middlewares

import (
    "github.com/sirupsen/logrus"
    "net/http"
    "time"
)

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        logrus.WithFields(logrus.Fields{
            "method": r.Method,
            "url":    r.URL.Path,
            "time":   time.Since(start),
        }).Info("handled request")
    })
}

8. सुरक्षा

HTTPS का उपयोग करके, इनपुट को सत्यापित और स्वच्छ करके, और उचित प्रमाणीकरण और प्राधिकरण को लागू करके सुनिश्चित करें कि आपका एपीआई सुरक्षित है।

9. संस्करणीकरण

मौजूदा क्लाइंट को तोड़े बिना परिवर्तनों को संभालने के लिए अपने एपीआई को संस्करणित करें। यह URL में संस्करण शामिल करके किया जा सकता है, जैसे /api/v1/users.

10. दस्तावेज़ीकरण

डेवलपर्स के लिए स्पष्ट उपयोग निर्देश प्रदान करने के लिए स्वैगर या पोस्टमैन जैसे टूल का उपयोग करके अपने एपीआई का दस्तावेजीकरण करें।

इन सर्वोत्तम प्रथाओं का पालन करके, आप गो में एक मजबूत, रखरखाव योग्य और स्केलेबल रेस्टफुल एपीआई बना सकते हैं।