Web Development with Go (ওয়েব ডেভেলপমেন্ট)

Go তে Web Development (ওয়েব ডেভেলপমেন্ট)

Go (Golang) একটি শক্তিশালী এবং কার্যকরী প্রোগ্রামিং ভাষা, যা ওয়েব ডেভেলপমেন্টের জন্য খুবই জনপ্রিয় হয়ে উঠেছে। এর দ্রুত পারফরম্যান্স, সিম্পল সিনট্যাক্স এবং বহুমুখী ব্যবহারের কারণে Go ওয়েব অ্যাপ্লিকেশন ডেভেলপমেন্টের জন্য আদর্শ একটি ভাষা। Go-তে ওয়েব ডেভেলপমেন্ট করার জন্য সাধারণত net/http প্যাকেজ ব্যবহার করা হয়, যা HTTP সার্ভার তৈরি, রিকোয়েস্ট হ্যান্ডলিং এবং রেসপন্স প্রদান করতে সহায়তা করে।

এখানে আমরা দেখব কিভাবে Go দিয়ে ওয়েব সার্ভার তৈরি করতে হয়, রিকোয়েস্ট হ্যান্ডলিং করতে হয় এবং কিছু সাধারণ ওয়েব ডেভেলপমেন্ট টপিক নিয়ে আলোচনা করব।

১. Go-তে Web Server তৈরি করা

Go-তে ওয়েব সার্ভার তৈরি করতে net/http প্যাকেজ ব্যবহার করা হয়। এটি খুবই সহজ এবং ডেভেলপারদের দ্রুত একটি ওয়েব সার্ভার চালু করতে সহায়তা করে।

১.১ Simple Web Server

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, world! You requested: %s", r.URL.Path)
}

func main() {
    http.HandleFunc("/", handler)  // রুট পাথের জন্য হ্যান্ডলার সেট করা
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil) // সার্ভার চালু করা
}

এখানে:

• http.HandleFunc("/", handler): এটি রুট পাথ / এর জন্য একটি HTTP হ্যান্ডলার সেট করেছে। যখন আপনি ব্রাউজারে / পাথ থেকে রিকোয়েস্ট পাঠাবেন, তখন handler ফাংশনটি কল হবে।
• http.ListenAndServe(":8080", nil): এটি সার্ভার চালু করে এবং localhost:8080 পোর্টে শুনতে থাকে।

আউটপুট:

Server is running on http://localhost:8080

এখন আপনি http://localhost:8080 এ গিয়ে "Hello, world!" মেসেজ দেখতে পাবেন।

২. HTTP Methods Handling (GET, POST, PUT, DELETE)

Go-তে বিভিন্ন HTTP মেথড যেমন GET, POST, PUT, এবং DELETE হ্যান্ডল করার জন্য http.HandleFunc বা http.Handle ব্যবহার করা হয়।

২.১ GET Request হ্যান্ডলিং

package main

import (
    "fmt"
    "net/http"
)

func handleGet(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "GET method is handled successfully!")
}

func main() {
    http.HandleFunc("/get", handleGet)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

এখানে /get পাথের জন্য GET রিকোয়েস্ট হ্যান্ডল করা হচ্ছে।

আউটপুট:

GET method is handled successfully!

২.২ POST Request হ্যান্ডলিং

package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func handlePost(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPost {
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
            fmt.Println("Error reading body:", err)
            return
        }
        fmt.Fprintf(w, "Received POST request with body: %s", string(body))
    }
}

func main() {
    http.HandleFunc("/post", handlePost)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

এখানে, /post পাথে POST রিকোয়েস্ট হ্যান্ডল করা হচ্ছে এবং রিকোয়েস্টের বডি পড়া হচ্ছে।

আউটপুট:

Received POST request with body: Your data here

২.৩ PUT and DELETE Request হ্যান্ডলিং

PUT এবং DELETE রিকোয়েস্ট হ্যান্ডল করার জন্য একইভাবে http.MethodPut এবং http.MethodDelete চেক করা হয়।

package main

import (
    "fmt"
    "net/http"
)

func handlePut(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPut {
        fmt.Fprintf(w, "PUT method is handled successfully!")
    }
}

func handleDelete(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodDelete {
        fmt.Fprintf(w, "DELETE method is handled successfully!")
    }
}

func main() {
    http.HandleFunc("/put", handlePut)
    http.HandleFunc("/delete", handleDelete)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

এখানে, /put এবং /delete পাথে যথাক্রমে PUT এবং DELETE রিকোয়েস্ট হ্যান্ডল করা হচ্ছে।

৩. JSON Handling in Go

Go-তে JSON ডেটা হ্যান্ডল করার জন্য encoding/json প্যাকেজ ব্যবহার করা হয়। আপনি JSON ডেটা পার্স এবং জেনারেট করতে পারেন।

৩.১ JSON Request Body Handling

ধরা যাক, আপনি একটি POST রিকোয়েস্টে JSON ডেটা গ্রহণ করতে চান। এটি করতে হলে, json.Unmarshal ফাংশন ব্যবহার করা হয়।

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io/ioutil"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func handlePost(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPost {
        var p Person
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
            fmt.Println("Error reading body:", err)
            return
        }

        // JSON ডেটা পার্স করা
        err = json.Unmarshal(body, &p)
        if err != nil {
            fmt.Println("Error parsing JSON:", err)
            return
        }

        fmt.Fprintf(w, "Received name: %s, age: %d", p.Name, p.Age)
    }
}

func main() {
    http.HandleFunc("/post", handlePost)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

এখানে, আমরা Person struct তৈরি করেছি এবং POST রিকোয়েস্টে JSON ডেটা পাঠালে তা পার্স করা হচ্ছে এবং প্রিন্ট করা হচ্ছে।

POST Request Body Example:

{
    "name": "John",
    "age": 30
}

আউটপুট:

Received name: John, age: 30

৩.২ JSON Response

Go তে JSON রেসপন্স প্রদান করার জন্য json.Marshal ব্যবহার করা হয়।

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type Response struct {
    Status  string `json:"status"`
    Message string `json:"message"`
}

func handleGet(w http.ResponseWriter, r *http.Request) {
    response := Response{
        Status:  "success",
        Message: "This is a JSON response",
    }

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

func main() {
    http.HandleFunc("/json", handleGet)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

এখানে, Response struct তৈরি করে এবং JSON রেসপন্স প্রদান করা হয়েছে।

GET Request Example:

GET http://localhost:8080/json

আউটপুট:

{
    "status": "success",
    "message": "This is a JSON response"
}

৪. Middleware in Go

Go তে Middleware হলো একটি ফাংশন যা রিকোয়েস্ট এবং রেসপন্স প্রসেস করার জন্য ব্যবহৃত হয়। সাধারণত এটি লগিং, অথেনটিকেশন, অথবা রিকোয়েস্ট ভ্যালিডেশন এর জন্য ব্যবহৃত হয়।

৪.১ Simple Middleware Example

package main

import (
    "fmt"
    "net/http"
)

// Middleware function to log requests
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request received:", r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    mux := http.NewServeMux()
    mux

.HandleFunc("/", handler)

    // Wrapping the handler with middleware
    http.Handle("/", loggingMiddleware(mux))
    
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

এখানে, loggingMiddleware একটি মডিফাইড হ্যান্ডলার যা প্রতিটি রিকোয়েস্টের জন্য লগিং করে।

সারসংক্ষেপ

• Go-তে Web Development: Go দিয়ে খুব সহজে ওয়েব সার্ভার তৈরি করা যায় এবং HTTP মেথড যেমন GET, POST, PUT, DELETE হ্যান্ডল করা যায়।
• JSON Handling: Go-তে JSON ডেটা হ্যান্ডল করার জন্য encoding/json প্যাকেজ ব্যবহৃত হয়, যার মাধ্যমে JSON পার্স এবং রেসপন্স করা যায়।
• Middleware: Go-তে Middleware ব্যবহার করে আপনি রিকোয়েস্ট প্রসেসিং এ একাধিক কাজ করতে পারেন যেমন লগিং, অথেনটিকেশন ইত্যাদি।

Go-তে Web Development এবং JSON Handling খুবই শক্তিশালী এবং নমনীয়, যা ডেভেলপারদের ওয়েব সার্ভিস, REST API এবং ডেটা এক্সচেঞ্জ সিস্টেম দ্রুত তৈরি করতে সহায়তা করে।

Go-তে HTTP Server তৈরি করা

Go তে HTTP সার্ভার তৈরি করা খুবই সহজ। Go-তে net/http প্যাকেজটি ব্যবহার করে আপনি সহজেই HTTP সার্ভার তৈরি করতে পারেন। এই প্যাকেজটি HTTP সার্ভার এবং ক্লায়েন্ট সম্পর্কিত সমস্ত কার্যকলাপ পরিচালনা করতে ব্যবহৃত হয়।

এই টিউটোরিয়ালে আমরা দেখব কিভাবে Go তে HTTP সার্ভার তৈরি করা যায়, রাউটিং, এবং রিকোয়েস্ট হ্যান্ডলিং করা যায়।

১. Basic HTTP Server

Go তে একটি সিম্পল HTTP সার্ভার তৈরি করতে শুধুমাত্র http.HandleFunc() এবং http.ListenAndServe() ফাংশনগুলো ব্যবহার করা হয়।

১.১ Simple HTTP Server উদাহরণ

package main

import (
    "fmt"
    "net/http"
)

// একটি হ্যান্ডলার ফাংশন যা রিকোয়েস্ট পেলে একটি বার্তা রিটার্ন করবে
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    // রুট পাথে helloHandler ফাংশন সংযুক্ত করা
    http.HandleFunc("/", helloHandler)

    // সার্ভার শুরু করা
    fmt.Println("Starting server at :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

এখানে:

• http.HandleFunc("/", helloHandler): এটি "/" পাথে রিকোয়েস্ট আসলে helloHandler ফাংশনটি চালাবে।
• http.ListenAndServe(":8080", nil): এটি সার্ভার চালু করবে এবং পোর্ট 8080 তে অপেক্ষা করবে।

১.২ HTTP Server চালানো

এই কোডটি চালানোর পরে, আপনার সার্ভার localhost:8080 এ চলবে। আপনি আপনার ব্রাউজারে গিয়ে http://localhost:8080 এ গিয়ে "Hello, World!" বার্তা দেখতে পারবেন।

২. Multiple Routes Handling

Go তে একাধিক রাউট (routes) সেট করা এবং তাদের জন্য ভিন্ন ভিন্ন হ্যান্ডলার ফাংশন ব্যবহার করা খুবই সহজ। আপনি একাধিক http.HandleFunc() ফাংশন ব্যবহার করে বিভিন্ন রাউট হ্যান্ডল করতে পারেন।

২.১ Multiple Routes Example

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the Home Page!")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "This is the About Page.")
}

func contactHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the Contact Page.")
}

func main() {
    // বিভিন্ন রাউটের জন্য হ্যান্ডলার সংযোগ করা
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/about", aboutHandler)
    http.HandleFunc("/contact", contactHandler)

    // সার্ভার চালানো
    fmt.Println("Starting server at :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

এখানে:

• http.HandleFunc("/", homeHandler): / রুটে আসলে homeHandler ফাংশন চলবে।
• http.HandleFunc("/about", aboutHandler): /about রুটে আসলে aboutHandler ফাংশন চলবে।
• http.HandleFunc("/contact", contactHandler): /contact রুটে আসলে contactHandler ফাংশন চলবে।

২.২ Multiple Routes Testing

এখন আপনি localhost:8080, localhost:8080/about, এবং localhost:8080/contact এই URL গুলিতে ব্রাউজ করে বিভিন্ন পৃষ্ঠায় যাওয়ার মাধ্যমে দেখতে পারবেন।

৩. Query Parameters এবং URL Parameters Handling

Go-তে HTTP রিকোয়েস্টের মধ্যে query parameters এবং URL parameters পেতে পারেন। r.URL.Query() দিয়ে আপনি query parameters এবং mux রাউটারের মাধ্যমে URL parameters পেতে পারেন।

৩.১ Query Parameters Example

package main

import (
    "fmt"
    "net/http"
)

func queryHandler(w http.ResponseWriter, r *http.Request) {
    // URL query parameters
    name := r.URL.Query().Get("name")
    age := r.URL.Query().Get("age")

    fmt.Fprintf(w, "Hello, %s! Your age is %s.", name, age)
}

func main() {
    http.HandleFunc("/greet", queryHandler)
    fmt.Println("Starting server at :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

এখানে, /greet?name=John&age=30 URL ব্যবহার করলে এটি Hello, John! Your age is 30. বার্তা রিটার্ন করবে।

৪. Serving Static Files

Go তে সহজে static files (যেমন HTML, CSS, JavaScript, ছবি) সার্ভ করা যায় http.FileServer ফাংশনের মাধ্যমে।

৪.১ Static Files Serving Example

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // Static files serve করার জন্য
    fs := http.FileServer(http.Dir("./static"))
    http.Handle("/static/", http.StripPrefix("/static/", fs))

    fmt.Println("Starting server at :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

এখানে:

• http.FileServer(http.Dir("./static")): এটি ./static ডিরেক্টরিতে থাকা ফাইলগুলি সার্ভ করবে।
• http.StripPrefix("/static/", fs): এটি URL থেকে /static/ প্রিফিক্স সরিয়ে ফাইল সার্ভ করবে।

এখন আপনি localhost:8080/static/filename URL দিয়ে static ফাইল অ্যাক্সেস করতে পারবেন।

৫. Handling POST Requests

Go-তে POST রিকোয়েস্ট হ্যান্ডেল করার জন্য r.Method চেক করা হয়। POST রিকোয়েস্টের বডি পড়ার জন্য r.ParseForm() ব্যবহার করতে হয়।

৫.১ POST Request Example

package main

import (
    "fmt"
    "net/http"
)

func postHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPost {
        // POST ডেটা পড়া
        r.ParseForm()
        name := r.FormValue("name")
        age := r.FormValue("age")

        fmt.Fprintf(w, "Received POST request. Name: %s, Age: %s", name, age)
    } else {
        http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/submit", postHandler)
    fmt.Println("Starting server at :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

এখানে, /submit URL তে POST রিকোয়েস্ট করলে name এবং age ফর্ম ভ্যালু রিসিভ করা হবে।

এটি একটি HTML ফর্মের মাধ্যমে POST রিকোয়েস্ট পাঠাতে হবে:

<form action="/submit" method="post">
    Name: <input type="text" name="name"><br>
    Age: <input type="text" name="age"><br>
    <input type="submit">
</form>

৬. Middleware ব্যবহার

Go তে Middleware ফাংশন ব্যবহার করে আপনি রিকোয়েস্ট বা রেসপন্স প্রক্রিয়ায় ইন্টারসেপ্ট করতে পারেন এবং কিছু অতিরিক্ত কার্যকলাপ সম্পাদন করতে পারেন, যেমন লগিং, অথেনটিকেশন, ইত্যাদি।

৬.১ Middleware Example

package main

import (
    "fmt"
    "net/http"
)

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request URL:", r.URL)
        next.ServeHTTP(w, r)
    })
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    http.Handle("/log", loggingMiddleware(http.DefaultServeMux))

    fmt.Println("Starting server at :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println("Error starting server:", err)
    }
}

এখানে, loggingMiddleware ফাংশন রিকোয়েস্টের URL লগ করছে এবং তারপরে রিকোয়েস্ট প্রক্রিয়া সম্পন্ন করছে।

সারসংক্ষেপ

• HTTP Server: Go-তে HTTP সার্ভ

ার তৈরি করতে net/http প্যাকেজ ব্যবহৃত হয়।

• Routes and Handlers: http.HandleFunc() ব্যবহার করে একাধিক রাউট হ্যান্ডল করা হয়।
• Static File Serving: http.FileServer দিয়ে static ফাইল সার্ভ করা যায়।
• POST Requests: POST রিকোয়েস্ট হ্যান্ডল করার জন্য r.Method এবং r.ParseForm() ব্যবহার করা হয়।
• Middleware: Middleware ফাংশন ব্যবহার করে রিকোয়েস্ট এবং রেসপন্স প্রক্রিয়ায় অতিরিক্ত কার্যকলাপ সম্পাদন করা যায়।

Go তে HTTP সার্ভার তৈরি করার মাধ্যমে আপনি ওয়েব অ্যাপ্লিকেশন বা API তৈরি করতে পারবেন যা বিভিন্ন রাউট, মেথড, এবং ফিচার সমর্থন করবে।

Go-তে Routing এবং Middleware এর ব্যবহার

Go তে routing এবং middleware গুরুত্বপূর্ণ অংশ যা ওয়েব অ্যাপ্লিকেশন তৈরি করার সময় ব্যবহৃত হয়। Routing ওয়েব রিকোয়েস্টগুলিকে নির্দিষ্ট হ্যান্ডলার ফাংশনে পাঠানোর জন্য ব্যবহৃত হয়, এবং Middleware হল ফাংশনগুলির একটি চেইন যা রিকোয়েস্ট প্রক্রিয়াকরণের আগে, পরে বা তার মধ্যে কিছু নির্দিষ্ট কাজ করে।

Go তে net/http প্যাকেজ ব্যবহার করে সাধারণ HTTP সার্ভার তৈরি করা হয় এবং তাতে routing এবং middleware ব্যবহারের জন্য অনেক লাইব্রেরি রয়েছে, যেমন gorilla/mux, gin, echo, ইত্যাদি।

এখানে আমরা Go তে Routing এবং Middleware ব্যবহারের মৌলিক ধারণা আলোচনা করব।

১. Routing (রুটিং)

Routing হল একটি প্রক্রিয়া যা HTTP রিকোয়েস্টের URL পাথ এবং HTTP মেথড (GET, POST, PUT, DELETE) অনুযায়ী সঠিক হ্যান্ডলার ফাংশনে রিকোয়েস্টটি রিডাইরেক্ট করে।

১.১ Go-তে Basic Routing

Go-তে net/http প্যাকেজ ব্যবহার করে সাদামাটা রাউটিং করা যায়। নিচে একটি সহজ উদাহরণ দেওয়া হলো:

package main

import (
    "fmt"
    "net/http"
)

// Handler ফাংশন যা "Hello, World!" প্রিন্ট করবে
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    // রাউটিং করা
    http.HandleFunc("/", helloHandler)

    // সার্ভার শুরু করা
    fmt.Println("Starting server at :8080...")
    http.ListenAndServe(":8080", nil)
}

এখানে:

• http.HandleFunc("/", helloHandler): এই রাউটিংটি URL পাথ / এর জন্য helloHandler ফাংশন কল করবে।
• http.ListenAndServe(":8080", nil): সার্ভার 8080 পোর্টে চলে।

আউটপুট: ব্রাউজারে গিয়ে http://localhost:8080/ এই URL এ গেলে "Hello, World!" বার্তা দেখাবে।

১.২ gorilla/mux প্যাকেজ দিয়ে Routing

গোরিলা মাক্স (Gorilla Mux) একটি জনপ্রিয় এবং শক্তিশালী HTTP রাউটার প্যাকেজ যা URL প্যারামিটার, রুট মেথড, এবং অন্যান্য কনফিগারেশন নিয়ন্ত্রণ করতে সহায়তা করে।

package main

import (
    "fmt"
    "github.com/gorilla/mux"
    "net/http"
)

// Handler ফাংশন যা GET রিকোয়েস্ট গ্রহণ করবে
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", mux.Vars(r)["name"])
}

func main() {
    // রাউটার তৈরি
    r := mux.NewRouter()

    // রাউটিং
    r.HandleFunc("/hello/{name}", helloHandler).Methods("GET")

    // সার্ভার শুরু করা
    fmt.Println("Starting server at :8080...")
    http.ListenAndServe(":8080", r)
}

এখানে:

• mux.NewRouter(): একটি নতুন রাউটার তৈরি করে।
• r.HandleFunc("/hello/{name}", helloHandler).Methods("GET"): /hello/{name} রুটে একটি ডাইনামিক প্যারামিটার {name} ব্যবহার করা হয়েছে।

আউটপুট:
এখন আপনি http://localhost:8080/hello/John এ গিয়ে "Hello, John!" বার্তা দেখতে পারবেন।

২. Middleware (মিডলওয়্যার)

Middleware হল একটি ফাংশন যা HTTP রিকোয়েস্ট আসার আগে বা পরে কাজ করে এবং রিকোয়েস্ট প্রসেসিং চেইনের মধ্যে সন্নিবেশিত হয়। এটি প্রাথমিকভাবে রিকোয়েস্ট ভ্যালিডেশন, অথেন্টিকেশন, লগিং, রিকোয়েস্ট/রেসপন্স মডিফিকেশন ইত্যাদি কাজের জন্য ব্যবহৃত হয়।

২.১ Go-তে Basic Middleware

Go তে সাদামাটা middleware তৈরি করার জন্য, আপনি একটি হ্যান্ডলার ফাংশনকে অন্য ফাংশনের মধ্যে এড করতে পারেন যা রিকোয়েস্টের পূর্বে বা পরে কাজ করে।

package main

import (
    "fmt"
    "net/http"
)

// Middleware Function
func logRequest(handler http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request received:", r.Method, r.URL.Path)
        handler.ServeHTTP(w, r) // মূল হ্যান্ডলার ফাংশন কল
    })
}

// Main Handler Function
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    // রাউটার তৈরি
    http.HandleFunc("/", helloHandler)

    // Middleware যুক্ত করা
    http.Handle("/", logRequest(http.DefaultServeMux))

    // সার্ভার শুরু করা
    fmt.Println("Starting server at :8080...")
    http.ListenAndServe(":8080", nil)
}

এখানে:

• logRequest: এটি একটি middleware ফাংশন যা রিকোয়েস্ট লোগ করে।
• handler.ServeHTTP(w, r): মূল রিকোয়েস্ট হ্যান্ডলার কল করা হয়েছে।

আউটপুট: ব্রাউজারে http://localhost:8080/ URL এ গেলে Request received: GET / বার্তা কনসোলে প্রদর্শিত হবে, এবং তারপর "Hello, World!" বার্তা রেসপন্স হিসেবে প্রদর্শিত হবে।

২.২ Multiple Middleware with gorilla/mux

Gorilla mux দিয়ে আমরা একাধিক middleware যোগ করতে পারি। এখানে একটি উদাহরণ দেখানো হলো, যেখানে লগিং এবং অথেন্টিকেশন middleware একসাথে ব্যবহার করা হয়েছে।

package main

import (
    "fmt"
    "github.com/gorilla/mux"
    "net/http"
)

// Log middleware
func logMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request received:", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

// Authentication middleware
func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("Authorization") == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

// Main handler
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    // New Router
    r := mux.NewRouter()

    // Apply middlewares
    r.HandleFunc("/", helloHandler)
    r.Use(logMiddleware)  // Adding log middleware
    r.Use(authMiddleware) // Adding auth middleware

    // Start server
    fmt.Println("Server is running at http://localhost:8080")
    http.ListenAndServe(":8080", r)
}

এখানে:

• logMiddleware: রিকোয়েস্টের লগ রাখবে।
• authMiddleware: অথেন্টিকেশন চেক করবে এবং যদি অথেন্টিকেশন সফল না হয়, তাহলে Unauthorized রেসপন্স ফেরত পাঠাবে।

আউটপুট:

• যদি Authorization হেডার না থাকে, তাহলে Unauthorized রেসপন্স ফিরে আসবে।
• যদি Authorization হেডার থাকে, তাহলে "Hello, World!" বার্তা ফেরত আসবে।

৩. Middleware এবং Routing চেইনিং

Go তে একটি একাধিক middleware চেইন তৈরি করা সম্ভব, যেখানে প্রতিটি middleware পরবর্তী middleware বা হ্যান্ডলারকে কল করবে। এটি কিছু সাধারণ কাজ যেমন রিকোয়েস্ট লগিং, অথেন্টিকেশন, CORS হ্যান্ডলিং ইত্যাদি করতে ব্যবহৃত হয়।

৩.১ Complex Middleware Example with Multiple Handlers

package main

import (
    "fmt"
    "github.com/gorilla/mux"
    "net/http"
)

// Middleware 1
func logRequest(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request received:", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

// Middleware 2 (Authentication)
func authenticate(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("Authorization") != "Bearer secret-token" {
            http.Error(w, "Forbidden", http.StatusForbidden)
            return
        }
        next.ServeHTTP(w, r)
    })
}

// Final handler
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    r := mux.NewRouter()

    // Applying Middlewares
    r.HandleFunc("/", hello

Handler)
    r.Use(logRequest)       // Apply log middleware
    r.Use(authenticate)     // Apply auth middleware

    fmt.Println("Server running at http://localhost:8080")
    http.ListenAndServe(":8080", r)
}

এখানে:

• logRequest middleware রিকোয়েস্টের লগ রাখবে।
• authenticate middleware অথেন্টিকেশন চেক করবে।
• helloHandler মূল রিকোয়েস্ট হ্যান্ডলার।

সারসংক্ষেপ

• Routing: Go তে রাউটিং http.HandleFunc বা gorilla/mux এর মাধ্যমে করা হয়। এর মাধ্যমে URL পাথের সাথে মেলানো হ্যান্ডলার ফাংশন ডিফাইন করা হয়।
• Middleware: Middleware হল এমন ফাংশন যা রিকোয়েস্ট আসার আগে বা পরে কাজ করে এবং বিভিন্ন কার্যকলাপ যেমন লগিং, অথেন্টিকেশন, রিকোয়েস্ট/রেসপন্স ম্যানিপুলেশন ইত্যাদি পরিচালনা করে।
• Middleware Chaining: Go তে একাধিক middleware চেইন করা যায় যা বিভিন্ন কাজ একসাথে পরিচালনা করতে সাহায্য করে।

Go তে Routing এবং Middleware ব্যবহারের মাধ্যমে আপনি সহজেই কার্যকরী ওয়েব অ্যাপ্লিকেশন তৈরি করতে পারবেন যা রিকোয়েস্ট এবং রেসপন্সকে সঠিকভাবে পরিচালনা এবং প্রসেস করবে।

Go-তে HTML Template Rendering এবং Static Files Serve করা

Go প্রোগ্রামিং ভাষায় HTML template rendering এবং static files serve করা সহজ এবং কার্যকরী। html/template প্যাকেজটি ব্যবহার করে আপনি HTML টেমপ্লেট রেন্ডার করতে পারেন এবং static files (যেমন CSS, JS, ইমেজ) সরবরাহ করতে http প্যাকেজের সাহায্যে সঠিকভাবে হ্যান্ডেল করতে পারেন।

এই টিউটোরিয়ালে, আমরা দেখব কিভাবে HTML Templates রেন্ডার করা হয় এবং কিভাবে Static Files (যেমন CSS, JavaScript) ব্যবহার করা যায় একটি Go অ্যাপ্লিকেশনে।

১. HTML Template Rendering

Go তে HTML template rendering করতে html/template প্যাকেজ ব্যবহার করা হয়। এটি একটি শক্তিশালী টেমপ্লেট ইঞ্জিন যা ডেটা ডাইনামিকভাবে HTML ডকুমেন্টে প্রিন্ট করতে সাহায্য করে।

১.১ HTML Template তৈরি এবং রেন্ডার করা

প্রথমে একটি HTML Template তৈরি করি এবং তারপর তা Go এর মাধ্যমে রেন্ডার করা হবে।

১.১.১ HTML Template ফাইল তৈরি

ধরা যাক, আপনার একটি index.html ফাইল আছে যা ডেটা রেন্ডার করবে:

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.Title}}</title>
</head>
<body>
    <h1>{{.Message}}</h1>
</body>
</html>

এখানে:

• {{.Title}} এবং {{.Message}} হল template variables, যা ডাইনামিকভাবে ডেটার মাধ্যমে পরিবর্তিত হবে।

১.১.২ Go কোডে HTML Template রেন্ডার করা

package main

import (
    "fmt"
    "html/template"
    "net/http"
)

type PageVariables struct {
    Title   string
    Message string
}

func handler(w http.ResponseWriter, r *http.Request) {
    pageVariables := PageVariables{
        Title:   "Go HTML Template",
        Message: "Welcome to Go HTML Template Rendering!",
    }

    // HTML template রেন্ডার করা
    tmpl, err := template.ParseFiles("index.html")
    if err != nil {
        fmt.Println(err)
        return
    }

    // template.Execute() দ্বারা ডেটা রেন্ডার করা
    tmpl.Execute(w, pageVariables)
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Starting server at :8080...")
    http.ListenAndServe(":8080", nil)
}

এখানে:

• template.ParseFiles ফাংশনটি HTML টেমপ্লেট ফাইলটি লোড করে।
• tmpl.Execute ফাংশনটি টেমপ্লেটে ডেটা রেন্ডার করে এবং ক্লায়েন্টকে পাঠায়।

টেস্ট করতে:

1. আপনার Go অ্যাপ্লিকেশন চালান: go run main.go
2. ব্রাউজারে গিয়ে http://localhost:8080 এ যান।
3. আপনি টেমপ্লেটের ডাইনামিক ডেটা দেখতে পাবেন।

২. Static Files Serve করা

Go তে static files (যেমন CSS, JavaScript, ইমেজ) serve করার জন্য http.ServeFile অথবা http.FileServer ব্যবহার করা হয়।

২.১ Static File Serve করা

ধরা যাক, আপনার অ্যাপ্লিকেশনে কিছু CSS এবং JS ফাইল রয়েছে, যা আপনি স্ট্যাটিকভাবে serve করতে চান।

২.১.১ Directory Structure

/myapp
    /static
        /css
            styles.css
        /js
            script.js
    main.go
    index.html

২.১.২ CSS এবং JS ফাইল serve করা

package main

import (
    "fmt"
    "html/template"
    "net/http"
)

type PageVariables struct {
    Title   string
    Message string
}

func handler(w http.ResponseWriter, r *http.Request) {
    pageVariables := PageVariables{
        Title:   "Go HTML Template",
        Message: "Welcome to Go HTML Template Rendering!",
    }

    tmpl, err := template.ParseFiles("index.html")
    if err != nil {
        fmt.Println(err)
        return
    }

    tmpl.Execute(w, pageVariables)
}

func main() {
    // Static files serve করা
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static"))))

    // Template render handler
    http.HandleFunc("/", handler)

    fmt.Println("Starting server at :8080...")
    http.ListenAndServe(":8080", nil)
}

এখানে:

• http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static")))) লাইনে আমরা স্ট্যাটিক ফাইল সার্ভ করার জন্য http.FileServer ব্যবহার করেছি। এটি static ডিরেক্টরি থেকে ফাইল serve করবে এবং ক্লায়েন্টকে পাঠাবে।
• http.StripPrefix দিয়ে আমরা /static/ পাথকে ফাইলের রুট থেকে বাদ দিয়ে ডিরেক্টরির ভিতরের ফাইল serve করেছি।

২.২ Static Files Access

এখন, আপনি যদি styles.css অথবা script.js ফাইলকে serve করতে চান, আপনি ব্রাউজারে গিয়ে:

http://localhost:8080/static/css/styles.css
http://localhost:8080/static/js/script.js

এগুলো অ্যাক্সেস করতে পারবেন।

৩. Combining Template Rendering and Static Files

আপনি HTML টেমপ্লেট রেন্ডার এবং স্ট্যাটিক ফাইল serve একসাথে ব্যবহার করতে পারেন, যাতে টেমপ্লেটের মধ্যে স্ট্যাটিক ফাইল যেমন CSS বা JavaScript লিংক করা যায়।

৩.১ HTML Template with Static Files

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.Title}}</title>
    <link rel="stylesheet" type="text/css" href="/static/css/styles.css">
</head>
<body>
    <h1>{{.Message}}</h1>
    <script src="/static/js/script.js"></script>
</body>
</html>

এখানে, আমরা HTML টেমপ্লেটে স্ট্যাটিক ফাইলের লিঙ্ক যোগ করেছি।

সারসংক্ষেপ

• HTML Template Rendering: Go-তে html/template প্যাকেজ ব্যবহার করে আপনি HTML টেমপ্লেট রেন্ডার করতে পারেন এবং ডাইনামিকভাবে ডেটা প্রদান করতে পারেন।
• Static Files Serve: Go তে http.FileServer এবং http.ServeFile ব্যবহার করে আপনি স্ট্যাটিক ফাইল (যেমন CSS, JS) সার্ভ করতে পারেন।
• Integration: HTML টেমপ্লেট এবং স্ট্যাটিক ফাইল একসাথে কাজ করতে পারে, যেখানে আপনি টেমপ্লেটে স্ট্যাটিক ফাইলের লিঙ্ক যোগ করতে পারেন।

Go-তে HTML Template Rendering এবং Static Files Serve খুবই সহজ এবং কার্যকরী, যা ওয়েব অ্যাপ্লিকেশন তৈরি করার জন্য শক্তিশালী ফিচার।

Go-তে RESTful API Development এবং JSON Handling

Go (Golang) একটি শক্তিশালী এবং দ্রুত ভাষা, যা RESTful API এবং JSON ডেটা হ্যান্ডলিংয়ে ব্যবহৃত হয়। Go-তে RESTful API তৈরি করার জন্য সাধারণত net/http প্যাকেজ ব্যবহার করা হয় এবং JSON ডেটা হ্যান্ডলিং করার জন্য encoding/json প্যাকেজ ব্যবহৃত হয়। এই টিউটোরিয়ালে আমরা দেখব কিভাবে Go তে RESTful API তৈরি করা যায় এবং JSON ডেটা প্রক্রিয়াজাত করা যায়।

১. Go-তে RESTful API তৈরি করা

RESTful API হল একটি ওয়েব সার্ভিস আর্কিটেকচার যা HTTP প্রটোকল ব্যবহার করে এবং এটি বিভিন্ন রিসোর্স (ডেটা) এর সাথে কাজ করে। RESTful API তৈরি করার জন্য Go-তে সাধারণত net/http প্যাকেজ ব্যবহৃত হয়।

১.১ Simple RESTful API তৈরি করা

এখানে একটি খুব সহজ RESTful API তৈরি করা হয়েছে, যা HTTP GET, POST, PUT, এবং DELETE রিকোয়েস্ট প্রসেস করবে।

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "strconv"
)

var data = map[int]string{
    1: "Go Programming",
    2: "RESTful API",
    3: "JSON Handling",
}

// GET Request handler
func getData(w http.ResponseWriter, r *http.Request) {
    // রিকোয়েস্ট থেকে ID বের করা
    id := r.URL.Query().Get("id")
    intID, err := strconv.Atoi(id)
    if err != nil || data[intID] == "" {
        http.Error(w, "Data not found", http.StatusNotFound)
        return
    }

    // JSON ফরম্যাটে রেসপন্স দেওয়া
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "id":   id,
        "data": data[intID],
    })
}

// POST Request handler
func postData(w http.ResponseWriter, r *http.Request) {
    var newData map[string]string
    decoder := json.NewDecoder(r.Body)
    err := decoder.Decode(&newData)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    // নতুন ডেটা প্রসেস করা
    id := len(data) + 1
    data[id] = newData["data"]

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "message": "Data created successfully",
        "id":      id,
    })
}

// PUT Request handler
func putData(w http.ResponseWriter, r *http.Request) {
    var updateData map[string]string
    decoder := json.NewDecoder(r.Body)
    err := decoder.Decode(&updateData)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    id := r.URL.Query().Get("id")
    intID, err := strconv.Atoi(id)
    if err != nil || data[intID] == "" {
        http.Error(w, "Data not found", http.StatusNotFound)
        return
    }

    // ডেটা আপডেট করা
    data[intID] = updateData["data"]

    json.NewEncoder(w).Encode(map[string]string{
        "message": "Data updated successfully",
        "id":      id,
    })
}

// DELETE Request handler
func deleteData(w http.ResponseWriter, r *http.Request) {
    id := r.URL.Query().Get("id")
    intID, err := strconv.Atoi(id)
    if err != nil || data[intID] == "" {
        http.Error(w, "Data not found", http.StatusNotFound)
        return
    }

    delete(data, intID)

    json.NewEncoder(w).Encode(map[string]string{
        "message": "Data deleted successfully",
        "id":      id,
    })
}

func main() {
    http.HandleFunc("/get", getData)     // GET রিকোয়েস্টের জন্য
    http.HandleFunc("/post", postData)   // POST রিকোয়েস্টের জন্য
    http.HandleFunc("/put", putData)     // PUT রিকোয়েস্টের জন্য
    http.HandleFunc("/delete", deleteData) // DELETE রিকোয়েস্টের জন্য

    fmt.Println("Starting server on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil)) // সার্ভার চালু করা
}

এখানে:

• getData: একটি GET রিকোয়েস্ট হ্যান্ডলার যা ডেটার আইডি দিয়ে JSON রেসপন্স পাঠায়।
• postData: একটি POST রিকোয়েস্ট হ্যান্ডলার যা নতুন ডেটা গ্রহণ করে এবং সেটি ডেটাবেস (এখানে data মেমরি ভেরিয়েবল) এ সংরক্ষণ করে।
• putData: একটি PUT রিকোয়েস্ট হ্যান্ডলার যা নির্দিষ্ট ডেটা আইডি আপডেট করে।
• deleteData: একটি DELETE রিকোয়েস্ট হ্যান্ডলার যা নির্দিষ্ট ডেটা আইডি মুছে ফেলে।

আউটপুট:

• GET Request: http://localhost:8080/get?id=1
  • আউটপুট: {"id":"1", "data": "Go Programming"}
• POST Request: http://localhost:8080/post
  • আউটপুট: { "message": "Data created successfully", "id": 4 }
• PUT Request: http://localhost:8080/put?id=1
  • আউটপুট: { "message": "Data updated successfully", "id": 1 }
• DELETE Request: http://localhost:8080/delete?id=1
  • আউটপুট: { "message": "Data deleted successfully", "id": 1 }

৩. Go-তে JSON Handling

Go-তে JSON ডেটা হ্যান্ডলিং সাধারণত encoding/json প্যাকেজ দিয়ে করা হয়। আপনি JSON প্যাকেজ ব্যবহার করে সহজেই JSON ডেটা পড়তে এবং লেখতে পারেন।

৩.১ JSON Parse (JSON ডেটা পার্স করা)

যখন আপনি একটি JSON ডেটা গ্রহণ করেন, তখন আপনি সেটি একটি struct বা map এর মধ্যে রূপান্তর করতে পারেন। নিচে একটি উদাহরণ দেয়া হলো, যেখানে একটি JSON ডেটা কনভার্ট করা হচ্ছে Go struct এর মধ্যে।

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    // JSON ডেটা
    jsonData := `{"name": "Alice", "age": 30}`

    // JSON ডেটাকে struct এ রূপান্তর করা
    var p Person
    err := json.Unmarshal([]byte(jsonData), &p)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println("Name:", p.Name) // আউটপুট: Name: Alice
    fmt.Println("Age:", p.Age)   // আউটপুট: Age: 30
}

এখানে, json.Unmarshal ফাংশন ব্যবহার করে JSON ডেটা Go struct এর মধ্যে রূপান্তর করা হয়েছে।

৩.২ JSON Generate (JSON ডেটা জেনারেট করা)

আপনি যদি Go struct থেকে JSON ডেটা তৈরি করতে চান, তবে json.Marshal ব্যবহার করতে পারেন।

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{"Bob", 25}

    // Go struct থেকে JSON তৈরি করা
    jsonData, err := json.Marshal(p)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(jsonData)) // আউটপুট: {"name":"Bob","age":25}
}

এখানে, json.Marshal ফাংশন ব্যবহার করে Go struct থেকে JSON তৈরি করা হয়েছে।

৩.৩ JSON Pretty Print

আপনি যদি JSON ডেটা প্রিন্ট করতে চান যাতে তা আরও পড়তে সুবিধাজনক হয়, তাহলে json.MarshalIndent ব্যবহার করতে পারেন।

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{"John", 40}

    // JSON Pretty Print
    jsonData, err := json.MarshalIndent(p, "", "  ")
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(jsonData))
}

আউটপুট:

{
  "name": "John",
  "age": 40
}

সারসংক্ষেপ

• Go-তে RESTful API তৈরি করতে net/http প্যাকেজ ব্যবহৃত হয়। এতে GET, POST, PUT, এবং DELETE রিকোয়েস্টের জন্য হ্যান্ডলার তৈরি করা যায়।
• JSON Handling এর জন্য Go-তে **`

encoding/json`** প্যাকেজ ব্যবহৃত হয়, যার মাধ্যমে JSON ডেটা পড়া এবং লেখা সম্ভব হয়।

• json.Unmarshal এবং json.Marshal ফাংশনগুলির মাধ্যমে JSON ডেটা পার্স এবং জেনারেট করা হয়।
• Go-তে JSON Pretty Print এর জন্য json.MarshalIndent ব্যবহার করা হয়।

Go-তে RESTful API এবং JSON Handling খুবই সহজ এবং কার্যকরীভাবে করা যায়, যা ওয়েব সার্ভিস এবং ডেটা এক্সচেঞ্জ প্রক্রিয়াগুলিকে অনেক বেশি নমনীয় এবং দ্রুত করে তোলে।