IRIS智能路由使用

目录结构

主目录smartContract

  1.     —— main.go

代码示例

main.go

  1. package main
  3. import (
  4.     "github.com/kataras/iris"
  5.     "fmt"
  6.     "github.com/jmespath/go-jmespath"
  7.     "github.com/kataras/iris/context"
  8.     "github.com/kataras/iris/hero"
  9.     "strings"
  10. )
  11. /*
  12. $ go get github.com/jmespath/go-jmespath
  13. */
  14. func newApp() *iris.Application {
  15.     app := iris.New()
  16.     // PartyFunc 等同于 usersRouter := app.Party("/users")
  17.     //但它为我们提供了一种简单的方法来调用路由组的注册路由方法，
  18.     //即来自另一个可以处理这组路由的包的函数。
  19.     app.PartyFunc("/users", registerUsersRoutes)
  20.     return app
  21. }
  23. func main() {
  24.     app := newApp()
  25.     // http://localhost:8080/users?query=[?Name == 'John Doe'].Age
  26.     // < - 客户端将收到用户的年龄，他的名字是John Doe
  27.     //您还可以测试query = [0] .Name以检索第一个用户的名称。
  28.     //甚至query= [0:3].Age打印前三个年龄段。
  29.     //了解有关jmespath以及如何过滤的更多信息：
  30.     // http://jmespath.readthedocs.io/en/latest/ and
  31.     // https://github.com/jmespath/go-jmespath/tree/master/fuzz/testdata
  32.     // http://localhost:8080/users
  33.     // http://localhost:8080/users/William%20Woe
  34.     // http://localhost:8080/users/William%20Woe/age
  35.     app.Run(iris.Addr(":8080"))
  36. }
  38. /*
  39. 开始使用路由
  40. */
  41. func registerUsersRoutes(usersRouter iris.Party) {
  42.     // GET: /users
  43.     usersRouter.Get("/", getAllUsersHandler)
  44.     usersRouter.PartyFunc("/{name:string}", registerUserRoutes)
  45. }
  47. type user struct {
  48.     Name string `json:"name"`
  49.     Age  int    `json:"age"`
  50. }
  52. var usersSample = []*user{
  53.     {"William Woe", 25},
  54.     {"Mary Moe", 15},
  55.     {"John Doe", 17},
  56. }
  58. func getAllUsersHandler(ctx iris.Context) {
  59.     err := sendJSON(ctx, usersSample)
  60.     if err != nil {
  61.         fail(ctx, iris.StatusInternalServerError, "unable to send a list of all users: %v", err)
  62.         return
  63.     }
  64. }
  66. //开始使用  USERS路由组的子路由组
  67. func registerUserRoutes(userRouter iris.Party) {
  68.     //为此子路由器创建一个新的依赖注入管理器
  69.     userDeps := hero.New()
  70.     //你也可以使用global/package-level的hero.Register(userDependency)，正如我们在其他例子中已经学到的那样。
  71.     userDeps.Register(userDependency)
  72.     // GET: /users/{name:string}
  73.     userRouter.Get("/", userDeps.Handler(getUserHandler))
  74.     // GET: /users/{name:string}/age
  75.     userRouter.Get("/age", userDeps.Handler(getUserAgeHandler))
  76. }
  78. var userDependency = func(ctx iris.Context) *user {
  79.     name := strings.Title(ctx.Params().Get("name"))
  80.     for _, u := range usersSample {
  81.         if u.Name == name {
  82.             return u
  83.         }
  84.     }
  85.     // you may want or no to handle the error here, either way the main route handler
  86.     // is going to be executed, always. A dynamic dependency(per-request) is not a middleware, so things like `ctx.Next()` or `ctx.StopExecution()`
  87.     // do not apply here, look the `getUserHandler`'s first lines; we stop/exit the handler manually
  88.     // if the received user is nil but depending on your app's needs, it is possible to do other things too.
  89.     // A dynamic dependency like this can return more output values, i.e (*user, bool).
  90.     //你可能想要或不想在这里处理错误，无论是主路由处理程序
  91.     //将永远执行。 动态依赖（每个请求）不是中间件，所以像`ctx.Next()`或`ctx.StopExecution()`
  92.     //不要在这里申请，看看`getUserHandler`的第一行; 我们手动停止/退出处理程序
  93.     //如果收到的用户是零，但根据您的应用程序的需要，也可以做其他事情。
  94.     //像这样的动态依赖可以返回更多的输出值，即(*user，bool)。
  95.     fail(ctx, iris.StatusNotFound, "user with name '%s' not found", name)
  96.     return nil
  97. }
  99. func getUserHandler(ctx iris.Context, u *user) {
  100.     if u == nil {
  101.         return
  102.     }
  103.     sendJSON(ctx, u)
  104. }
  106. func getUserAgeHandler(ctx iris.Context, u *user) {
  107.     if u == nil {
  108.         return
  109.     }
  110.     ctx.Writef("%d", u.Age)
  111. }
  113. /*请记住，使用'hero'可以获得类似mvc的函数，所以这也可以工作：
  114. func getUserAgeHandler(u *user) string {
  115.     if u == nil {
  116.         return ""
  117.     }
  118.     return fmt.Sprintf("%d", u.Age)
  119. }
  120. */
  122. /* ENDERS USERS.USER SUB ROUTER */
  123. /* 用户路由器结束 */
  124. //可选择手动HTTP错误的常见JSON响应。
  125. type httpError struct {
  126.     Code   int    `json:"code"`
  127.     Reason string `json:"reason"`
  128. }
  130. func (h httpError) Error() string {
  131.     return fmt.Sprintf("Status Code: %d\nReason: %s", h.Code, h.Reason)
  132. }
  134. func fail(ctx context.Context, statusCode int, format string, a ...interface{}) {
  135.     err := httpError{
  136.         Code:   statusCode,
  137.         Reason: fmt.Sprintf(format, a...),
  138.     }
  139.     //记录所有> = 500内部错误。
  140.     if statusCode >= 500 {
  141.         ctx.Application().Logger().Error(err)
  142.     }
  143.     ctx.StatusCode(statusCode)
  144.     ctx.JSON(err)
  145.     //没有下一个处理程序将运行。
  146.     ctx.StopExecution()
  147. }
  149. // JSON辅助函数，为最终用户提供插入字符或过滤响应的能力，您可以选择这样做。
  150. //如果您想在Iris的Context中看到该函数，则会引发[Feature Request]问题并链接此示例。
  151. func sendJSON(ctx iris.Context, resp interface{}) (err error) {
  152.     indent := ctx.URLParamDefault("indent", "  ")
  153.     // i.e [?Name == 'John Doe'].Age # to output the [age] of a user which his name is "John Doe".
  154.     if query := ctx.URLParam("query"); query != "" && query != "[]" {
  155.         resp, err = jmespath.Search(query, resp)
  156.         if err != nil {
  157.             return
  158.         }
  159.     }
  160.     _, err = ctx.JSON(resp, context.JSON{Indent: indent, UnescapeHTML: true})
  161.     return err
  162. }