Golang Iris 框架介绍 1

文章简介

在本次教程中，将会向大家介绍Go Web框架Iris，文章会重点介绍Iris框架的功能特性、安装、主机服务和第一次运行几个方面为大家详细介绍。

Iris介绍

AndroidiosLinuxWindowsGoogle GoIrisapiIrisIrisMVCMVCGo WebIrisIris

Iris 框架的特性

专注于高性能
简单流畅的API
高扩展性
强大的路由和中间件生态系统
使用iris独特的表达主义路径解释器构建RESTful API
动态路径参数化或通配符路由与静态路由不冲突
使用重定向选项从URL中删除尾部斜杠
使用虚拟主机和子域名变得容易
分组API和静态或甚至动态子域名
net / http和negroni-like处理程序通过iris.FromStd兼容
针对任意Http请求错误定义处理函数
支持事务和回滚
支持响应缓存
使用简单的函数嵌入资源并与go-bindata 保持兼容
mvc
上下文
高度可扩展的试图渲染(目前支持markdown,json,xml，jsonp等等)
正文绑定器和发送HTTP响应的便捷功能
限制请求正文
提供静态资源或嵌入式资产
本地化i18N
压缩（Gzip是内置的）
身份验证
Basic Authentication
OAuth, OAuth2 (支持27个以上的热门网站)
JWT *服务器
通过TLS提供服务时，自动安装和提供来自https://letsencrypt.org的证书
默认为关闭状态
在关闭，错误或中断事件时注册
连接多个服务器，完全兼容 net/http#Server
视图系统.支持五种模板隐隐完全兼容 html/template
Websocket库，其API类似于http://socket.io [如果你愿意，你仍然可以使用你最喜欢的]
热重启
Typescript集成 + Web IDE

安装iris

iris安装要求golang版本至少为1.8,建议1.9(本文档按照1.9进行编写)

$ go get -u github.com/kataras/iris

Go 1.9

package main
    import (
        "github.com/kataras/iris"
        "github.com/kataras/iris/context"//需要单独引入
    )
    func main() {
        app := iris.New()
        app.Get("/", func(ctx context.Context){})
        app.Run(iris.Addr(":8080"))
    }

从 Go 1.9开始，在您不必导入之后，您可以选择性地执行此操作：

package main
    import "github.com/kataras/iris"
    func main() {
        app := iris.New()
        app.Get("/", func(ctx iris.Context){})
        app.Run(iris.Addr(":8080"))
    }

同样的 kataras/iris/core/router/APIBuilder#PartyFunc

package main
    import (
        "github.com/kataras/iris"
        //"github.com/kataras/iris/core/router" 1.9之后需要引入
    )
    func main()  {
    app := iris.New()
    app.Get("/", func(ctx iris.Context){})
    app.Run(iris.Addr(":8080"))
    app.PartyFunc("/cpanel", func(child iris.Party) { 
         child.Get("/", func(ctx iris.Context){})
    })
     // OR
     cpanel := app.Party("/cpanel")
     cpanel.Get("/", func(ctx iris.Context){})
   }

Hosts

监听服务

net.Listenerhttp.Server

Go开发人员用于服务其服务器的最常用方法是传递“hostname：ip”形式的网络地址。有了Iris，我们使用的iris.Addr是一种iris.Runner类型

//用网络地址监听tcp 0.0.0.0:8080

app.Run(iris.Addr(":8080"))

有时您在应用程序的其他位置创建了标准的net / http服务器，并希望使用它来为Iris Web应用程序提供服务

// 与之前相同，但使用自定义的http.Server，也可能在其他地方使用

app.Run(iris.Server(&http.Server{Addr:":8080"}))

最高级的用法是创建自定义或标准net.Listener并将其传递给app.Run

// 使用自定义的net.Listener

l, err := net.Listen("tcp4", ":8080")
    if err != nil {
        panic(err)
    }
    app.Run(iris.Listener(l))

一个更完整的示例，使用仅限unix的套接字文件功能

package main
    import (
        "os"
        "net"
        "github.com/kataras/iris"
    )
    func main() {
        app := iris.New()
        // UNIX socket
        if errOs := os.Remove(socketFile); errOs != nil && !os.IsNotExist(errOs) {
            app.Logger().Fatal(errOs)
        }
        l, err := net.Listen("unix", socketFile)
        if err != nil {
            app.Logger().Fatal(err)
        }
        if err = os.Chmod(socketFile, mode); err != nil {
            app.Logger().Fatal(err)
        }
        app.Run(iris.Listener(l))
    }

UNIX和BSD主机可以优先考虑重用端口功能

package main
    import (
        // Package tcplisten provides customizable TCP net.Listener with various
        // performance-related options:
        //
        //   - SO_REUSEPORT. This option allows linear scaling server performance
        //     on multi-CPU servers.
        //     See https://www.nginx.com/blog/socket-sharding-nginx-release-1-9-1/ for details.
        //
        //   - TCP_DEFER_ACCEPT. This option expects the server reads from the accepted
        //     connection before writing to them.
        //
        //   - TCP_FASTOPEN. See https://lwn.net/Articles/508865/ for details.
        "github.com/valyala/tcplisten"
        "github.com/kataras/iris"
    )
   //go get github.com/valyala/tcplisten
   //go run main.go
    func main() {
        app := iris.New()
        app.Get("/", func(ctx iris.Context) {
            ctx.HTML("<h1>Hello World!</h1>")
        })
        listenerCfg := tcplisten.Config{
            ReusePort:   true,
            DeferAccept: true,
            FastOpen:    true,
        }
        l, err := listenerCfg.NewListener("tcp", ":8080")
        if err != nil {
            app.Logger().Fatal(err)
        }
        app.Run(iris.Listener(l))
    }

HTTP / 2和安全

如果您有已签名的文件密钥，则可以根据这些证书密钥使用该iris.TLS服务https

app.Run(iris.TLS("127.0.0.1:443", "mycert.cert", "mykey.key"))

该方法时，你的应用程序已经准备好，你应该使用的生产是iris.AutoTLS其开始安全服务器所提供的自动认证 https://letsencrypt.org为免费

// Automatic TLS

app.Run(iris.AutoTLS(":443", "example.com","admin@example.com"))

任何 iris.Runner

net.Listener

net / http

app.Run(iris.Raw(&http.Server{Addr:":8080"}).ListenAndServe)

主机配置器

所有上述形式的倾听都接受了最后的，可变的论证func(*iris.Supervisor)。这用于为通过这些函数传递的特定主机添加配置程序。

例如，假设我们要添加一个在服务器关闭时触发的回调

app.Run(iris.Addr(":8080", func(h *iris.Supervisor) {
        h.RegisterOnShutdown(func() {
            println("server terminated")
        })
    }))

您甚至可以在app.Run方法之前执行此操作，但区别在于这些主机配置程序将被执行到您可能用于为您的Web应用程序提供服务的所有主机（通过app.NewHost我们将在一分钟内看到）

app := iris.New()
    app.ConfigureHost(func(h *iris.Supervisor) {
        h.RegisterOnShutdown(func() {
            println("server terminated")
        })
    })
    app.Run(iris.Addr(":8080"))

Application#Hosts在该Run方法之后，字段可以提供对为您的应用程序提供服务的所有主机的访问权限。

但最常见的情况是您可能需要在app.Run方法之前访问主机，有两种获取访问主机主管的方法，请参阅下文。

我们已经看到了如何通过app.Run或的第二个参数配置所有应用程序的主机app.ConfigureHost。还有一种方法更适合简单的场景，即使用app.NewHost创建新主机并使用其中一个Serve或多个Listen函数通过iris#RawRunner 启动应用程序。

请注意，这种方式需要额外导入net/http包。

h := app.NewHost(&http.Server{Addr:":8080"})
    h.RegisterOnShutdown(func(){
        println("server terminated")
    })
    app.Run(iris.Raw(h.ListenAndServe))

多主机

您可以使用多个服务器为您的Iris Web应用程序提供服务，因此iris.Router与net/http/Handler功能兼容，您可以理解，它可以在任何net/http服务器上进行调整，但是有一种更简单的方法，通过使用app.NewHost也可以复制所有主机配置程序，它关闭连接到特定Web应用程序的所有主机app.Shutdown。

app := iris.New()
    app.Get("/", indexHandler)

    //在不同的goroutine中运行，以便不阻止主要的“goroutine”。
    go app.Run(iris.Addr(":8080"))

    // 启动第二个服务器，它正在监听tcp 0.0.0.0:9090，
    //没有“go”关键字，因为我们想要在最后一次服务器运行时阻止。
    app.NewHost(&http.Server{Addr:":9090"}).ListenAndServe()

关机（优雅）让我们继续学习如何捕获CONTROL + C / COMMAND + C或unix kill命令并优雅地关闭服务器。

正确关闭CONTROL + C / COMMAND + C或者当发送的kill命令是ENABLED BY-DEFAULT时。

为了手动管理应用程序中断时要执行的操作，我们必须使用该选项禁用默认行为WithoutInterruptHandler 并注册新的中断处理程序（全局，跨所有可能的主机）。

如下代码:

package main
    import (
        "context"
        "time"
        "github.com/kataras/iris"
    )
    func main() {
        app := iris.New()
        iris.RegisterOnInterrupt(func() {
            timeout := 5 * time.Second
            ctx, cancel := context.WithTimeout(context.Background(), timeout)
            defer cancel()
            // close all hosts
            app.Shutdown(ctx)
        })
        app.Get("/", func(ctx iris.Context) {
            ctx.HTML(" <h1>hi, I just exist in order to see if the server is closed</h1>")
        })
        app.Run(iris.Addr(":8080"), iris.WithoutInterruptHandler)
    }

第一次运行

安装完Iris,我们就可以跟着下面的简单示例运行我们的第一个web应用程序了,下面程序通过调用不同方法实现不同格式的输出如 json,字符串,和直接输出html代码等

我们新建serv.go 文件写入以下内容.

package main
    import (
        "github.com/kataras/iris"
        "github.com/kataras/iris/middleware/logger"
        "github.com/kataras/iris/middleware/recover"
    )
    func main() {
        app := iris.New()
        app.Use(recover.New())
        app.Use(logger.New())
        //输出html
        // 请求方式: GET
        // 访问地址: http://localhost:8080/welcome
        app.Handle("GET", "/welcome", func(ctx iris.Context) {
            ctx.HTML("<h1>Welcome</h1>")
        })
        //输出字符串
        // 类似于 app.Handle("GET", "/ping", [...])
        // 请求方式: GET
        // 请求地址: http://localhost:8080/ping
        app.Get("/ping", func(ctx iris.Context) {
            ctx.WriteString("pong")
        })
        //输出json
        // 请求方式: GET
        // 请求地址: http://localhost:8080/hello
        app.Get("/hello", func(ctx iris.Context) {
            ctx.JSON(iris.Map{"message": "Hello Iris!"})
        })
        app.Run(iris.Addr(":8080"))//8080 监听端口
    }

现在打开控制台切换到该文件同级目录我们执行以下命令。

$ go run serv.go

我们可以看到如下输出,控制台信息告知我们有新的版本可以更新,如果我们不做更新的话可以无视它,后面我们会看到如何关闭版本更新提示

现在我们打开浏览器或者curl 请求的们定义的地址,这里我们拿 http://localhost:8080/welcome 测试请求记过如下图:

快去看看控制台输出了什么信息吧

ctrl+c

Golang Iris 框架 介绍 1