Go言語でのhttp.HandleFuncを使ったルートとハンドラ設定完全ガイド

Go言語は、そのシンプルさと高いパフォーマンスにより、Webアプリケーション開発で広く使われています。その中でもhttp.HandleFuncは、HTTPサーバーのルート設定やエンドポイント作成を簡単に実現するための強力なツールです。この機能を活用することで、簡単なWebアプリケーションから本格的なAPIサーバーまで、さまざまな用途に対応することが可能です。本記事では、http.HandleFuncの基本的な使い方から、具体的な実装例、応用的な活用方法まで、初心者でもわかりやすく解説します。これを読めば、Go言語を使ったWebアプリケーションの開発に自信を持てるようになるでしょう。

`http.HandleFunc`とは何か

http.HandleFuncは、Go言語標準ライブラリnet/httpに含まれる関数で、HTTPリクエストを処理するエンドポイント（ルート）を設定するために使用されます。この関数は、特定のパス（URLパターン）に対応するハンドラ関数を登録する役割を果たします。

仕組み

http.HandleFuncを利用することで、特定のURLパスにリクエストが送られた際、そのリクエストを処理する関数を呼び出すことができます。このハンドラ関数は、HTTPレスポンスを生成し、クライアントに返す役割を担います。

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
})

主要な引数

パス（パターン）: クライアントがリクエストを送信するURLのパス部分（例: /, /about）。
ハンドラ関数: リクエストを処理し、レスポンスを生成するための関数。http.ResponseWriterと*http.Requestを引数に取ります。

用途

小規模なHTTPサーバーの構築
特定のパスに対するリクエスト処理
RESTful APIのエンドポイント定義

http.HandleFuncを理解することで、効率的にHTTPサーバーのルート設定を行えるようになります。次のセクションでは、具体的なハンドラ関数の構造について解説します。

ハンドラ関数の基本構造

Go言語におけるハンドラ関数は、http.HandleFuncに登録されるリクエスト処理の中心的な役割を果たします。この関数は、クライアントからのHTTPリクエストを受け取り、それに対応するレスポンスを生成します。

基本のシグネチャ

ハンドラ関数は、以下のようなシグネチャを持つ関数です。

func(w http.ResponseWriter, r *http.Request)

http.ResponseWriter
レスポンスを書き込むためのインターフェースです。このインターフェースを使って、HTTPステータスコードやレスポンスボディを指定します。
*http.Request
クライアントから送られてきたリクエストを表します。リクエストヘッダーやURL、ボディの内容を取得できます。

基本例

以下は、簡単なハンドラ関数の例です。

package main

import (
    "fmt"
    "net/http"
)

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

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

このコードでは、http.HandleFuncにhelloHandlerを登録し、HTTPリクエストが/パスに送信されると、Hello, Go!というレスポンスを返します。

ハンドラ関数内での主要処理

レスポンスの書き込み
http.ResponseWriterに対して、WriteまたはFprintlnを使ってレスポンスボディを書き込みます。

   fmt.Fprintln(w, "This is a response")

HTTPステータスコードの設定
デフォルトでは200（OK）が返されますが、WriteHeaderを使ってステータスコードを指定できます。

   w.WriteHeader(http.StatusNotFound)
   fmt.Fprintln(w, "404 Not Found")

リクエストの解析
*http.Requestを使用して、クエリパラメータ、リクエストボディ、ヘッダーなどを解析します。

   fmt.Println("Method:", r.Method)
   fmt.Println("URL Path:", r.URL.Path)

実際のアプリケーションでの利用

ハンドラ関数は、レスポンスを生成するだけでなく、エラーハンドリングやデータベースとのやり取り、リクエストの検証など、より複雑な処理にも対応できます。この柔軟性が、Go言語を使ったWeb開発を強力なものにしています。

次のセクションでは、複数のルートを設定する具体例を紹介します。

ルート設定の具体例

複数のエンドポイントをhttp.HandleFuncで設定することで、HTTPサーバーは異なるURLパスに応じた処理を柔軟に行えます。ここでは、複数ルートの設定方法を実例を交えて解説します。

基本的なルート設定

以下は、複数のルートを設定した例です。

package main

import (
    "fmt"
    "net/http"
)

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

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "About us: We love coding in Go!")
}

func main() {
    http.HandleFunc("/", homeHandler)         // ルートパス
    http.HandleFunc("/about", aboutHandler) // /about パス
    http.ListenAndServe(":8080", nil)        // サーバー起動
}

このコードでは、以下のエンドポイントが提供されます：

/ – homeHandlerが処理します。
/about – aboutHandlerが処理します。

それぞれのルートで異なるレスポンスを返すことで、動的なWebサイトやAPIを構築できます。

動的なルート処理

Go言語では、動的なパス処理も可能です。たとえば、URLパスから動的にデータを抽出するには以下のようにします。

func dynamicHandler(w http.ResponseWriter, r *http.Request) {
    path := r.URL.Path
    fmt.Fprintf(w, "You accessed path: %s", path)
}

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

この例では、すべてのリクエストをdynamicHandlerで処理し、アクセスされたURLパスをレスポンスに表示します。

パスごとに処理を分岐する方法

単一のハンドラ関数内で複数のパスを処理することもできます。

func routerHandler(w http.ResponseWriter, r *http.Request) {
    switch r.URL.Path {
    case "/":
        fmt.Fprintln(w, "Welcome to the Home Page!")
    case "/about":
        fmt.Fprintln(w, "This is the About Page.")
    default:
        http.NotFound(w, r)
    }
}

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

この方法は、小規模なアプリケーションで有効ですが、パスが増えると可読性が低下するため注意が必要です。

ベストプラクティス

複数のルートを設定する場合は、コードの整理が重要です。以下のようにルートとハンドラを別々のファイルやパッケージに分けることで、可読性とメンテナンス性が向上します。

package main

import (
    "net/http"
    "myapp/handlers"
)

func main() {
    http.HandleFunc("/", handlers.HomeHandler)
    http.HandleFunc("/about", handlers.AboutHandler)
    http.ListenAndServe(":8080", nil)
}

次のセクションでは、クエリパラメータの処理方法について詳しく説明します。

クエリパラメータの処理方法

HTTPリクエストのURLには、クエリパラメータと呼ばれる追加情報を付加することができます。Go言語のhttp.Requestを使用すれば、これらのクエリパラメータを簡単に取得して処理できます。

クエリパラメータの基本

クエリパラメータは、URLの「?」以降に「キー=値」の形式で記述されます。複数のパラメータは「&」で区切られます。

例:

http://example.com/search?query=golang&page=2

query の値は golang
page の値は 2

クエリパラメータの取得

Goでは、http.RequestのURL.Queryメソッドを使ってクエリパラメータを取得します。

package main

import (
    "fmt"
    "net/http"
)

func searchHandler(w http.ResponseWriter, r *http.Request) {
    // クエリパラメータを取得
    queryParams := r.URL.Query()

    // 特定のキーの値を取得
    query := queryParams.Get("query")
    page := queryParams.Get("page")

    fmt.Fprintf(w, "Search Query: %s, Page: %s", query, page)
}

func main() {
    http.HandleFunc("/search", searchHandler)
    http.ListenAndServe(":8080", nil)
}

このコードでは、/search?query=golang&page=2 のリクエストを受けると、以下のレスポンスを返します。

Search Query: golang, Page: 2

クエリパラメータの検証

クエリパラメータが存在しない場合や不正な値が渡された場合は、適切なエラーハンドリングが必要です。

func searchHandler(w http.ResponseWriter, r *http.Request) {
    queryParams := r.URL.Query()

    // 必須パラメータの存在チェック
    query := queryParams.Get("query")
    if query == "" {
        http.Error(w, "query parameter is required", http.StatusBadRequest)
        return
    }

    // オプションパラメータのデフォルト値設定
    page := queryParams.Get("page")
    if page == "" {
        page = "1" // デフォルト値
    }

    fmt.Fprintf(w, "Search Query: %s, Page: %s", query, page)
}

複数値の取得

同じキーで複数の値がある場合は、Queryメソッドでスライスとして取得できます。

func filterHandler(w http.ResponseWriter, r *http.Request) {
    queryParams := r.URL.Query()

    // 複数値の取得
    categories := queryParams["category"]
    fmt.Fprintf(w, "Categories: %v", categories)
}

func main() {
    http.HandleFunc("/filter", filterHandler)
    http.ListenAndServe(":8080", nil)
}

リクエスト:

/filter?category=tech&category=science

レスポンス:

Categories: [tech science]

実際の利用例

クエリパラメータは、検索機能やフィルタリング、ページングなどの用途で活用されます。また、複数の値を受け取って、動的なレスポンスを生成する際にも便利です。

次のセクションでは、POSTリクエストのデータ取得方法について説明します。

POSTリクエストのデータ取得

Go言語を使ってPOSTリクエストを処理する際、フォームデータやJSONデータなど、リクエストボディに含まれるデータを取得して処理することが可能です。このセクションでは、基本的な取得方法と具体例を解説します。

POSTリクエストの基本

POSTリクエストは、HTTPリクエストの一種で、主にサーバーにデータを送信する際に使用されます。データはリクエストボディに含まれ、http.Requestオブジェクトを通じてアクセスできます。

フォームデータの取得

HTMLフォームから送信されたデータは、ParseFormメソッドを使用して解析できます。

package main

import (
    "fmt"
    "net/http"
)

func formHandler(w http.ResponseWriter, r *http.Request) {
    // POSTメソッド以外を拒否
    if r.Method != http.MethodPost {
        http.Error(w, "Only POST method is supported", http.StatusMethodNotAllowed)
        return
    }

    // フォームデータを解析
    if err := r.ParseForm(); err != nil {
        http.Error(w, "Error parsing form data", http.StatusBadRequest)
        return
    }

    // フォームの値を取得
    name := r.FormValue("name")
    email := r.FormValue("email")

    fmt.Fprintf(w, "Name: %s, Email: %s", name, email)
}

func main() {
    http.HandleFunc("/submit", formHandler)
    http.ListenAndServe(":8080", nil)
}

HTMLフォーム例:

<form action="/submit" method="post">
    <input type="text" name="name" placeholder="Your Name">
    <input type="email" name="email" placeholder="Your Email">
    <button type="submit">Submit</button>
</form>

リクエストを送信すると、サーバーはフォームデータを受け取り、レスポンスを返します。

JSONデータの取得

JSONデータを処理するには、encoding/jsonパッケージを使用します。

package main

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

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

func jsonHandler(w http.ResponseWriter, r *http.Request) {
    // POSTメソッド以外を拒否
    if r.Method != http.MethodPost {
        http.Error(w, "Only POST method is supported", http.StatusMethodNotAllowed)
        return
    }

    // リクエストボディを解析
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "Invalid JSON data", http.StatusBadRequest)
        return
    }

    fmt.Fprintf(w, "Name: %s, Email: %s", user.Name, user.Email)
}

func main() {
    http.HandleFunc("/json", jsonHandler)
    http.ListenAndServe(":8080", nil)
}

JSONリクエスト例:

POST /json
Content-Type: application/json

{
    "name": "John Doe",
    "email": "john.doe@example.com"
}

レスポンス:

Name: John Doe, Email: john.doe@example.com

エラーハンドリングの重要性

POSTリクエストの処理では、以下のエラーに対応する必要があります：

メソッドの誤り (MethodNotAllowed)
データ形式の誤り (BadRequest)
必須フィールドの欠如

適切なエラーハンドリングを行うことで、堅牢なサーバーを構築できます。

応用例: ファイルのアップロード

POSTリクエストを使用してファイルをアップロードする方法もよく使用されます。この手法を利用することで、ユーザーの操作性を高めるアプリケーションが構築可能です。

次のセクションでは、ルートやハンドラの整理方法について解説します。

ルートやハンドラの整理方法

複雑なWebアプリケーションでは、ルートやハンドラを整理し、コードを分かりやすく保つことが重要です。このセクションでは、ルートやハンドラの整理方法についてベストプラクティスを紹介します。

ルートとハンドラの分離

全てのルート設定とハンドラを1つのファイルに記述すると、コードが肥大化し可読性が低下します。これを防ぐために、ルート設定とハンドラ関数を分離しましょう。

// main.go
package main

import (
    "net/http"
    "myapp/handlers"
)

func main() {
    // ルート設定
    http.HandleFunc("/", handlers.HomeHandler)
    http.HandleFunc("/about", handlers.AboutHandler)
    http.ListenAndServe(":8080", nil)
}

ハンドラを別のパッケージに定義します。

// handlers/handlers.go
package handlers

import (
    "fmt"
    "net/http"
)

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

func AboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "About us: We love coding in Go!")
}

この構造により、各ファイルの役割が明確になり、コードの保守性が向上します。

ハンドラを構造体にまとめる

構造体を利用すると、関連するデータや依存関係をまとめて管理できます。

package handlers

import (
    "fmt"
    "net/http"
)

type AppHandler struct {
    AppName string
}

func (h *AppHandler) HomeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to %s Home Page!", h.AppName)
}

func (h *AppHandler) AboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "About %s: Go is awesome!", h.AppName)
}

メインプログラムで構造体を初期化して使用します。

package main

import (
    "net/http"
    "myapp/handlers"
)

func main() {
    handler := &handlers.AppHandler{AppName: "MyGoApp"}

    http.HandleFunc("/", handler.HomeHandler)
    http.HandleFunc("/about", handler.AboutHandler)
    http.ListenAndServe(":8080", nil)
}

ルーティングライブラリの利用

Go標準のhttp.HandleFuncはシンプルですが、大規模なプロジェクトでは柔軟なルーティングが必要になる場合があります。その際には、gorilla/muxのようなサードパーティライブラリを使用すると便利です。

インストール:

go get -u github.com/gorilla/mux

使用例:

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

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

func UserHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID := vars["id"]
    fmt.Fprintf(w, "User ID: %s", userID)
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler).Methods("GET")
    r.HandleFunc("/user/{id}", UserHandler).Methods("GET")

    http.ListenAndServe(":8080", r)
}

このコードでは、/user/{id}のような動的パスも簡単に設定できます。

ベストプラクティス

役割ごとにファイルやパッケージを分割する

ルート定義、ハンドラ、ユーティリティ関数などを分ける。

構造体やインターフェースを活用する

アプリケーション全体で共有されるデータや設定を構造体で管理する。

ルーティングライブラリを導入する

柔軟なルーティングが必要な場合に検討する。

次のセクションでは、JSONレスポンスを生成する応用例について説明します。

応用例: JSONレスポンスの生成

Web APIの開発では、クライアントにJSON形式でデータを返すことが一般的です。Go言語では、標準ライブラリのencoding/jsonを使用して簡単にJSONレスポンスを生成できます。このセクションでは、JSONレスポンスを生成する方法とその応用例を紹介します。

JSONレスポンスの基本

JSONレスポンスを生成するには、データ構造を定義し、それをJSON形式にエンコードしてクライアントに送信します。

package main

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

type Response struct {
    Message string `json:"message"`
    Success bool   `json:"success"`
}

func jsonHandler(w http.ResponseWriter, r *http.Request) {
    response := Response{
        Message: "Operation completed successfully",
        Success: true,
    }

    // ヘッダーを設定してJSONを返す
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

func main() {
    http.HandleFunc("/json", jsonHandler)
    http.ListenAndServe(":8080", nil)
}

リクエストを/jsonに送信すると、以下のレスポンスが返されます。

{
    "message": "Operation completed successfully",
    "success": true
}

動的なJSONレスポンス

クライアントからの入力を基に動的なJSONレスポンスを生成する例です。

func dynamicJsonHandler(w http.ResponseWriter, r *http.Request) {
    query := r.URL.Query().Get("query")
    if query == "" {
        query = "default"
    }

    response := map[string]string{
        "query":   query,
        "message": "Here is your result",
    }

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

func main() {
    http.HandleFunc("/search", dynamicJsonHandler)
    http.ListenAndServe(":8080", nil)
}

リクエスト例:

/search?query=golang

レスポンス:

{
    "query": "golang",
    "message": "Here is your result"
}

JSON配列のレスポンス

JSON配列を返すことで、複数のデータを一度にクライアントに送信することができます。

func arrayJsonHandler(w http.ResponseWriter, r *http.Request) {
    users := []map[string]string{
        {"id": "1", "name": "Alice"},
        {"id": "2", "name": "Bob"},
    }

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

func main() {
    http.HandleFunc("/users", arrayJsonHandler)
    http.ListenAndServe(":8080", nil)
}

レスポンス:

[
    {"id": "1", "name": "Alice"},
    {"id": "2", "name": "Bob"}
]

エラーハンドリング付きのJSONレスポンス

クライアントエラーやサーバーエラーの場合、適切なHTTPステータスコードとエラーメッセージを含むJSONを返すことが重要です。

func errorHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusBadRequest)

    response := map[string]string{
        "error":   "Invalid request",
        "message": "Please check your input parameters",
    }

    json.NewEncoder(w).Encode(response)
}

レスポンス:
HTTPステータス: 400

{
    "error": "Invalid request",
    "message": "Please check your input parameters"
}

応用例: RESTful APIの構築

以下の例は、簡単なRESTful APIでCRUD操作を実装する例です。

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

var items = []Item{
    {ID: 1, Name: "Item 1"},
    {ID: 2, Name: "Item 2"},
}

func listItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

func main() {
    http.HandleFunc("/items", listItems)
    http.ListenAndServe(":8080", nil)
}

リクエスト:

GET /items

レスポンス:

[
    {"id": 1, "name": "Item 1"},
    {"id": 2, "name": "Item 2"}
]

次のセクションでは、実践演習として簡易Web APIの構築方法を紹介します。

実践演習: 簡易Web APIの構築

これまで解説してきたhttp.HandleFuncの基本や応用例を活用し、簡単なWeb APIを構築してみましょう。この演習では、シンプルなタスク管理APIを作成します。以下のステップを順に実装していきます。

APIの仕様

GET /tasks: すべてのタスクを取得
POST /tasks: 新しいタスクを追加
DELETE /tasks/{id}: 特定のタスクを削除

タスクはIDとタイトルを持つシンプルな構造体とします。

1. データ構造の定義

タスクデータを管理するための構造体と、タスクリストを定義します。

package main

type Task struct {
    ID    int    `json:"id"`
    Title string `json:"title"`
}

var tasks = []Task{
    {ID: 1, Title: "Learn Go"},
    {ID: 2, Title: "Build a Web API"},
}

2. GET /tasks の実装

すべてのタスクを取得するエンドポイントを実装します。

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

func getTasksHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(tasks)
}

3. POST /tasks の実装

新しいタスクを追加するエンドポイントを実装します。

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

    var newTask Task
    if err := json.NewDecoder(r.Body).Decode(&newTask); err != nil {
        http.Error(w, "Invalid input", http.StatusBadRequest)
        return
    }

    // 新しいIDを割り当て
    newTask.ID = len(tasks) + 1
    tasks = append(tasks, newTask)

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(newTask)
}

4. DELETE /tasks/{id} の実装

特定のタスクを削除するエンドポイントを実装します。

import (
    "github.com/gorilla/mux"
    "strconv"
)

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

    for i, task := range tasks {
        if task.ID == id {
            tasks = append(tasks[:i], tasks[i+1:]...)
            w.WriteHeader(http.StatusNoContent)
            return
        }
    }

    http.Error(w, "Task not found", http.StatusNotFound)
}

5. ルーティングの設定

gorilla/muxライブラリを使用して、エンドポイントを設定します。

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

    r.HandleFunc("/tasks", getTasksHandler).Methods("GET")
    r.HandleFunc("/tasks", createTaskHandler).Methods("POST")
    r.HandleFunc("/tasks/{id}", deleteTaskHandler).Methods("DELETE")

    http.ListenAndServe(":8080", r)
}

テスト

以下のツールを使ってAPIをテストします：

curl（コマンドラインツール）
Postman（APIテスト用GUIツール）

例:

すべてのタスクを取得:

  curl http://localhost:8080/tasks

新しいタスクを追加:

  curl -X POST -H "Content-Type: application/json" -d '{"title": "New Task"}' http://localhost:8080/tasks

特定のタスクを削除:

  curl -X DELETE http://localhost:8080/tasks/1

まとめ

この簡易Web APIは、基本的なCRUD操作を実装する練習として最適です。必要に応じて、認証機能やデータベースとの連携を追加することで、より本格的なAPIを構築できます。

次のセクションでは、これまでの内容を総括します。

まとめ

本記事では、Go言語を用いたhttp.HandleFuncによるルートとハンドラの設定について解説しました。http.HandleFuncの基本的な使用方法から、クエリパラメータの処理、POSTリクエストのデータ取得、JSONレスポンスの生成、そして簡易Web APIの構築まで、幅広い実例を通じてWeb開発の基礎を学びました。

特に、コードを整理する方法や応用例を活用することで、実用的でメンテナンス性の高いWebアプリケーションを構築できる力が身についたはずです。これらの知識を活かし、Go言語で効率的なWeb開発を実現してください。

Go言語でのhttp.HandleFuncを使ったルートとハンドラ設定完全ガイド

`http.HandleFunc`とは何か

仕組み

主要な引数

用途

ハンドラ関数の基本構造

基本のシグネチャ

基本例

ハンドラ関数内での主要処理

実際のアプリケーションでの利用

ルート設定の具体例

基本的なルート設定

動的なルート処理

パスごとに処理を分岐する方法

ベストプラクティス

クエリパラメータの処理方法

クエリパラメータの基本

クエリパラメータの取得

クエリパラメータの検証

複数値の取得

実際の利用例

POSTリクエストのデータ取得

POSTリクエストの基本

フォームデータの取得

JSONデータの取得

エラーハンドリングの重要性

応用例: ファイルのアップロード

ルートやハンドラの整理方法

ルートとハンドラの分離

ハンドラを構造体にまとめる

ルーティングライブラリの利用

ベストプラクティス

応用例: JSONレスポンスの生成

JSONレスポンスの基本

動的なJSONレスポンス

JSON配列のレスポンス

エラーハンドリング付きのJSONレスポンス

応用例: RESTful APIの構築

実践演習: 簡易Web APIの構築

APIの仕様

1. データ構造の定義

2. GET /tasks の実装

3. POST /tasks の実装

4. DELETE /tasks/{id} の実装

5. ルーティングの設定

テスト

まとめ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル