باعتباري أحد مطوري Go، وجدت أن المكتبة القياسية توفر مجموعة رائعة من الأدوات لبناء واجهات برمجة تطبيقات قوية. دعونا نستكشف كيف يمكننا الاستفادة من هذه الحزم المضمنة لإنشاء خدمات ويب فعالة وقابلة للتطوير.

تشكل حزمة net/http أساس تطوير واجهة برمجة التطبيقات لدينا. فهو يوفر واجهة بسيطة لكنها قوية للتعامل مع طلبات واستجابات HTTP. إليك كيفية إعداد خادم أساسي:

package main

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

func main() {
    http.HandleFunc("/", handleRoot)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleRoot(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to our API!")
}

يؤدي هذا إلى إعداد خادم يستمع على المنفذ 8080 ويستجيب للطلبات في المسار الجذر. ولكن دعونا نجعل الأمر أكثر إثارة للاهتمام من خلال إضافة نقطة نهاية RESTful للمستخدمين:

func main() {
    http.HandleFunc("/api/users", handleUsers)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleUsers(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        getUsers(w, r)
    case "POST":
        createUser(w, r)
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

func getUsers(w http.ResponseWriter, r *http.Request) {
    // Fetch users from database and return them
}

func createUser(w http.ResponseWriter, r *http.Request) {
    // Create a new user in the database
}

لدينا الآن واجهة برمجة تطبيقات أكثر تنظيماً يمكنها التعامل مع طرق HTTP المختلفة لنفس نقطة النهاية. ولكن كيف نعمل مع بيانات JSON؟ أدخل حزمة الترميز/json.

تتيح لنا حزمة التشفير/json تنظيم بنيات Go بسهولة في JSON وإلغاء تنظيم JSON في بنيات Go. إليك كيفية استخدامه في واجهة برمجة التطبيقات (API) الخاصة بنا:

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func getUsers(w http.ResponseWriter, r *http.Request) {
    users := []User{
        {ID: 1, Name: "Alice"},
        {ID: 2, Name: "Bob"},
    }

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

func createUser(w http.ResponseWriter, r *http.Request) {
    var newUser User
    err := json.NewDecoder(r.Body).Decode(&newUser)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    // Save newUser to database
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(newUser)
}

يوضح هذا الرمز كيفية إرسال استجابات JSON وتحليل طلبات JSON. يقوم سطر json.NewEncoder(w).Encode(users) بإجراء تسلسل لشريحة المستخدمين لدينا في JSON ويكتبها في الاستجابة. من ناحية أخرى، json.NewDecoder(r.Body).Decode(&newUser) يقرأ JSON من نص الطلب ويملأ بنية المستخدم الجديد.

مع نمو واجهة برمجة التطبيقات (API) الخاصة بنا، قد نرغب في إضافة بعض البرامج الوسيطة لمهام مثل التسجيل أو المصادقة. تجعل حزمة http الخاصة بـ Go هذا الأمر واضحًا:

func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Request: %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    }
}

func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "secret-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    }
}

func main() {
    http.HandleFunc("/api/users", authMiddleware(loggingMiddleware(handleUsers)))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

لقد أنشأنا هنا وظيفتين للبرامج الوسيطة: واحدة للتسجيل والأخرى للمصادقة البسيطة المستندة إلى الرمز المميز. يمكننا ربط وظائف البرامج الوسيطة هذه لتطبيق طبقات متعددة من المعالجة على طلباتنا.

هناك جانب آخر مهم لتطوير واجهة برمجة التطبيقات (API) وهو معالجة الأخطاء بشكل صحيح. تشجع فلسفة التعامل مع الأخطاء في Go على التحقق الصريح من الأخطاء، مما يؤدي إلى تعليمات برمجية أكثر قوة. دعونا نعزز وظيفة createUser الخاصة بنا من خلال معالجة أفضل للأخطاء:

func createUser(w http.ResponseWriter, r *http.Request) {
    var newUser User
    err := json.NewDecoder(r.Body).Decode(&newUser)
    if err != nil {
        http.Error(w, "Invalid request payload", http.StatusBadRequest)
        return
    }

    if newUser.Name == "" {
        http.Error(w, "Name is required", http.StatusBadRequest)
        return
    }

    // Simulate database error
    if newUser.ID == 999 {
        http.Error(w, "Database error", http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(newUser)
}

يقوم هذا الإصدار بالتحقق من حالات الخطأ المختلفة ويعيد رموز حالة HTTP ورسائل الخطأ المناسبة.

مع نمو واجهة برمجة التطبيقات لدينا، قد نحتاج إلى التعامل مع سيناريوهات أكثر تعقيدًا، مثل الطلبات طويلة الأمد أو الحاجة إلى إلغاء العمليات. هذا هو المكان الذي تكون فيه حزمة السياق مفيدة. فهو يسمح لنا بتحمل القيم المحددة حسب الطلب، والتعامل مع المهلات، وإدارة عمليات الإلغاء.

إليك كيفية استخدام السياق في واجهة برمجة التطبيقات الخاصة بنا:

func handleLongRunningTask(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
    defer cancel()

    result := make(chan string, 1)
    go func() {
        // Simulate a long-running task
        time.Sleep(6 * time.Second)
        result 



في هذا المثال، قمنا بتعيين مهلة قدرها 5 ثوانٍ للطلب. إذا لم تكتمل المهمة طويلة الأمد خلال هذا الوقت، فسنعيد خطأ المهلة إلى العميل.

يعد الأداء مصدر قلق بالغ لأي واجهة برمجة تطبيقات. توفر مكتبة Go القياسية العديد من الأدوات لمساعدتنا في تحسين أداء واجهة برمجة التطبيقات (API) الخاصة بنا. على سبيل المثال، يمكننا استخدام sync.Pool لإعادة استخدام الكائنات وتقليل الحمل على أداة تجميع البيانات المهملة:



var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buf)
    buf.Reset()

    // Use buf for some operation
    json.NewEncoder(buf).Encode(someData)
    w.Write(buf.Bytes())
}




يعيد هذا الرمز استخدام المخازن المؤقتة للبايت، والتي يمكن أن تقلل بشكل كبير من تخصيصات الذاكرة في سيناريوهات حركة المرور العالية.

أحد الاعتبارات الأخرى المتعلقة بالأداء هو التوجيه الفعال. على الرغم من أن http.ServeMux القياسي كافٍ لواجهات برمجة التطبيقات البسيطة، إلا أنه بالنسبة لاحتياجات التوجيه الأكثر تعقيدًا، قد نرغب في تنفيذ جهاز توجيه مخصص:



type router struct {
    handlers map[string]http.HandlerFunc
}

func newRouter() *router {
    return &router{
        handlers: make(map[string]http.HandlerFunc),
    }
}

func (r *router) HandleFunc(pattern string, handler http.HandlerFunc) {
    r.handlers[pattern] = handler
}

func (r *router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    for pattern, handler := range r.handlers {
        if matched, _ := path.Match(pattern, req.URL.Path); matched {
            handler(w, req)
            return
        }
    }
    http.NotFound(w, req)
}

func main() {
    r := newRouter()
    r.HandleFunc("/api/users", handleUsers)
    r.HandleFunc("/api/posts/*", handlePosts)
    log.Fatal(http.ListenAndServe(":8080", r))
}




يسمح هذا الموجه المخصص بمطابقة مسار أكثر مرونة، بما في ذلك أنماط أحرف البدل.

مع نمو واجهة برمجة التطبيقات لدينا، قد نحتاج إلى التعامل مع الطلبات المتزامنة بكفاءة. تُعد إجراءات Gooutines وقنواتها مثالية لهذا:



func handleConcurrentRequests(w http.ResponseWriter, r *http.Request) {
    results := make(chan string, 3)

    go func() { results 



يجلب هذا الكود البيانات من ثلاث خدمات بشكل متزامن، ويجمع النتائج في استجابة واحدة.

 يعد الأمان أمرًا بالغ الأهمية في تطوير واجهة برمجة التطبيقات. توفر حزمة التشفير الخاصة بـ Go أدوات للتجزئة والتشفير والمزيد. فيما يلي مثال لكيفية تجزئة كلمة المرور:



import "golang.org/x/crypto/bcrypt"

func hashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
    return string(bytes), err
}

func checkPasswordHash(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}




يمكن استخدام هذه الوظائف لتخزين كلمات مرور المستخدم والتحقق منها بشكل آمن.

 يعد الاختبار جزءًا لا يتجزأ من تطوير واجهة برمجة التطبيقات (API)، وتسهل حزمة اختبار Go كتابة الاختبارات وتشغيلها. فيما يلي مثال لكيفية اختبار وظيفة HandleUsers الخاصة بنا:



func TestHandleUsers(t *testing.T) {
    req, err := http.NewRequest("GET", "/api/users", nil)
    if err != nil {
        t.Fatal(err)
    }

    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(handleUsers)

    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }

    expected := `[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]`
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}




يقوم هذا الاختبار بإنشاء طلب، وتمريره إلى معالجنا، والتحقق من حالة الاستجابة والنص.

 في الختام، توفر مكتبة Go القياسية مجموعة قوية من الأدوات لبناء واجهات برمجة تطبيقات فعالة وقابلة للتطوير. بدءًا من التعامل مع طلبات HTTP والعمل مع JSON وحتى إدارة التزامن وتنفيذ الإجراءات الأمنية، تغطينا المكتبة القياسية. ومن خلال الاستفادة من هذه الحزم المضمنة بشكل فعال، يمكننا إنشاء واجهات برمجة تطبيقات قوية دون الاعتماد على أطر عمل خارجية. وهذا لا يبسط إدارة التبعية لدينا فحسب، بل يضمن أيضًا أن تظل التعليمات البرمجية الخاصة بنا عالية الأداء وقابلة للصيانة أثناء نموها. وبينما نواصل استكشاف أعماق مكتبة Go القياسية، سنكتشف المزيد من الطرق لتحسين عملية تطوير واجهة برمجة التطبيقات لدينا.





  
  
  إبداعاتنا


تأكد من الاطلاع على إبداعاتنا:

المستثمر المركزي | المستثمر المركزي الإسباني | المستثمر الألماني المركزي | الحياة الذكية | العصور والأصداء | ألغاز محيرة | الهندوتفا | النخبة ديف | مدارس JS





  
  
  نحن في المتوسط


رؤى تقنية كوالا | عالم العصور والأصداء | وسط المستثمر المركزي |  وسط الألغاز المحيرة | وسط العلوم والعصور |  الهندوتفا الحديثة