README
¶
Shack
Shack is a simple web framework written in Go.
Installation
go get -u github.com/ichxxx/shack
Examples
Quick start
import (
"github.com/ichxxx/shack"
"github.com/ichxxx/shack/middleware"
"github.com/ichxxx/shack/rest"
)
func main() {
r := shack.NewRouter()
r.GET("/example", func(ctx *shack.Context) {
rest.Resp(ctx).OK()
}).With(middleware.Recovery())
shack.Run(":8080", r)
// or
// http.ListenAndServe(":8080", r)
}
Parameters in path
func main() {
r := shack.NewRouter()
r.GET("/example/:id/*path", func(ctx *shack.Context) {
id := ctx.Param("id")
path := ctx.Param("path")
ctx.JSON(shack.M{"id": id, "path": path})
// or
// rest.Resp(ctx).Data("id", id, "path", path).OK()
})
shack.Run(":8080", r)
}
Querystring parameters
type query struct {
Foo int `json:"foo"`
Bar string `json:"bar"`
}
func main() {
r := shack.NewRouter()
r.GET("/example", func(ctx *shack.Context) {
foo := ctx.QueryFlow("foo").Int()
bar := ctx.Query("bar", "defaultBar")
query := &query{}
ctx.RawQueryFlow().Bind(query, "json")
rest.Resp(ctx).Data(
"foo", foo,
"bar", bar,
"query", query,
)).OK()
})
shack.Run(":8080", r)
}
Json Body
type query struct {
Foo int `json:"foo"`
Bar string `json:"bar"`
}
func main() {
r := shack.NewRouter()
r.GET("/example", func(ctx *shack.Context) {
query := &query{}
ctx.BodyFlow().BindJson(query)
rest.Resp(ctx).Data(
"query", query,
).OK()
})
shack.Run(":8080", r)
}
Multipart/Urlencoded Form
type forms struct {
Code int `json:"code"`
Msg string `json:"msg"`
Data map[string]string `json:"data"`
}
func main() {
r := shack.NewRouter()
r.POST("/example", func(ctx *shack.Context) {
data := ctx.Form("data")
forms := &forms{}
ctx.FormsFlow().Bind(forms, "json")
rest.Resp(ctx).Data(
"data", data,
"forms", forms,
).OK()
})
shack.Run(":8080", r)
}
Router group and middleware
func main() {
r := shack.NewRouter()
r.Use(forAll)
r.GET("/example", exampleHandler).With(middleware.AccessLog())
r.Group("/api", func(r *shack.Router) {
r.Use(onlyForApi)
r.Handle("/article", articleHandler)
r.Add(func(r *shack.Router) {
r.Handle("/user", userHandler, http.MethodGet, http.MethodPost)
})
})
shack.Run(":8080", r)
}
Mount router
func main() {
r := shack.NewRouter()
r.Mount("/api", apiRouter())
shack.Run(":8080", r)
}
func apiRouter() *shack.Router {
return shack.NewRouter()
}
Logger
func main() {
shack.Logger("example").
Level(shack.ErrorLevel).
Encoding("json").
Output("./logs").
Enable()
shack.Log.Error("some error",
"timestamp", time.Now().Unix(),
)
}
Config
Shack has a simple toml config parser built in.
You can use it as follows:
# test_config.toml
[test]
name = "shack"
port = 8080
foo_bar = ["1", "2"]
var TestConfig = &struct{
// To use automatic parsing,
// you have to combine shack.BaseConfig
// in a struct.
shack.BaseConfig
Name string
Port string
FooBar []int `config:"foo_bar"`
}
func init() {
// The second args `test` is the section's name in the toml file.
shack.Config.Add(TestConfig, "test")
}
func main() {
shack.Config.File("test_config.toml").Load()
// After that, shack will parse the config automatically.
// You can just use it.
fmt.Println(TestConfig.Name)
fmt.Println(TestConfig.Port)
fmt.Println(TestConfig.FooBar)
}
Documentation
¶
Index ¶
- Variables
- func Run(addr string, router *Router, opts ...Option) error
- func Shutdown(addrs ...string)
- type Context
- type Handler
- type Map
- type Option
- type Request
- func (r *Request) BindJSON(dst interface{}) error
- func (r *Request) BindQuery(dst interface{}, tag ...string) error
- func (r *Request) Body() []byte
- func (r *Request) File(key string) []*multipart.FileHeader
- func (r *Request) Forms(key string) string
- func (r *Request) Header(key string) string
- func (r *Request) JSON(key string) interface{}
- func (r *Request) Method() string
- func (r *Request) Path() string
- func (r *Request) Query(key string, defaultValue ...string) string
- func (r *Request) RawQuery() string
- func (r *Request) URI() string
- type Response
- type Router
- func (r *Router) Add(routeFunc func(r *Router)) *Router
- func (r *Router) DELETE(pattern string, handler Handler) *trie
- func (r *Router) GET(pattern string, handler Handler) *trie
- func (r *Router) Group(pattern string, routeFunc func(r *Router)) *Router
- func (r *Router) HEAD(pattern string, handler Handler) *trie
- func (r *Router) Handle(pattern string, handler Handler) *trie
- func (r *Router) MethodNotAllowed(handler Handler)
- func (r *Router) Mount(pattern string, router *Router)
- func (r *Router) NotFound(handler Handler)
- func (r *Router) OPTIONS(pattern string, handler Handler) *trie
- func (r *Router) PATCH(pattern string, handler Handler) *trie
- func (r *Router) POST(pattern string, handler Handler) *trie
- func (r *Router) PUT(pattern string, handler Handler) *trie
- func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request)
- func (r *Router) Use(middlewares ...Handler)
Constants ¶
This section is empty.
Variables ¶
View Source
var (
MaxMultipartMemory int64 = 8 << 20
)
Functions ¶
Types ¶
type Context ¶
type Context struct {
Request Request
Response Response
PathParams map[string]string
Err error
Bucket map[string]interface{}
// contains filtered or unexported fields
}
func (*Context) Abort ¶
func (c *Context) Abort()
Abort prevents pending handlers from being called.
type Map ¶ added in v0.4.1
type Map map[string]interface{}
Map is a shortcut for map[string]interface{}
type Request ¶ added in v0.4.1
type Response ¶ added in v0.4.1
type Response struct {
http.ResponseWriter
StatusCode int
// contains filtered or unexported fields
}
type Router ¶
type Router struct {
// contains filtered or unexported fields
}
func (*Router) MethodNotAllowed ¶
MethodNotAllowed defines a handler to respond whenever a method is not allowed.
Source Files
¶
Directories
Click to show internal directories.
Click to hide internal directories.