原始请求转换成context.Handler

    代码示例

    main.go

    1. package main
    3. import (
    4.     "net/http"
    5.     "github.com/kataras/iris"
    6. )
    8. func main() {
    9.     app := iris.New()
    10.     //FromStd将原生http.Handler,http.HandlerFunc和func(w，r，next)转换为context.Handler
    11.     irisMiddleware := iris.FromStd(negronilikeTestMiddleware)
    12.     app.Use(irisMiddleware)
    13.     // 请求 GET: http://localhost:8080/
    14.     app.Get("/", func(ctx iris.Context) {
    15.         ctx.HTML("<h1> Home </h1>")
    16.         //这会打印错误
    17.         //这个路由的处理程序永远不会被执行，因为中间件的标准没有通过
    18.     })
    19.     // 请求 GET: http://localhost:8080/ok
    20.     app.Get("/ok", func(ctx iris.Context) {
    21.         ctx.Writef("Hello world!")
    22.         // 这将打印"OK. Hello world!"
    23.     })
    24.     // http://localhost:8080
    25.     // http://localhost:8080/ok
    26.     app.Run(iris.Addr(":8080"))
    27. }
    29. func negronilikeTestMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
    30.     if r.URL.Path == "/ok" && r.Method == "GET" {
    31.         w.Write([]byte("OK. "))
    32.         next(w, r) // 中间件
    33.         return
    34.     }
    35.     //否则打印错误
    36.     w.WriteHeader(iris.StatusBadRequest)
    37.     w.Write([]byte("Bad request"))
    38. }
    39. //如果要使用自定义上下文转换自定义处理程序，请查看routing/custom-context
    40. //一个context.Handler

    negroni是go实现中间件的一种使用很广泛的模式

    代码示例

    main.go

    1. package main
    3. import (
    4.     "net/http"
    5. )
    7. func main() {
    8.     app := iris.New()
    9.     //FromStd将原生http.Handler,http.HandlerFunc和func(w，r，next)转换为context.Handler
    10.     irisMiddleware := iris.FromStd(nativeTestMiddleware)
    11.     app.Use(irisMiddleware)
    13.     app.Get("/", func(ctx iris.Context) {
    14.         ctx.HTML("Home")
    15.     })
    16.     // 请求 GET: http://localhost:8080/ok
    17.     app.Get("/ok", func(ctx iris.Context) {
    18.         ctx.HTML("<b>Hello world!</b>")
    19.     })
    20.     // http://localhost:8080
    21.     // http://localhost:8080/ok
    22.     app.Run(iris.Addr(":8080"))
    23. }
    25. func nativeTestMiddleware(w http.ResponseWriter, r *http.Request) {
    26.     println("Request path: " + r.URL.Path)
    27. }
    28. //如果要使用自定义上下文转换自定义处理程序，请查看routing/custom-context
    29. //一个context.Handler。

    直接把原生的net/http满足请求接口的函数转化成中间件

    目录结构

    代码示例

    main.go

    1. package main
    3. import (
    4.     "errors"
    5.     "fmt"
    6.     "net/http"
    7.     "runtime/debug"
    8.     "github.com/kataras/iris"
    9.     "github.com/getsentry/raven-go"
    10. )
    12. // https://docs.sentry.io/clients/go/integrations/http/
    13. func init() {
    14.     raven.SetDSN("https://<key>:<secret>@sentry.io/<project>")
    15. }
    17. func main() {
    18.     app := iris.New()
    19.     app.Get("/", func(ctx iris.Context) {
    20.         ctx.Writef("Hi")
    21.     })
    22.     // WrapRouter的示例已在此处:
    23.     // https://github.com/kataras/iris/blob/master/_examples/routing/custom-wrapper/main.go#L53
    24.     app.WrapRouter(func(w http.ResponseWriter, r *http.Request, irisRouter http.HandlerFunc) {
    25.         //完全相同的源代码:
    26.         // https://github.com/getsentry/raven-go/blob/379f8d0a68ca237cf8893a1cdfd4f574125e2c51/http.go#L70
    27.         defer func() {
    28.             if rval := recover(); rval != nil {
    29.                 debug.PrintStack()
    30.                 rvalStr := fmt.Sprint(rval)
    31.                 packet := raven.NewPacket(rvalStr, raven.NewException(errors.New(rvalStr), raven.NewStacktrace(2, 3, nil)), raven.NewHttp(r))
    32.                 raven.Capture(packet, nil)
    33.                 w.WriteHeader(http.StatusInternalServerError)
    34.         }()
    35.         irisRouter(w, r)
    36.     })
    38. }

    2.直接中间件类型

    目录结构

    主目录writingMiddleware

    代码示例

    1. package main
    3. import (
    4.     "errors"
    5.     "fmt"
    6.     "runtime/debug"
    7.     "github.com/kataras/iris"
    8.     "github.com/getsentry/raven-go"
    9. )
    10. //raven实现了Sentry错误日志记录服务的客户端。
    11. //在此示例中，您将看到如何转换任何net/http中间件
    12. //具有`(HandlerFunc)HandlerFunc`的形式。
    13. //如果`raven.RecoveryHandler`的形式是
    14. //`(http.HandlerFunc)`或`(http.HandlerFunc,下一个http.HandlerFunc)`
    15. //你可以使用`irisMiddleware：= iris.FromStd(nativeHandler)`
    16. //但它没有，但是你已经知道Iris可以直接使用net/http
    17. //因为`ctx.ResponseWriter()`和`ctx.Request()`是原来的
    18. // http.ResponseWriter和* http.Request。
    19. //(这个是一个很大的优势，因此你可以永远使用Iris :))。
    20. //本机中间件的源代码根本不会改变。
    21. // https://github.com/getsentry/raven-go/blob/379f8d0a68ca237cf8893a1cdfd4f574125e2c51/http.go#L70
    22. //唯一的补充是第18行和第39行(而不是handler(w，r))
    23. //你有一个新的Iris中间件准备使用！
    24. func irisRavenMiddleware(ctx iris.Context) {
    25.     w, r := ctx.ResponseWriter(), ctx.Request()
    26.     defer func() {
    27.         if rval := recover(); rval != nil {
    28.             debug.PrintStack()
    29.             rvalStr := fmt.Sprint(rval)
    30.             packet := raven.NewPacket(rvalStr, raven.NewException(errors.New(rvalStr), raven.NewStacktrace(2, 3, nil)), raven.NewHttp(r))
    31.             raven.Capture(packet, nil)
    32.             w.WriteHeader(iris.StatusInternalServerError)
    33.         }
    34.     }()
    35.     ctx.Next()
    36. }
    38. // https://docs.sentry.io/clients/go/integrations/http/
    39. func init() {
    40.     raven.SetDSN("https://<key>:<secret>@sentry.io/<project>")
    41. }
    43. func main() {
    44.     app := iris.New()
    45.     app.Use(irisRavenMiddleware)
    46.     app.Get("/", func(ctx iris.Context) {
    47.         ctx.Writef("Hi")
    48.     })
    49.     app.Run(iris.Addr(":8080"))
    50. }
    • 主要介绍如何将原始请求转换成context.Handler
    • Negroni是面向web中间件的一种惯用方法.它是微小的,非侵入性的,并且鼓励使用net/http处理器
    • 错误中间件(raven)客户端为我们提供了一个非常清晰的报表,展示我们的响应并提高质量.这是完整的堆栈跟踪.这是一个非常强大的东西