الوسيط

الوسيط — Middleware

الوسيط (Middleware) هو نمط يسمح لك بتنفيذ كود قبل وبعد المعالج الفعلي — مثل التسجيل، المصادقة، ضغط البيانات، وغيرها. في Go، الوسيط هو ببساطة دالة تأخذ http.Handler وتُرجع http.Handler.

مفهوم الوسيط

الفكرة بسيطة: كل طلب يمر عبر سلسلة من الدوال قبل أن يصل للمعالج النهائي:

الطلب → [تسجيل] → [مصادقة] → [CORS] → المعالج → الاستجابة

كتابة وسيط بسيط

main.go

package main

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

// وسيط التسجيل — Logging middleware
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // تنفيذ المعالج التالي — Execute next handler
        next.ServeHTTP(w, r)

        // تسجيل بعد الانتهاء — Log after completion
        duration := time.Since(start)
        fmt.Printf("[%s] %s %s — %v\n",
            time.Now().Format("15:04:05"),
            r.Method,
            r.URL.Path,
            duration,
        )
    })
}

// وسيط الترويسات — Headers middleware
func headersMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-Server", "AzLearn/1.0")
        w.Header().Set("Content-Type", "application/json; charset=utf-8")
        next.ServeHTTP(w, r)
    })
}

// المعالج الفعلي — Actual handler
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, `{"message": "أهلاً!"}`)
}

func main() {
    // سلسلة الوسيط — Middleware chain
    handler := loggingMiddleware(
        headersMiddleware(
            http.HandlerFunc(helloHandler),
        ),
    )

    fmt.Println("سلسلة الوسيط:")
    fmt.Println("الطلب → loggingMiddleware → headersMiddleware → helloHandler")
    fmt.Println("\nهذا هو نمط الوسيط في Go!")

    _ = handler
}

Output:

وسيط المصادقة — Authentication Middleware

main.go

package main

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

// وسيط المصادقة — Auth middleware
func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")

        if token == "" {
            http.Error(w, `{"error": "مطلوب رمز مصادقة"}`, http.StatusUnauthorized)
            return // مهم! لا تكمل — Important! Don't continue
        }

        if !strings.HasPrefix(token, "Bearer ") {
            http.Error(w, `{"error": "تنسيق رمز غير صالح"}`, http.StatusUnauthorized)
            return
        }

        // تحقق من الرمز — Validate token
        actualToken := strings.TrimPrefix(token, "Bearer ")
        if actualToken != "valid-token-123" {
            http.Error(w, `{"error": "رمز منتهي أو غير صالح"}`, http.StatusForbidden)
            return
        }

        // المصادقة ناجحة — Auth successful
        next.ServeHTTP(w, r)
    })
}

func main() {
    // محاكاة فحص المصادقة — Simulate auth check
    tokens := []string{
        "",
        "InvalidFormat",
        "Bearer wrong-token",
        "Bearer valid-token-123",
    }

    for _, token := range tokens {
        if token == "" {
            fmt.Println("❌ بدون رمز → 401 غير مصرح")
        } else if !strings.HasPrefix(token, "Bearer ") {
            fmt.Println("❌ تنسيق خاطئ → 401 غير مصرح")
        } else if strings.TrimPrefix(token, "Bearer ") != "valid-token-123" {
            fmt.Println("❌ رمز خاطئ → 403 ممنوع")
        } else {
            fmt.Println("✅ مصادقة ناجحة → 200")
        }
    }
}

Output:

وسيط CORS

main.go

package main

import (
    "fmt"
    "net/http"
)

// وسيط CORS — CORS middleware
func corsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // ضبط ترويسات CORS — Set CORS headers
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        w.Header().Set("Access-Control-Max-Age", "86400")

        // طلبات OPTIONS (preflight) — Handle preflight
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusNoContent) // 204
            return
        }

        next.ServeHTTP(w, r)
    })
}

func main() {
    fmt.Println("ترويسات CORS:")
    fmt.Println("Access-Control-Allow-Origin: *")
    fmt.Println("Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS")
    fmt.Println("Access-Control-Allow-Headers: Content-Type, Authorization")
    fmt.Println("\nطلب OPTIONS → 204 No Content (بدون جسم)")
    fmt.Println("طلب GET/POST → يكمل للمعالج التالي مع ترويسات CORS")

    _ = corsMiddleware
}

Output:

سلسلة الوسيط — Middleware Chaining

بدلاً من التداخل العميق، يمكنك إنشاء دالة مساعدة:

main.go

package main

import (
    "fmt"
    "net/http"
)

// نوع الوسيط — Middleware type
type Middleware func(http.Handler) http.Handler

// سلسلة الوسيط — Chain middleware
func chain(handler http.Handler, middlewares ...Middleware) http.Handler {
    // تطبيق بالعكس حتى يُنفذ الأول أولاً
    // Apply in reverse so first middleware runs first
    for i := len(middlewares) - 1; i >= 0; i-- {
        handler = middlewares[i](handler)
    }
    return handler
}

// أمثلة وسيط — Example middlewares
func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("  → تسجيل")
        next.ServeHTTP(w, r)
    })
}

func auth(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("  → مصادقة")
        next.ServeHTTP(w, r)
    })
}

func cors(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("  → CORS")
        next.ServeHTTP(w, r)
    })
}

func main() {
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("  → المعالج النهائي")
    })

    // بدلاً من التداخل — Instead of nesting:
    // logging(auth(cors(handler)))

    // استخدم chain — Use chain:
    final := chain(handler, logging, auth, cors)

    fmt.Println("ترتيب التنفيذ:")
    // محاكاة طلب — Simulate request
    final.ServeHTTP(nil, &http.Request{})
}

Output:

وسيط استرداد panic — Recovery Middleware

func recoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("panic: %v", err)
                http.Error(w, "خطأ داخلي", 500)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

هذا الوسيط يمنع انهيار الخادم الكامل عند حدوث panic في أي معالج.

نصائح عملية

رتّب الوسيط بعناية — التسجيل أولاً، ثم CORS، ثم المصادقة
استخدم defer للتنظيف في الوسيط
لا تنسَ return بعد كتابة استجابة خطأ
الوسيط يجب أن يكون خفيفاً — لا تضع منطق أعمال فيه

تحدي — Challenge

package main

import "fmt"

// أكمل دالة processRequest لمحاكاة سلسلة وسيط
func processRequest(hasToken bool) {
    // 1. اطبع "تسجيل → "
    // 2. اطبع "مصادقة → "
    // 3. إذا لم يكن هناك token اطبع "❌ مرفوض" وعد
    // 4. وإلا اطبع "معالج → ✅ مكتمل"
    // اكتب الكود هنا
}

func main() {
    fmt.Print("طلب 1: ")
    processRequest(true)
    fmt.Print("طلب 2: ")
    processRequest(false)
}