1. package mygin
    3. import (
    4.     "fmt"
    5.     "math"
    6.     "net/http"
    7.     "path"
    8.     "sync"
    9. )
    11. const abortIndex int8 = math.MaxInt8 / 2
    13. type HandlerFun func(ctx *Context)
    15. type IRouter interface {
    16.     Use(...HandlerFun) IRouter
    17.     GET(string, ...HandlerFun) IRouter
    18.     Group(string, ...HandlerFun) *RouterGroup
    19. }
    21. type RouterGroup struct {
    22.     Handlers []HandlerFun
    23.     engine   *Engine
    24.     basePath string
    25. }
    26. type Context struct {
    27.     Request       *http.Request
    28.     ResponseWrite http.ResponseWriter
    29.     engine        *Engine
    30. }
    32. type Engine struct {
    33.     router map[string][]HandlerFun
    34.     pool   sync.Pool
    35.     RouterGroup
    36. }
    38. func NewEngine() *Engine {
    39.     e := &Engine{}
    40.     e.router = make(map[string][]HandlerFun)
    41.     e.pool.New = func() interface{} {
    42.         return e.allocateContext()
    43.     }
    44.     e.RouterGroup = RouterGroup{
    45.         basePath: "/",
    46.         Handlers: nil,
    47.         engine:   e,
    48.     }
    49.     return e
    50. }
    51. func (engine *Engine) allocateContext() *Context {
    52.     return &Context{engine: engine}
    53. }
    54. func (engine *Engine) Run(addr string) error {
    55.     fmt.Println("http start ", addr)
    56.     return http.ListenAndServe(addr, engine)
    57. }
    59. func (engine *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    60.     c := engine.pool.Get().(*Context)
    61.     c.ResponseWrite = w
    62.     c.Request = r
    63.     engine.handleHTTPRequest(c)
    64.     engine.pool.Put(c)
    65. }
    67. func (engine *Engine) handleHTTPRequest(c *Context) {
    68.     method := c.Request.Method
    69.     path := c.Request.URL.Path
    70.     key := engine.handleRequestKey(method, path)
    71.     if handlers, ok := engine.router[key]; ok {
    72.         for _, h := range handlers {
    73.             h(c)
    74.         }
    75.     }
    76. }
    77. func (e *Engine) handleRequestKey(httpMethod, path string) string {
    78.     return fmt.Sprintf("%s-%s", httpMethod, path)
    79. }
    80. func (engine *Engine) addRouter(httpMethod, absolutePath string, handlers []HandlerFun) {
    81.     key := engine.handleRequestKey(httpMethod, absolutePath)
    82.     engine.router[key] = handlers
    83. }
    85. func (g *RouterGroup) Group(path string, handlers ...HandlerFun) *RouterGroup {
    86.     rg := &RouterGroup{}
    87.     rg.Handlers = g.CombineHandler(handlers)
    88.     rg.basePath = path
    89.     rg.engine = g.engine
    90.     return rg
    91. }
    93. func (group *RouterGroup) Use(handlers ...HandlerFun) IRouter {
    94.     group.Handlers = append(group.Handlers, handlers...)
    95.     return group
    96. }
    97. func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
    98.     return joinPaths(group.basePath, relativePath)
    99. }
    101. func joinPaths(absolutePath, relativePath string) string {
    102.     if relativePath == "" {
    103.         return absolutePath
    104.     }
    106.     finalPath := path.Join(absolutePath, relativePath)
    107.     appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
    108.     if appendSlash {
    109.         return finalPath + "/"
    110.     }
    111.     return finalPath
    112. }
    113. func lastChar(str string) uint8 {
    114.     if str == "" {
    115.         panic("The length of the string can't be 0")
    116.     }
    117.     return str[len(str)-1]
    118. }
    120. func (group *RouterGroup) CombineHandler(handlers []HandlerFun) []HandlerFun {
    122.     finalSize := len(group.Handlers) + len(handlers)
    123.     if finalSize >= int(abortIndex) {
    124.         panic("too many handlers")
    125.     }
    126.     mergedHandlers := make([]HandlerFun, finalSize)
    127.     copy(mergedHandlers, group.Handlers)
    128.     copy(mergedHandlers[len(group.Handlers):], handlers)
    129.     return mergedHandlers
    131. }
    132. func (group *RouterGroup) handle(httpMethod, relativePath string, handlers []HandlerFun) IRouter {
    133.     absolutePath := group.calculateAbsolutePath(relativePath)
    134.     handlers = group.CombineHandler(handlers)
    135.     group.engine.addRouter(httpMethod, absolutePath, handlers)
    136.     return group
    137. }
    139. func (g *RouterGroup) GET(path string, handles ...HandlerFun) IRouter {
    140.     g.handle("GET", path, handles)
    141.     return g
    142. }

    测试

    1. func main() {
    2.     r := mygin.NewEngine()
    3.     r.GET("/ping", func(ctx *mygin.Context) {
    4.         ctx.ResponseWrite.Header().Set("content-type","text/json")
    5.         ctx.ResponseWrite.WriteHeader(http.StatusOK)
    6.         r := map[string]interface{}{"code":0,"message":"ok","data":"pong"}
    7.         data,_:= json.Marshal(r)
    8.         ctx.ResponseWrite.Write(data)
    9.     })
    10.     log.Fatal(r.Run(":8888"))
    11. }

    执行测试

    1. curl localhost:8888/ping
    2. {"code":0,"data":"pong","message":"ok"}