net/httpがあれば、なぜGinが必要なのか？

[![Group141.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/7daa68ed-655a-437a-be71-46a5aa3b4ab8.png)](https://leapcell.io/?lc_t=q_gonet)


**[Leapcell: The Next - Gen Serverless Platform for Golang app Hosting](https://leapcell.io/?lc_t=q_gonet)**

# なぜnet/httpがあるのに、Ginがまだ必要なのか？

## Ⅰ. 序論
Go言語のエコシステムにおいて、net/httpパッケージは、標準のHTTPライブラリとして、強力で柔軟な機能を持っています。これはWebアプリケーションを構築し、HTTPリクエストを処理するために使用することができます。このパッケージはGo言語の標準ライブラリに属するため、すべてのGoプログラムが直接呼び出すことができます。しかし、このように強力で柔軟な標準ライブラリであるnet/httpが既に存在するのに、なぜWebアプリケーションの構築を支援するGinのようなサードパーティのライブラリがまだ登場するのでしょうか？

実際、これはnet/httpの位置付けと密接に関係しています。net/httpパッケージは基本的なHTTP機能を提供し、その設計目標はシンプルさと汎用性に重点を置いており、高度な機能や便利な開発体験を提供することではありません。HTTPリクエストを処理し、Webアプリケーションを構築する過程で、開発者は一連の問題に遭遇する可能性があり、これがまさにGinのようなサードパーティのライブラリが生まれた理由です。

以下では、一連のシナリオを詳述し、net/httpとGinのこれらのシナリオにおける異なる実装方法を比較することで、Ginフレームワークの必要性を説明します。

## Ⅱ. 複雑なルーティングシナリオの処理
Webアプリケーションの実際の開発プロセスにおいて、同じルーティングプレフィックスを使用することは極めて一般的です。ここで、比較的典型的な2つの例を挙げます。

APIを設計する際、時間の経過とともに、APIはしばしば更新と改善が必要になります。後方互換性を維持し、複数のAPIバージョンを共存させるために、通常は/v1、/v2などのルーティングプレフィックスを使用して、異なるバージョンのAPIを区別します。

もう1つのシナリオは、大規模なWebアプリケーションは通常、複数のモジュールで構成されており、各モジュールは異なる機能を担当していることです。コードをより効果的に整理し、異なるモジュールのルートを区別するために、モジュール名をルーティングプレフィックスとして使用することがよくあります。

上記の2つのシナリオでは、同じルーティングプレフィックスを使用する可能性が非常に高いです。もし私たちがnet/httpを使用してWebアプリケーションを構築する場合、その実装は概ね以下の通りです：
```go
package main

import (
        "fmt"
        "net/http"
)

func handleUsersV1(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "User list in v1")
}

func handlePostsV1(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Post list in v1")
}

func main() {
        http.HandleFunc("/v1/users", handleUsersV1)
        http.HandleFunc("/v1/posts", handlePostsV1)
        http.ListenAndServe(":8080", nil)
}
```
上記の例では、手動でhttp.HandleFuncを呼び出すことで、異なるルーティング処理関数が定義されています。このコード例から見ると、明らかな問題は見られませんが、これは現在ルーティンググループが2つしかないからです。ルートの数が続けて増えると、処理関数の数も増え、コードはますます複雑で長くなります。また、各ルーティングルールには、手動でルーティングプレフィックスを設定する必要があり、例えば上記の例のv1プレフィックスのようにです。プレフィックスが/v1/v2/...のような複雑な形式の場合、設定プロセスはコードのアーキテクチャを明確にしないだけでなく、極めて煩雑で間違いやすくなります。

これに対して、Ginフレームワークはルーティンググループ機能を実装しています。以下は、Ginフレームワークにおけるこの機能の実装コードです：
```go
package main

import (
        "fmt"
        "github.com/gin-gonic/gin"
)

func main() {
        router := gin.Default()
        // ルーティンググループを作成
        v1 := router.Group("/v1")
        {
                v1.GET("/users", func(c *gin.Context) {
                        c.String(200, "User list in v1")
                })
                v1.GET("/posts", func(c *gin.Context) {
                        c.String(200, "Post list in v1")
                })
        }
        router.Run(":8080")
}
```
上記の例では、router.Groupを使用して、v1ルーティングプレフィックスを持つルーティンググループが作成されています。ルーティングルールを設定する際、再度ルーティングプレフィックスを設定する必要がなく、フレームワークが自動的に組み立てます。同時に、同じルーティングプレフィックスを持つルールはすべて同じコードブロック内で管理されます。net/httpコードライブラリと比較して、Ginはコード構造をより明確にし、管理しやすくします。

## Ⅲ. ミドルウェアの処理
Webアプリケーションのリクエストを処理する過程で、特定のビジネスロジックを実行するほかに、通常は事前にいくつかの共通のロジックを実行する必要があります。例えば、認証操作、エラーハンドリング、またはログの印刷機能などです。これらのロジックは総称してミドルウェア処理ロジックと呼ばれ、実際のアプリケーションでは欠かせないものです。

まず、エラーハンドリングに関してです。アプリケーションの実行中に、データベース接続の失敗、ファイル読み取りエラーなどの内部エラーが発生する可能性があります。適切なエラーハンドリングにより、これらのエラーがアプリケーション全体をクラッシュさせるのを防ぎ、代わりに適切なエラーレスポンスを介してクライアントに通知することができます。

認証操作については、多くのWeb処理シナリオで、ユーザーは通常、特定の制限されたリソースにアクセスするか、特定の操作を実行する前に、認証を行う必要があります。同時に、認証操作はユーザーの権限を制限し、ユーザーの不正アクセスを防ぐことができ、プログラムのセキュリティを向上させるのに役立ちます。

したがって、完全なHTTPリクエスト処理ロジックは、これらのミドルウェア処理ロジックを必要とする可能性が非常に高いです。理論的には、フレームワークまたはライブラリはミドルウェアロジックに対するサポートを提供するはずです。まず、net/httpがどのように実装しているか見てみましょう：
```go
package main

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

// エラーハンドリングミドルウェア
func errorHandler(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                defer func() {
                        if err := recover(); err != nil {
                                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
                                log.Printf("Panic: %v", err)
                        }
                }()
                next.ServeHTTP(w, r)
        })
}

// 認証ミドルウェア
func authMiddleware(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                // 認証をシミュレート
                if r.Header.Get("Authorization") != "secret" {
                        http.Error(w, "Unauthorized", http.StatusUnauthorized)
                        return
                }
                next.ServeHTTP(w, r)
        })
}

// ビジネスロジックを処理
func helloHandler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
}

// 追加
func anotherHandler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Another endpoint")
}

func main() {
        // ルートハンドラを作成
        router := http.NewServeMux()
        
        // ミドルウェアを適用し、ハンドラを登録
        handler := errorHandler(authMiddleware(http.HandlerFunc(helloHandler)))
        router.Handle("/", handler)
        
        // ミドルウェアを適用し、別のリクエストのハンドラを登録
        another := errorHandler(authMiddleware(http.HandlerFunc(anotherHandler)))
        router.Handle("/another", another)
        
        // サーバーを起動
        http.ListenAndServe(":8080", router)
}
```
上記の例では、net/httpでは、エラーハンドリングと認証機能が、2つのミドルウェアerrorHandlerとauthMiddlewareを通じて実装されています。例のコードの49行目を見ると、このコードはデコレータパターンを使用して、元のハンドラにエラーハンドリングと認証操作の機能を追加していることがわかります。このコード実装の利点は、デコレータパターンを通じて複数の処理関数を組み合わせてハンドラチェーンを形成することで、エラーハンドリングと認証機能を実現し、各処理関数ハンドラにこの部分のロジックを追加することなく、コードの可読性と保守性を向上させることができる点です。

しかし、ここにも重大な欠点があります。それは、この機能がフレームワークから直接提供されるものではなく、開発者自身が実装したものだということです。新しい処理関数ハンドラを追加するたびに、それをデコレートし、エラーハンドリングと認証操作を追加する必要があり、これは開発者の負担を増やすだけでなく、間違いやすいものです。また、要件が続けて変化するにつれて、一部のリクエストはエラーハンドリングのみを必要とし、一部のリクエストは認証操作のみを必要とし、一部のリクエストはエラーハンドリングと認証操作の両方を必要とする可能性があります。このコード構造に基づいて、保守の難しさはますます大きくなります。

これに対して、Ginフレームワークは、ミドルウェアロジックを有効化および無効化するより柔軟な方法を提供しています。特定のルーティンググループに対して設定することができ、各ルーティングルールを個別に設定する必要はありません。以下に例のコードを示します：
```go
package main

import (
        "github.com/gin-gonic/gin"
)

func authMiddleware() gin.HandlerFunc {
        return func(c *gin.Context) {
                // 認証をシミュレート
                if c.GetHeader("Authorization") != "secret" {
                        c.AbortWithStatusJSON(401, gin.H{"error": "Unauthorized"})
                        return
                }
                c.Next()
        }
}

func main() {
        router := gin.Default()
        // ロガーとリカバリーミドルウェアをグローバルに追加
        // ルーティンググループを作成し、このグループ内のすべてのルートはauthMiddlewareミドルウェアを適用する
        authenticated := router.Group("/")
        authenticated.Use(authMiddleware())
        {
                authenticated.GET("/hello", func(c *gin.Context) {
                        c.String(200, "Hello, World!")
                })

                authenticated.GET("/private", func(c *gin.Context) {
                        c.String(200, "Private data")
                })
        }

        // ルーティンググループに属していないため、authMiddlewareミドルウェアレを適用しない
        router.GET("/welcome", func(c *gin.Context) {
                c.String(200, "Welcome!")
        })

        router.Run(":8080")
}
```
上記の例では、`router.Group("/")` を通じて `authenticated` という名前のルーティンググループが作成され、その後 `Use` メソッドを使用してこのルーティンググループに `authMiddleware` ミドルウェアを有効にしています。このルーティンググループの下のすべてのルーティングルールは、自動的に `authMiddleware` が実装する認証操作を実行します。

`net/http` と比較すると、Gin の利点は以下の通りです。まず、各ハンドラをデコレートしてミドルウェアロジックを追加する必要がなく、開発者はビジネスロジックの開発に集中するだけでよく、開発負担が軽減されます。第二に、保守性が高いです。ビジネスが認証操作を必要としなくなった場合、Gin では `Use` メソッドの呼び出しを削除するだけで済みます。一方、`net/http` では、すべてのハンドラのデコレート操作を処理し、デコレータノード内の認証操作ノードを削除する必要があり、作業量が多く、間違いやすいです。最後に、リクエストの異なる部分が異なるミドルウェアを使用するシナリオでは、Gin はより柔軟で実装しやすいです。たとえば、一部のリクエストは認証操作を必要とし、一部のリクエストはエラーハンドリングを必要とし、一部のリクエストはエラーハンドリングと認証操作の両方を必要とする場合、このシナリオでは、Gin を通じて3つのルーティンググループを作成し、それぞれ異なるルーティンググループが `Use` メソッドを呼び出して異なるミドルウェアを有効にするだけで、要件を満たすことができます。これは `net/http` と比較して、より柔軟で保守しやすいです。これも、`net/http` が既に存在するにもかかわらず、Gin フレームワークが登場する重要な理由の1つです。

## Ⅳ. データバインディング
HTTP リクエストを処理する際、一般的な機能は、リクエスト内のデータを構造体に自動的にバインドすることです。フォームデータを例にとると、以下は `net/http` を使用した場合にデータを構造体にバインドする方法を示しています：
```go
package main

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

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

func handleFormSubmit(w http.ResponseWriter, r *http.Request) {
        var user User

        // フォームデータをUser構造体にバインド
        user.Name = r.FormValue("name")
        user.Email = r.FormValue("email")

        // ユーザーデータを処理
        fmt.Fprintf(w, "user has been created：%s (%s)", user.Name, user.Email)
}

func main() {
        http.HandleFunc("/createUser", handleFormSubmit)
        http.ListenAndServe(":8080", nil)
}
```
この過程では、`FormValue` メソッドを呼び出して、フォームからデータを1つずつ読み取り、それから構造体に設定する必要があります。フィールドが多い場合、一部のフィールドを見落として、後続の処理ロジックに問題が生じる可能性が非常に高いです。また、各フィールドを手動で読み取り、設定する必要があり、開発効率に大きく影響します。

次に、Gin がフォームデータを読み取り、構造体に設定する方法を見てみましょう：
```go
package main

import (
        "fmt"
        "github.com/gin-gonic/gin"
)

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

func handleFormSubmit(c *gin.Context) {
        var user User

        // フォームデータをUser構造体にバインド
        err := c.ShouldBind(&user)
        if err != nil {
                c.JSON(http.StatusBadRequest, gin.H{"error": "error form"})
                return
        }

        // ユーザーデータを処理
        c.JSON(http.StatusOK, gin.H{"message": fmt.Sprintf("user has been created：%s (%s)", user.Name, user.Email)})
}

func main() {
        router := gin.Default()
        router.POST("/createUser", handleFormSubmit)
        router.Run(":8080")
}
```
上記の例のコードの17行目を見ると、`ShouldBind` 関数を直接呼び出すことで、フォームデータを構造体に自動的にマッピングでき、各フィールドを1つずつ読み取り、個別に構造体に設定する必要がないことがわかります。`net/http` を使用する場合と比較して、Gin フレームワークはデータバインディングの面でより便利で、間違いが起きにくいです。Gin は、さまざまなタイプのデータを構造体にマッピングできるさまざまな API を提供しており、ユーザーは対応する API を呼び出すだけです。しかし、`net/http` はそのような操作を提供せず、ユーザーは自分でデータを読み取り、手動で構造体に設定する必要があります。

## Ⅴ. 結論
Go 言語では、`net/http` は基本的な HTTP 機能を提供しますが、その設計目標はシンプルさと汎用性に重点を置いており、高度な機能や便利な開発体験を提供することではありません。HTTP リクエストを処理し、Web アプリケーションを構築する際、`net/http` は複雑なルーティングルールに直面したときに不十分です。ログ記録やエラーハンドリングなどの一般的な操作については、プラガブルな設計を実現するのが難しいです。リクエストデータを構造体にバインドする面では、`net/http` は便利な操作を提供せず、ユーザーは手動で実装する必要があります。

これが、Gin のようなサードパーティのライブラリが登場する理由です。Gin は `net/http` の上に構築されており、Web アプリケーションの開発を簡素化し、高速化することを目的としています。全体的に、Gin は開発者がより効率的に Web アプリケーションを構築するのを支援し、より良い開発体験と豊富な機能を提供します。もちろん、`net/http` を使用するか Gin を使用するかは、プロジェクトの規模、要件、および個人の好みによって異なります。単純な小規模プロジェクトでは、`net/http` で十分な場合がありますが、複雑なアプリケーションでは、Gin の方が適している可能性があります。

# [Leapcell: The Next - Gen Serverless Platform for Golang app Hosting](https://leapcell.io/?lc_t=q_gonet)
最後に、Go サービスのデプロイに最適なプラットフォームをおすすめします：**[Leapcell](https://leapcell.io/?lc_t=q_gonet)**

[![barndpic.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/874cf113-1134-4437-bb3a-5bd81fb80576.png)](https://leapcell.io/?lc_t=q_gonet)


### 1. 多言語対応
- JavaScript、Python、Go、または Rust で開発できます。

### 2. 無制限のプロジェクトを無料でデプロイ
- 使用量に応じて課金 — リクエストがなければ料金はかかりません。

### 3. 比類のないコスト効率
- 従量制課金で、アイドル時の料金はかかりません。
- 例：平均応答時間 60ms で 694 万件のリクエストを 25 ドルでサポートします。

### 4. 簡素化された開発者体験
- 直感的な UI で簡単にセットアップできます。
- 完全自動化された CI/CD パイプラインと GitOps 統合。
- アクション可能な洞察を得るためのリアルタイムメトリクスとログ。

### 5. 簡単なスケーラビリティと高パフォーマンス
- 高い同時アクセスを簡単に処理するための自動スケーリング。
- 運用オーバーヘッドがゼロ — 構築に集中できます。

[![Frame3-withpadding2x.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/da66b0fd-a067-4b15-bb99-0e211cdb4306.png)](https://leapcell.io/?lc_t=q_gonet)


[ドキュメントで詳細を探索！](https://docs.leapcell.io/)

Leapcell Twitter: [https://x.com/LeapcellHQ](https://x.com/LeapcellHQ)