Go言語のインターフェースを活用したHTTPハンドラー構築法と実践解説

package main

import (
    "fmt"
    "net/http"
)

// MyHandlerは、http.Handlerインターフェースを実装する
type MyHandler struct{}

// ServeHTTPメソッドを定義し、リクエストに応じてレスポンスを返す
func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, this is a response from MyHandler!")
}

func main() {
    // インターフェースに基づくハンドラーをHTTPサーバーに設定
    handler := &MyHandler{}
    http.Handle("/", handler)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "net/http"
)

// HelloHandlerは"/hello"パスに対応するハンドラー
type HelloHandler struct{}

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

// GoodbyeHandlerは"/goodbye"パスに対応するハンドラー
type GoodbyeHandler struct{}

func (g *GoodbyeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Goodbye, see you again!")
}

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

    // 各パスにハンドラーを設定
    mux.Handle("/hello", &HelloHandler{})
    mux.Handle("/goodbye", &GoodbyeHandler{})

    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

package main

import (
    "fmt"
    "net/http"
)

// Greeterインターフェースを定義し、異なる挨拶を生成
type Greeter interface {
    Greet() string
}

// HelloGreeterは、"Hello, World!"を返す実装
type HelloGreeter struct{}

func (g *HelloGreeter) Greet() string {
    return "Hello, World!"
}

// Handlerは、Greeterインターフェースを使用するHTTPハンドラー
type Handler struct {
    Greeter Greeter
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, h.Greeter.Greet())
}

func main() {
    greeter := &HelloGreeter{}
    handler := &Handler{Greeter: greeter}

    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", handler)
}

// MockGreeterはテスト用のGreeter実装
type MockGreeter struct{}

func (g *MockGreeter) Greet() string {
    return "Mocked Greet Message!"
}

package main

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

// RequestDataはリクエストの検証対象データ構造
type RequestData struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// HandlerWithValidationはリクエストの検証とエラーハンドリングを行うハンドラー
type HandlerWithValidation struct{}

func (h *HandlerWithValidation) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    var data RequestData
    if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
        http.Error(w, "Invalid request payload", http.StatusBadRequest)
        return
    }

    if data.Name == "" || data.Age <= 0 {
        http.Error(w, "Invalid data: Name and Age are required", http.StatusBadRequest)
        return
    }

    fmt.Fprintf(w, "Hello %s, you are %d years old!", data.Name, data.Age)
}

func main() {
    handler := &HandlerWithValidation{}
    http.Handle("/validate", handler)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

package main

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

// Userモデルの定義
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// UserStoreインターフェースの定義
type UserStore interface {
    CreateUser(user User) error
    GetUser(id int) (*User, error)
    UpdateUser(id int, user User) error
    DeleteUser(id int) error
}

// InMemoryUserStoreはUserStoreインターフェースを実装する
type InMemoryUserStore struct {
    data map[int]User
    mu   sync.Mutex
}

func NewInMemoryUserStore() *InMemoryUserStore {
    return &InMemoryUserStore{data: make(map[int]User)}
}

func (store *InMemoryUserStore) CreateUser(user User) error {
    store.mu.Lock()
    defer store.mu.Unlock()
    store.data[user.ID] = user
    return nil
}

func (store *InMemoryUserStore) GetUser(id int) (*User, error) {
    store.mu.Lock()
    defer store.mu.Unlock()
    user, exists := store.data[id]
    if !exists {
        return nil, fmt.Errorf("User not found")
    }
    return &user, nil
}

func (store *InMemoryUserStore) UpdateUser(id int, user User) error {
    store.mu.Lock()
    defer store.mu.Unlock()
    if _, exists := store.data[id]; !exists {
        return fmt.Errorf("User not found")
    }
    store.data[id] = user
    return nil
}

func (store *InMemoryUserStore) DeleteUser(id int) error {
    store.mu.Lock()
    defer store.mu.Unlock()
    delete(store.data, id)
    return nil
}

type UserHandler struct {
    store UserStore
}

func (h *UserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodPost:
        var user User
        if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
            http.Error(w, "Invalid data", http.StatusBadRequest)
            return
        }
        h.store.CreateUser(user)
        fmt.Fprintf(w, "User created: %v", user)

    case http.MethodGet:
        id := 1 // Example ID, replace with ID parsing logic
        user, err := h.store.GetUser(id)
        if err != nil {
            http.Error(w, err.Error(), http.StatusNotFound)
            return
        }
        json.NewEncoder(w).Encode(user)

    case http.MethodPut:
        var user User
        if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
            http.Error(w, "Invalid data", http.StatusBadRequest)
            return
        }
        id := 1 // Example ID, replace with ID parsing logic
        err := h.store.UpdateUser(id, user)
        if err != nil {
            http.Error(w, err.Error(), http.StatusNotFound)
            return
        }
        fmt.Fprintf(w, "User updated: %v", user)

    case http.MethodDelete:
        id := 1 // Example ID, replace with ID parsing logic
        err := h.store.DeleteUser(id)
        if err != nil {
            http.Error(w, err.Error(), http.StatusNotFound)
            return
        }
        fmt.Fprintf(w, "User deleted")

    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

func main() {
    store := NewInMemoryUserStore()
    handler := &UserHandler{store: store}

    http.Handle("/user", handler)
    fmt.Println("Server is running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}