go语言iris框架完整源码包

# Routing ## Handlers A Handler, as the name implies, handle requests. ```go // A Handler responds to an HTTP request. // It writes reply headers and data to the // Context.ResponseWriter() and then return. // Returning signals that the request is finished; // it is not valid to use the Context after or // concurrently with the completion of the Handler call. // // Depending on the HTTP client software, HTTP protocol version, // and any intermediaries between the client and the iris server, // it may not be possible to read from the // Context.Request().Body after writing to the context.ResponseWriter(). // Cautious handlers should read the Context.Request().Body first, and then reply. // // Except for reading the body, handlers should not modify the provided Context. // // If Handler panics, the server (the caller of Handler) assumes that // the effect of the panic was isolated to the active request. // It recovers the panic, logs a stack trace to the server error log // and hangs up the connection. type Handler func(Context) ``` Once the handler is registered, we can use the returned [`Route`](https://godoc.org/github.com/kataras/iris/core/router#Route) instance to give a name to the handler registration for easier lookup in code or in templates. For more information, checkout the [Routing and reverse lookups](routing_reverse.md) section. ## API All HTTP methods are supported, developers can also register handlers for same paths for different methods. The first parameter is the HTTP Method, second parameter is the request path of the route, third variadic parameter should contains one or more iris.Handler executed by the registered order when a user requests for that specific resouce path from the server. Example code: ```go app := iris.New() app.Handle("GET", "/contact", func(ctx iris.Context) { ctx.HTML("<h1> Hello from /contact </h1>") }) ``` In order to make things easier for the end-developer, iris provides functions for all HTTP Methods. The first parameter is the request path of the route, second variadic parameter should contains one or more iris.Handler executed by the registered order when a user requests for that specific resouce path from the server. Example code: ```go app := iris.New() // Method: "GET" app.Get("/", handler) // Method: "POST" app.Post("/", handler) // Method: "PUT" app.Put("/", handler) // Method: "DELETE" app.Delete("/", handler) // Method: "OPTIONS" app.Options("/", handler) // Method: "TRACE" app.Trace("/", handler) // Method: "CONNECT" app.Connect("/", handler) // Method: "HEAD" app.Head("/", handler) // Method: "PATCH" app.Patch("/", handler) // register the route for all HTTP Methods app.Any("/", handler) func handler(ctx iris.Context){ ctx.Writef("Hello from method: %s and path: %s", ctx.Method(), ctx.Path()) } ``` ## Grouping Routes A set of routes that are being groupped by path prefix can (optionally) share the same middleware handlers and template layout. A group can have a nested group too. `.Party` is being used to group routes, developers can declare an unlimited number of (nested) groups. Example code: ```go app := iris.New() users := app.Party("/users", myAuthMiddlewareHandler) // http://localhost:8080/users/42/profile users.Get("/{id:uint64}/profile", userProfileHandler) // http://localhost:8080/users/messages/1 users.Get("/inbox/{id:uint64}", userMessageHandler) ``` The same could be also written using a function which accepts the child router(the Party). ```go app := iris.New() app.PartyFunc("/users", func(users iris.Party) { users.Use(myAuthMiddlewareHandler) // http://localhost:8080/users/42/profile users.Get("/{id:uint64}/profile", userProfileHandler) // http://localhost:8080/users/messages/1 users.Get("/inbox/{id:uint64}", userMessageHandler) }) ``` > `id:uint` is a (typed) dynamic path parameter, learn more by scrolling down. # Dynamic Path Parameters Iris has the easiest and the most powerful routing process you have ever meet. At the same time, Iris has its own interpeter(yes like a programming language) for route's path syntax and their dynamic path parameters parsing and evaluation. We call them "macros" for shortcut. How? It calculates its needs and if not any special regexp needed then it just registers the route with the low-level path syntax, otherwise it pre-compiles the regexp and adds the necessary middleware(s). That means that you have zero performance cost compared to other routers or web frameworks. Standard macro types for route path parameters ```sh +------------------------+ | {param:string} | +------------------------+ string type anything (single path segmnent) +-------------------------------+ | {param:int} | +-------------------------------+ int type -9223372036854775808 to 9223372036854775807 (x64) or -2147483648 to 2147483647 (x32), depends on the host arch +------------------------+ | {param:int8} | +------------------------+ int8 type -128 to 127 +------------------------+ | {param:int16} | +------------------------+ int16 type -32768 to 32767 +------------------------+ | {param:int32} | +------------------------+ int32 type -2147483648 to 2147483647 +------------------------+ | {param:int64} | +------------------------+ int64 type -9223372036854775808 to 9223372036854775807 +------------------------+ | {param:uint} | +------------------------+ uint type 0 to 18446744073709551615 (x64) or 0 to 4294967295 (x32) +------------------------+ | {param:uint8} | +------------------------+ uint8 type 0 to 255 +------------------------+ | {param:uint16} | +------------------------+ uint16 type 0 to 65535 +------------------------+ | {param:uint32} | +------------------------+ uint32 type 0 to 4294967295 +------------------------+ | {param:uint64} | +------------------------+ uint64 type 0 to 18446744073709551615 +---------------------------------+ | {param:bool} or {param:boolean} | +---------------------------------+ bool type only "1" or "t" or "T" or "TRUE" or "true" or "True" or "0" or "f" or "F" or "FALSE" or "false" or "False" +------------------------+ | {param:alphabetical} | +------------------------+ alphabetical/letter type letters only (upper or lowercase) +------------------------+ | {param:file} | +------------------------+ file type letters (upper or lowercase) numbers (0-9) underscore (_) dash (-) point (.) no spaces ! or other character +------------------------+ | {param:path} | +------------------------+ path type anything, should be the last part, can be more than one path segment, i.e: "/test/*param" and request: "/test/path1/path2/path3" , ctx.Params().Get("param") == "path1/path2/path3" ``` If type is missing then parameter's type is defaulted to string, so `{param} == {param:string}`. If a function not found on that type then the `string` macro type's functions are being used. Besides the fact that iris provides the basic types and some default "macro funcs" you are able to register your own too!. Register a named path parameter function ```go app.Macros().Get("int").RegisterFunc("min", func(argument int) func(paramValue int) bool { // [...] return func(paramValue int) bool { // -> true means valid, false means invalid fire 404 // or if "else 500" is appended to the macro syntax then internal server error. return true } }) ``` At the `func(argument ...)` you can have any standard type, it will be validated before the server starts so don't care about any performance cost there, the only thing it runs at serve time is the returning `func(paramValue <T>) bool`. ```go {param:string equal(iris)} ``` The "iris" will be the argument here: ```go app.Macros().Get("string").RegisterFunc("equal", func(argument string) func(paramValue string) bool { return func(paramValue string){ return argument == paramVa