「Yogin」更多功能：模板渲染、限流和Session管理

// StaticFile registers a single route in order to serve a single file of the local filesystem.
// router.StaticFile("favicon.ico", "./resources/favicon.ico")
func (group *RouterGroup) StaticFile(relativePath, filepath string) {
    if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
        panic("URL parameters can not be used when serving a static file")
    }
    handler := func(c *Context) {
        c.File(filepath)
    }
    group.GET(relativePath, handler)
    group.HEAD(relativePath, handler)
}

// File writes the specified file into the body stream in an efficient way.
func (c *Context) File(filepath string) {
    http.ServeFile(c.Writer, c.Request, filepath)
}

func FileServer(root FileSystem) Handler {
    return &fileHandler{root}
}

func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
    upath := r.URL.Path
    if !strings.HasPrefix(upath, "/") {
        upath = "/" + upath
        r.URL.Path = upath
    }
    serveFile(w, r, f.root, path.Clean(upath), true)
}

// Static serves files from the given file system root.
// Internally a http.FileServer is used, therefore http.NotFound is used instead
// of the Router's NotFound handler.
// To use the operating system's file system implementation,
// use :
//     router.Static("/static", "/var/www")
func (group *RouterGroup) Static(relativePath, root string) {
    if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
        panic("URL parameters can not be used when serving a static folder")
    }
    handler := group.createStaticHandler(relativePath, http.Dir(root))
    urlPattern := path.Join(relativePath, "/*filepath")

    // Register GET and HEAD handlers
    group.GET(urlPattern, handler)
    group.HEAD(urlPattern, handler)
}

func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc {
    absolutePath := group.calculateAbsolutePath(relativePath)
    fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))

    return func(c *Context) {
        file := c.Param("filepath")
        // Check if file exists and/or if we have permission to access it
        f, err := fs.Open(file)
        if err != nil {
            c.Status(http.StatusNotFound)
            return
        }
        f.Close()

        fileServer.ServeHTTP(c.Writer, c.Request)
    }
}

// Dir returns a http.FileSystem that can be used by http.FileServer(). It is used internally
// in router.Static().
// if listDirectory == true, then it works the same as http.Dir() otherwise it returns
// a filesystem that prevents http.FileServer() to list the directory files.
func Dir(root string, listDirectory bool) http.FileSystem {
    fs := http.Dir(root)
    if listDirectory {
        return fs
    }
    return &onlyFilesFS{fs}
}

type Engine struct {
    // ...
    htmlTemplates *template.Template // for html render
    FuncMap       template.FuncMap   // for html render
}

func (engine *Engine) LoadHTMLGlob(pattern string) {
    engine.htmlTemplates = template.Must(template.New("").Funcs(engine.FuncMap).ParseGlob(pattern))
}

// SetFuncMap sets the FuncMap used for template.FuncMap.
func (engine *Engine) SetFuncMap(funcMap template.FuncMap) {
    engine.FuncMap = funcMap
}

func (c *Context) WithHTML(name string, obj interface{}) *Context {
    writeContentType(c.Writer, htmlContentType)
    var b strings.Builder
    if err := c.engine.htmlTemplates.ExecuteTemplate(&b, name, obj); err != nil {
        panic(err)
    }
    data := []byte(b.String())
    wc, _ := c.Writer.Write(data)
    c.bodySize += wc
    return c
}

// HTML renders the HTTP template specified by its file name.
// It also updates the HTTP code and sets the Content-Type as "text/html".
// See http://golang.org/doc/articles/wiki/
func (c *Context) HTML(code int, name string, obj interface{}) {
    c.Status(code)
    c.WithHTML(name, obj)
}

func MaxAllowed(n int) HandlerFunc {
    sem := make(chan struct{}, n)
    acquire := func() { sem <- struct{}{} }
    release := func() { <-sem }
    return func(c *Context) {
        acquire() // before request
        defer release() // after request
        c.Next()
    }
}

import (
    "github.com/gorilla/sessions"
)

var (
    key = []byte("super-secret-key")
    store = sessions.NewCookieStore(key)
)

const DefaultSessionKey = "session"

func Session(name string) HandlerFunc {
    return func(c *Context) {
        session, _ := store.Get(c.Request, name)
        c.Set(DefaultSessionKey, session)
        c.Next()
    }
}

func Sessions(names []string) HandlerFunc {
    return func(c *Context) {
        sessions := make(map[string]*sessions.Session)
        for _, name := range names {
            session, _ := store.Get(c.Request, name)
            sessions[name] = session
        }
        c.Set(DefaultSessionKey, sessions)
        c.Next()
    }
}

type person struct {
    Name string
    Age  int8
}

var people = [2]person{
    {Name: "Jack", Age: 20},
    {Name: "Rose", Age: 17},
}

func FormatAsDate(t time.Time) string {
    return t.Format("2006-01-02")
}

r := Default()
r.SetFuncMap(template.FuncMap{
    "FormatAsDate": FormatAsDate,
})

r.LoadHTMLGlob("testdata/templates/*")
r.Static("/", "./testdata/assets")
r.StaticFile("/jack_and_rose.jpg", "./testdata/assets/img/jack_and_rose.jpg")

r.GET("/", func(c *Context) {
    c.HTML(http.StatusOK, "hello.tmpl", H{
        "name": "yogin",
        "now": time.Now(),
        "people": people,
    })
})

r.Run(":8080")

r := Default()
r.Use(Session("auth"))

r.GET("/login", func(c *Context) {
    session := c.MustGet(DefaultSessionKey).(*sessions.Session)
    session.Values["authenticated"] = true
    session.Save(c.Request, c.Writer)
    c.String(http.StatusOK, "login success")
})

r.GET("/logout", func(c *Context) {
    session := c.MustGet(DefaultSessionKey).(*sessions.Session)
    session.Values["authenticated"] = false
    session.Save(c.Request, c.Writer)
    c.String(http.StatusOK, "logout success")
})

r.GET("/secret", func(c *Context) {
    session := c.MustGet(DefaultSessionKey).(*sessions.Session)

    if auth, ok := session.Values["authenticated"].(bool); !ok || !auth {
        c.String(http.StatusForbidden, "login first")
        return
    }

    c.String(http.StatusOK, secret)
})