GoでのWeb開発：ミドルウェア、テンプレート、データベースなど

このシリーズの前回の記事では、Go net / httpについて広範な議論を行いました。 パッケージと、本番環境に対応したWebアプリケーションでの使用方法。主にルーティングの側面とその他の癖や http.ServeMuxの機能に焦点を当てました。 タイプ。

この記事では、 ServeMuxに関するディスカッションを締めくくります。 デフォルトのルーターを使用してミドルウェア機能を実装する方法を示し、Goを使用してWebサービスを開発するときに役立つ他の標準ライブラリパッケージを紹介します。

Goのミドルウェア

多くのまたはすべてのHTTPリクエストに対して実行する必要のある共有機能を設定する方法は、ミドルウェアと呼ばれます。 。認証、ログ記録、Cookie検証などの一部の操作は、通常のルートハンドラーの前後で独立してリクエストに対応するミドルウェア関数として実装されることがよくあります。

Goでミドルウェアを実装するには、http.Handlerインターフェースを満たすタイプがあることを確認する必要があります。通常、これは、signature ServeHTTP（http.ResponseWriter、* http.Request）を使用してメソッドをアタッチする必要があることを意味します。 タイプに。このメソッドを使用する場合、どのタイプでも http.Handlerを満たします。 インターフェイス。

簡単な例を次に示します。

package main

import "net/http"

type helloHandler struct {
    name string
}

func (h helloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello " + h.name))
}

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

    helloJohn := helloHandler{name: "John"}
    mux.Handle("/john", helloJohn)
    http.ListenAndServe(":8080", mux)
}

/ johnに送信されたリクエスト ルートはhelloHandler.ServeHTTPに直接渡されます 方法。サーバーを起動してhttp：// localhost：8080 / johnにアクセスすると、これが実際に動作していることを確認できます。

ServeHTTPを追加する必要があります http.Handlerを実装するたびにカスタムタイプへのメソッド かなり面倒なので、 net / http パッケージはhttp.HandlerFuncを提供します タイプ。通常の関数をHTTPハンドラーとして使用できます。

関数に次のシグネチャがあることを確認するだけです： func（http.ResponseWriter、* http.Request）;次に、それを http.HandlerFuncに変換します タイプ。

package main

import "net/http"

func helloJohnHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello John"))
}

func main() {
    mux := http.NewServeMux()
    mux.Handle("/john", http.HandlerFunc(helloJohnHandler))
    http.ListenAndServe(":8080", mux)
}

mux.Handleを置き換えることもできます mainの行 上記の関数withmux.HandleFunc 関数を直接渡します。前回の記事でこのパターンを排他的に使用しました。

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/john", helloJohnHandler)
    http.ListenAndServe(":8080", mux)
}

この時点で、 main に名前を設定できた以前とは異なり、名前は文字列にハードコードされています。 ハンドラーを呼び出す前に関数。この制限を取り除くために、以下に示すように、ハンドラーロジックをクロージャーに入れることができます：

package main

import "net/http"

func helloHandler(name string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello " + name))
    })
}

func main() {
    mux := http.NewServeMux()
    mux.Handle("/john", helloHandler("John"))
    http.ListenAndServe(":8080", mux)
}

helloHandler 関数自体がhttp.Handlerを満たしていません インターフェイスですが、匿名関数を作成して返します。この関数はnameを閉じます パラメータ。これは、呼び出されたときにいつでもアクセスできることを意味します。この時点で、 helloHandler 関数は、必要な数の異なる名前に再利用できます。

では、これはすべてミドルウェアと何の関係があるのでしょうか？さて、ミドルウェア関数の作成は、上記で見たのと同じ方法で行われます。 （例のように）文字列をクロージャーに渡す代わりに、チェーン内の次のハンドラーを引数として渡すことができます。

完全なパターンは次のとおりです。

func middleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // Middleware logic goes here...
    next.ServeHTTP(w, r)
  })
}

ミドルウェア 上記の関数はハンドラーを受け入れてハンドラーを返します。無名関数をhttp.Handlerを満たすようにする方法に注意してください。 http.HandlerFuncにキャストしてインターフェース タイプ。匿名関数の終了時に、制御は nextに移されます ServeHTTP（）を呼び出してハンドラー 方法。認証されたユーザーのIDなど、ハンドラー間で値を渡す必要がある場合は、 http.Request.Context（）を使用できます。 Go1.7で導入された方法。

このパターンを簡単に示すミドルウェア関数を書いてみましょう。この関数は、 requestTimeというプロパティを追加します リクエストオブジェクトに送信されます。リクエストオブジェクトは、その後 helloHandlerによって使用されます。 リクエストのタイムスタンプを表示します。

package main

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

func requestTime(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        ctx = context.WithValue(ctx, "requestTime", time.Now().Format(time.RFC3339))
        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)
    })
}

func helloHandler(name string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        responseText := "<h1>Hello " + name + "</h1>"

        if requestTime := r.Context().Value("requestTime"); requestTime != nil {
            if str, ok := requestTime.(string); ok {
                responseText = responseText + "\n<small>Generated at: " + str + "</small>"
            }
        }
        w.Write([]byte(responseText))
    })
}

func main() {
    mux := http.NewServeMux()
    mux.Handle("/john", requestTime(helloHandler("John")))
    http.ListenAndServe(":8080", mux)
}

ミドルウェア関数はhttp.Handlerを受け入れて返すため タイプの場合、相互にネストされたミドルウェア関数の無限のチェーンを作成することが可能です。

たとえば、

mux := http.NewServeMux()
mux.Handle("/", middleware1(middleware2(appHandler)))

Aliceのようなライブラリを使用して、上記の構成を次のようなより読みやすい形式に変換できます。

alice.New(middleware1, middleware2).Then(appHandler)

<ul>
  {{ range .TodoItems }}
  <li>{{ . }}</li>
  {{ end }}
</ul>

package main

import (
    "html/template"
    "log"
    "os"
)

func main() {
    t, err := template.ParseFiles("index.html")
    if err != nil {
        log.Fatal(err)
    }

    todos := []string{"Watch TV", "Do homework", "Play games", "Read"}

    err = t.Execute(os.Stdout, todos)
    if err != nil {
        log.Fatal(err)
    }
}

<ul>
  <li>Watch TV</li>
  <li>Do homework</li>
  <li>Play games</li>
  <li>Read</li>
</ul>

package main

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

func main() {
    t, err := template.ParseFiles("index.html")
    if err != nil {
        log.Fatal(err)
    }

    todos := []string{"Watch TV", "Do homework", "Play games", "Read"}

    http.HandleFunc("/todos", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        err = t.Execute(w, todos)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
        }
    })
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    FirstName string
    LastName  string
    Age       int
    email     string
}

func main() {
    p := Person{
        FirstName: "Abraham",
        LastName:  "Freeman",
        Age:       100,
        email:     "abraham.freeman@hey.com",
    }

    json, err := json.Marshal(p)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(json))
}

{"FirstName":"Abraham","LastName":"Freeman","Age":100}

type Person struct {
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
    Age       int    `json:"age"`
    email     string `json:"email"`
}

{"first_name":"Abraham","last_name":"Freeman","age":100}

func Unmarshal(data []byte, v interface{}) error

json := "{"first_name":"John","last_name":"Smith","age":35, "place_of_birth": "London", gender:"male"}"

func main() {
    b := `{"first_name":"John","last_name":"Smith","age":35, "place_of_birth": "London", "gender":"male", "email": "john.smith@hmail.com"}`
    var p Person
    err := json.Unmarshal([]byte(b), &p)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", p)
}

{FirstName:John LastName:Smith Age:35 email:}

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/hello")
    if err != nil {
        log.Fatal(err)
    }
}

err = db.Ping()
if err != nil {
  log.Fatal(err)
}

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/hello")
    if err != nil {
        log.Fatal(err)
    }
  defer db.Close()
}

var (
    id int
    name string
)

rows, err := db.Query("select id, name from users where id = ?", 1)
if err != nil {
    log.Fatal(err)
}

defer rows.Close()

for rows.Next() {
    err := rows.Scan(&id, &name)
    if err != nil {
        log.Fatal(err)
    }

    log.Println(id, name)
}

err = rows.Err()
if err != nil {
    log.Fatal(err)
}

var (
    id int
    name string
)

err = db.QueryRow("select id, name from users where id = ?", 1).Scan(&id, &name)
if err != nil {
    log.Fatal(err)
}

fmt.Println(id, name)