lris框架基础案例

  

下载

//俩种下载方式选1
# go get -u github.com/kataras/iris
# git clone https://github.com/kataras/iris.git

postman下载
http://y.downya.com/down1/postman_v7.6.0_downyi.com.zip

1. Get、Post、Put等请求

package main

import (
    "github.com/kataras/iris"
    "github.com/kataras/iris/context"
)

//main方法
func main() {

    //GET请求
    // http://localhost:8080/hello
    //app.Handle("GET", "/hello", func(context context.Context) {
    //    context.HTML("<h1> Hello world. </h1>")
    //})
    //app.Get("/hello", func(context context.Context) {
    //    context.HTML("<h1> Hello world. </h1>")
    //})
    //
    //app.Handle("GET", "/string", func(context context.Context) {
    //    context.WriteString(" This is get request ")
    //})
    //
    ////POST请求
    //app.Handle("POST", "/postHello", func(context context.Context) {
    //    context.HTML("<h1> This is post request </h1>")
    //})
    //app.Post("/postHello", func(context context.Context) {
    //    context.HTML("<h1> This is post request </h1>")
    //})
    //
    ////Options
    //app.Handle("OPTIONS", "/options", func(context context.Context) {
    //    context.HTML("<h1> This is  options request </h1>")
    //})
    //app.Options("/options", func(context context.Context) {
    //
    //})

    //http://localhost:8080/user/info
    //app.Get("/user/info", func(context context.Context) {
    //    //context.WriteString("Hello world")
    //    context.HTML("<h1> Hello wrold </h1>")
    //})
    //app.Handle("GET", "/user/info", func(context context.Context) {
    //    context.Text("Hello world")
    //})

    //POST请求
    //app.Post("/user/info", func(context context.Context) {
    //    context.WriteString(" User Info is Post Request ")
    //})
    //app.Handle("POST", "/user/info", func(context context.Context) {
    //    context.WriteString(" User Info is Post Request , Deal is in handle func ")
    //})
    //

    app := iris.New()

    app.Get("/getRequest", func(context context.Context) {
        //处理get请求，请求的url为：/getRequest
        path := context.Path()
        app.Logger().Info(path)
    })

    //1、处理Get请求
    app.Get("/userpath", func(context context.Context) {
        //获取Path
        path := context.Path()
        app.Logger().Info(path)
        //写入返回数据：string类型
        context.WriteString("请求路径：" + path)
    })

    //2.处理Get请求 并接受参数
    app.Get("/userinfo", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(path)
        //获取get请求所携带的参数
        userName := context.URLParam("username") //
        app.Logger().Info(userName)

        pwd := context.URLParam("pwd")
        app.Logger().Info(pwd)
        //返回html数据格式
        context.HTML("<h1>" + userName + "," + pwd + "</h1>")
    })

    //3.处理Post请求 form表单的字段获取
    app.Post("/postLogin", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(path)
        //context.PostValue方法来获取post请求所提交的for表单数据
        name := context.PostValue("name")
        pwd := context.PostValue("pwd")
        app.Logger().Info(name, "  ", pwd)
        context.HTML(name)
    })

    //4、处理Post请求 Json格式数据
    /**
     * Postman工具选择[{"key":"Content-Type","value":"application/json","description":""}]
     * 请求内容：{"name": "davie","age": 28}
     */
    app.Post("/postJson", func(context context.Context) {

        //1.path
        path := context.Path()
        app.Logger().Info("请求URL：", path)

        //2.Json数据解析
        var person Person
        //context.ReadJSON()
        if err := context.ReadJSON(&person); err != nil {
            panic(err.Error())
        }

        //输出：Received: main.Person{Name:"davie", Age:28}
        context.Writef("Received: %#+v
", person)
    })

    //5.处理Post请求 Xml格式数据
    /**
     * 请求配置：Content-Type到application/xml（可选但最好设置）
     * 请求内容：
     *
     *  <student>
     *        <stu_name>davie</stu_name>
     *        <stu_age>28</stu_age>
     *    </student>
     *
     */

    app.Post("/postXml", func(context context.Context) {

        //1.Path
        path := context.Path()
        app.Logger().Info("请求URL：", path)

        //2.XML数据解析
        var student Student
        if err := context.ReadXML(&student); err != nil {
            panic(err.Error())
        }
        //输出：
        context.Writef("Received：%#+v
", student)
    })

    //put请求
    app.Put("/putinfo", func(context context.Context) {
        path := context.Path()
        app.Logger().Info("请求url：", path)
    })

    //delete请求
    app.Delete("/deleteuser", func(context context.Context) {
        path := context.Path()
        app.Logger().Info("Delete请求url：", path)
    })

    app.Run(iris.Addr(":8000"), iris.WithoutServerError(iris.ErrServerClosed))
}

//自定义的struct
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

//自定义的结构体
type Student struct {
    //XMLName xml.Name `xml:"student"`
    StuName string `xml:"stu_name"`
    StuAge  int    `xml:"stu_age"`
}

type config struct {
    Addr       string `yaml:"addr"`
    ServerName string `yaml:"serverName"`
}

 3. 请求数据格式返回

package main

import (
    "github.com/kataras/iris"
    "github.com/kataras/iris/context"
)

type Teacher struct {
    Name  string `json:"Name"`
    City  string `json:"City"`
    Other string `json:"Other"`
}

//程序主入口
func main() {

    app := iris.New()

    /**
     * 通过Get请求
     * 返回 WriteString
     */
    app.Get("/getHello", func(context context.Context) {
        context.WriteString(" Hello world ")
    })

    /**
     * 通过Get请求
     * 返回 HTML数据
     */
    app.Get("/getHtml", func(context context.Context) {
        context.HTML("<h1> Davie, 12 </h1>")
    })

    /**
     * 通过Get请求
     * 返回 Json数据
     */
    app.Get("/getJson", func(context context.Context) {
        context.JSON(iris.Map{"message": "hello word", "requestCode": 200})
    })

    //POST
    app.Post("/user/postinfo", func(context context.Context) {
        //context.WriteString(" Post Request ")
        //user := context.Params().GetString("user")

        var tec Teacher
        err := context.ReadJSON(&tec)
        if err != nil {
            panic(err.Error())
        } else {
            app.Logger().Info(tec)
            context.WriteString(tec.Name)
        }

        //fmt.Println(user)
        //teacher := Teacher{}
        //err := context.ReadForm(&teacher)
        //if err != nil {
        //    panic(err.Error())
        //} else {
        //    context.WriteString(teacher.Name)
        //}
    })

    //PUT
    app.Put("/getHello", func(context context.Context) {
        context.WriteString(" Put Request ")
    })

    app.Delete("/DeleteHello", func(context context.Context) {
        context.WriteString(" Delete Request ")
    })

    //返回json数据
    app.Get("/getJson", func(context context.Context) {
        context.JSON(iris.Map{"message": "hello word", "requestCode": 200})
    })

    app.Get("/getStuJson", func(context context.Context) {
        context.JSON(Student{Name: "Davie", Age: 18})
    })

    //返回xml数据
    app.Get("/getXml", func(context context.Context) {
        context.XML(Person{Name: "Davie", Age: 18})
    })

    //返回Text
    app.Get("/helloText", func(context context.Context) {
        context.Text(" text hello world ")
    })

    app.Run(iris.Addr(":8000"), iris.WithoutServerError(iris.ErrServerClosed))

}

//json结构体
type Student struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

//xml结构体
type Person struct {
    Name string `xml:"name"`
    Age  int    `xml:"age"`
}

4. 路由功能处理方式

package main

import (
    "github.com/kataras/iris"
    "github.com/kataras/iris/context"
)

func main() {

    app := iris.New()

    /**
     * 1.handle方式处理请求
     */
    //GET: http://localhost:8002/userinfo
    app.Handle("GET", "/userinfo", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(path)
        app.Logger().Error(" request path :", path)
    })

    //post
    app.Handle("POST", "/postcommit", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(" post reuqest, the url is : ", path)
        context.HTML(path)
    })

    //      http://localhost:8002?date=20190310&city=beijing
    //GET： http://localhost:8002/weather/2019-03-10/beijing
    //      http://localhost:8002/weather/2019-03-11/beijing
    //      http://localhost:8002/weather/2019-03-11/tianjin

    app.Get("/weather/{date}/{city}", func(context context.Context) {
        path := context.Path()
        date := context.Params().Get("date")
        city := context.Params().Get("city")
        context.WriteString(path + "  , " + date + " , " + city)
    })
    
    /**
     * 1、Get 正则表达式 路由
     * 使用：context.Params().Get("name") 获取正则表达式变量
     *
     */
    // 请求1：/hello/1  /hello/2  /hello/3 /hello/10000
    //正则表达式：{name}
    app.Get("/hello/{name}", func(context context.Context) {
        //获取变量
        path := context.Path()

        app.Logger().Info(path)
        //获取正则表达式变量内容值
        name := context.Params().Get("name")
        context.HTML("<h1>" + name + "</h1>")
    })

    /**
     * 2、自定义正则表达式变量路由请求 {unit64:uint64}进行变量类型限制
     */
    // 123
    // davie
    app.Get("/api/users/{userid:uint64}", func(context context.Context) {
        userID, err := context.Params().GetUint("userid")

        if err != nil {
            //设置请求状态码，状态码可以自定义
            context.JSON(map[string]interface{}{
                "requestcode": 201,
                "message":     "bad request",
            })
            return
        }

        context.JSON(map[string]interface{}{
            "requestcode": 200,
            "user_id":     userID,
        })
    })

    //自定义正则表达式路由请求 bool
    app.Get("/api/users/{isLogin:bool}", func(context context.Context) {
        isLogin, err := context.Params().GetBool("isLogin")
        if err != nil {
            context.StatusCode(iris.StatusNonAuthoritativeInfo)
            return
        }
        if isLogin {
            context.WriteString(" 已登录 ")
        } else {
            context.WriteString(" 未登录 ")
        }

        //正则表达式所支持的数据类型
        context.Params()
    })

    app.Run(iris.Addr(":8002"), iris.WithoutServerError(iris.ErrServerClosed))

}

5. 路由组

package main

import (
    "github.com/kataras/iris"
    "github.com/kataras/iris/context"
)

func main() {

    app := iris.New()

    //用户模块users
    //  xxx/users/register 注册
    //  xxx/users/login  登录
    //  xxx/users/info   获取用户信息

    /**
     * 路由组请求
     */
    userParty := app.Party("/users", func(context context.Context) {
        // 处理下一级请求
        context.Next()
    })

    /**
     * 路由组下面的下一级请求
     * ../users/register
     */
    userParty.Get("/register", func(context context.Context) {
        app.Logger().Info("用户注册功能")
        context.HTML("<h1>用户注册功能</h1>")
    })

    /**
     * 路由组下面的下一级请求
     * ../users/login
     */
    userParty.Get("/login", func(context context.Context) {
        app.Logger().Info("用户登录功能")
        context.HTML("<h1>用户登录功能</h1>")
    })

    usersRouter := app.Party("/admin", userMiddleware)

    //Done：
    usersRouter.Done(func(context context.Context) {

        context.Application().Logger().Infof("response sent to " + context.Path())
    })

    usersRouter.Get("/info", func(context context.Context) {
        context.HTML("<h1> 用户信息 </h1>")
        context.Next()// 手动显示调用
    })

    usersRouter.Get("/query", func(context context.Context) {
        context.HTML("<h1> 查询信息 </h1>")
    })

    app.Run(iris.Addr(":8003"), iris.WithoutServerError(iris.ErrServerClosed))
}

//用户路由中间件
func userMiddleware(context iris.Context) {
    context.Next()
}

6. Iris配置

package main

import (
    "github.com/kataras/iris"
    "os"
    "encoding/json"
    "fmt"
)

/**
 * Iris配置设置案例
 */
func main() {

    //1.新建app实例
    app := iris.New()

    //一、通过程序代码对应用进行全局配置
    app.Configure(iris.WithConfiguration(iris.Configuration{
        //如果设置为true，当人为中断程序执行时，则不会自动正常将服务器关闭。如果设置为true，需要自己自定义处理。
        DisableInterruptHandler: false,
        //该配置项表示更正并将请求的路径重定向到已注册的路径
        //比如：如果请求/home/ 但找不到此Route的处理程序，然后路由器检查/home处理程序是否存在，如果是，（permant）将客户端重定向到正确的路径/home。
        //默认为false
        DisablePathCorrection: false,
        //
        EnablePathEscape:                  false,
        FireMethodNotAllowed:              false,
        DisableBodyConsumptionOnUnmarshal: false,
        DisableAutoFireStatusCode:         false,
        TimeFormat:                        "Mon,02 Jan 2006 15:04:05 GMT",
        Charset:                           "utf-8",
    }))

    //二、通过读取tml配置文件读取服务配置
    //注意：要在run方法运行之前执行
    app.Configure(iris.WithConfiguration(iris.TOML("/Users/hongweiyu/go/src/irisDemo/5-路由组及Iris配置/configs/iris.tml")))

    //三、通过读取yaml配置文件读取服务配置
    //同样要在run方法运行之前执行
    app.Configure(iris.WithConfiguration(iris.YAML("/Users/hongweiyu/go/src/irisDemo/5-路由组及Iris配置/configs/iris.yml")))

    //四、通过json配置文件进行应用配置
    file, _ := os.Open("/Users/hongweiyu/go/src/irisDemo/5-路由组及Iris配置/config.json")
    defer file.Close()
    
    decoder := json.NewDecoder(file)
    conf := Coniguration{}
    err := decoder.Decode(&conf)
    if err != nil {
        fmt.Println("Error:", err)
    }
    fmt.Println(conf.Port)

    //2.运行服务，端口监听
    app.Run(iris.Addr(":8009"))
}

type Coniguration struct {
    AppName string `json:"appname"`
    Port    int    `json:"port"`
}

config.json

{
  "appname": "IrisDemo",
  "port": 8000
}

iris.tml

DisablePathCorrection = false
EnablePathEscape = false
FireMethodNotAllowed = true
DisableBodyConsumptionOnUnmarshal = false
TimeFormat = "Mon, 01 Jan 2006 15:04:05 GMT"
Charset = "UTF-8"

[Other]
    MyServerName = "iris"

iris.yml

DisablePathCorrection: false
EnablePathEscape: false
FireMethodNotAllowed: true
DisableBodyConsumptionOnUnmarshal: true
TimeFormat: Mon, 01 Jan 2006 15:04:05 GMT
Charset: UTF-8

7. MVC包使用

package main

import (
    "github.com/kataras/iris"
    "github.com/kataras/iris/mvc"
)

func main() {
    app := iris.New()

    //mvc.Configure(app.Party("/user"), )
    //设置自定义控制器
    mvc.New(app).Handle(new(UserController))

    //路由组的mvc处理
    mvc.Configure(app.Party("/user"), func(context *mvc.Application) {
        context.Handle(new(UserController))
    })

    app.Run(iris.Addr(":8009"))
}

/**
 * url：http://localhost:8009
 * type：get
 */
func (uc *UserController) Get() string {
    iris.New().Logger().Info(" Get 请求 ")
    return "hell world"
}

/**
 * url：http://localhost:8009
 * type：post
 */
func (uc *UserController) Post() {
    iris.New().Logger().Info(" post 请求 ")
}

func (uc *UserController) Put() {
    iris.New().Logger().Info(" put 请求 ")
}

/**
 * url：http://localhost:8009/info
 * type：get
 */
func (uc *UserController) GetInfo() mvc.Result {
    iris.New().Logger().Info(" get 请求, 请求路径为info ")
    return mvc.Response{
        Object: map[string]interface{}{
            "code":     1,
            "msessage": "请求成功",
        },
    }
}

type UserController struct {
}

func (uc *UserController) BeforeActivation(a mvc.BeforeActivation) {
    a.Handle("GET", "/query", "UserInfo")
}

/**
 * url： http://localhost:8009/query
 * type：get
 */
func (uc *UserController) UserInfo() mvc.Result {
    //todo
    iris.New().Logger().Info(" user info query ")
    return mvc.Response{}
}

 

8.Seesion的使用和控制

package main

import (
    "github.com/kataras/iris/sessions"
    "github.com/kataras/iris"
    "github.com/kataras/iris/context"
    "github.com/kataras/iris/sessions/sessiondb/boltdb"
)

var (
    USERNAME = "userName"
    ISLOGIN  = "isLogin"
)

/**
 * Session的使用和控制
 */
func main() {

    app := iris.New()

    sessionID := "mySession"

    //1、创建session并进行使用
    sess := sessions.New(sessions.Config{
        Cookie: sessionID,
    })

    /**
     * 用户登录功能
     */
    app.Post("/login", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(" 请求Path：", path)
        userName := context.PostValue("name")
        passwd := context.PostValue("pwd")

        if userName == "davie" && passwd == "pwd123" {
            session := sess.Start(context)

            //用户名
            session.Set(USERNAME, userName)
            //登录状态
            session.Set(ISLOGIN, true)

            context.WriteString("账户登录成功 ")

        } else {
            session := sess.Start(context)
            session.Set(ISLOGIN, false)
            context.WriteString("账户登录失败，请重新尝试")
        }
    })

    /**
     * 用户退出登录功能
     */
    app.Get("/logout", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(" 退出登录 Path :", path)
        session := sess.Start(context)
        //删除session
        session.Delete(ISLOGIN)
        session.Delete(USERNAME)
        context.WriteString("退出登录成功")
    })


    app.Get("/query", func(context context.Context) {
        path := context.Path()
        app.Logger().Info(" 查询信息 path :", path)
        session := sess.Start(context)

        isLogin, err := session.GetBoolean(ISLOGIN)
        if err != nil {
            context.WriteString("账户未登录,请先登录 ")
            return
        }

        if isLogin {
            app.Logger().Info(" 账户已登录 ")
            context.WriteString("账户已登录")
        } else {
            app.Logger().Info(" 账户未登录 ")
            context.WriteString("账户未登录")
        }

    })


    //2、session和db绑定使用
    db, err := boltdb.New("sessions.db", 0600)
    if err != nil {
        panic(err.Error())
    }

    //程序中断时，将数据库关闭
    iris.RegisterOnInterrupt(func() {
        defer db.Close()
    })

    //session和db绑定
    sess.UseDatabase(db)

    app.Run(iris.Addr(":8009"), iris.WithoutServerError(iris.ErrServerClosed))
}

end