gin/README.md

439 lines
9.5 KiB
Markdown
Raw Normal View History

2014-06-17 23:42:34 +00:00
#Gin Web Framework
2014-07-02 12:36:23 +00:00
2014-07-02 12:38:01 +00:00
[![GoDoc](https://godoc.org/github.com/gin-gonic/gin?status.png)](https://godoc.org/github.com/gin-gonic/gin)
2014-07-03 15:29:44 +00:00
[![Build Status](https://travis-ci.org/gin-gonic/gin.svg)](https://travis-ci.org/gin-gonic/gin)
2014-07-02 12:36:23 +00:00
2014-06-17 23:42:34 +00:00
Gin is a web framework written in Golang. It features a martini-like API with much better performance, up to 40 times faster. If you need performance and good productivity, you will love Gin.
2014-07-04 00:55:01 +00:00
![Gin console logger](http://gin-gonic.github.io/gin/other/console.png)
2014-07-02 18:52:47 +00:00
##Gin is new, will it be supported?
Yes, Gin is an internal project of [my](https://github.com/manucorporat) upcoming startup. We developed it and we are going to continue using and improve it.
2014-07-18 13:22:38 +00:00
##Roadmap for v1.0
2014-07-05 17:27:33 +00:00
- [x] Performance improments, reduce allocation and garbage collection overhead
2014-07-06 16:57:58 +00:00
- [x] Fix bugs
2014-07-18 13:22:38 +00:00
- [ ] Stable API
2014-07-05 17:27:33 +00:00
- [ ] Ask our designer for a cool logo
2014-07-06 16:57:58 +00:00
- [ ] Add tons of unit tests
- [ ] Add internal benchmarks suite
2014-07-05 17:27:33 +00:00
- [x] Improve logging system
- [x] Improve JSON/XML validation using bindings
2014-07-06 16:57:58 +00:00
- [x] Improve XML support
2014-07-18 13:22:38 +00:00
- [x] Flexible rendering system
- [ ] More powerful validation API
2014-07-05 17:28:45 +00:00
- [ ] Improve documentation
- [ ] Add more cool middlewares, for example redis caching (this also helps developers to understand the framework).
2014-07-05 17:28:45 +00:00
- [x] Continuous integration
2014-07-02 18:52:47 +00:00
2014-06-17 23:42:34 +00:00
## Start using it
Obviously, you need to have Git and Go! already installed to run Gin.
Run this in your terminal
2014-06-17 23:42:34 +00:00
```
go get github.com/gin-gonic/gin
```
Then import it in your Go! code:
2014-06-17 23:42:34 +00:00
```
import "github.com/gin-gonic/gin"
```
2014-07-16 17:00:47 +00:00
##Community
If you'd like to help out with the project, there's a mailing list and IRC channel where Gin discussions normally happen.
* IRC
* [irc.freenode.net #getgin](irc://irc.freenode.net:6667/getgin)
* [Webchat](http://webchat.freenode.net?randomnick=1&channels=%23getgin)
* Mailing List
* Subscribe: [getgin@librelist.org](mailto:getgin@librelist.org)
* [Archives](http://librelist.com/browser/getgin/)
2014-06-17 23:42:34 +00:00
##API Examples
#### Create most basic PING/PONG HTTP endpoint
2014-06-30 01:58:10 +00:00
```go
2014-07-04 17:44:07 +00:00
package main
2014-06-30 01:58:10 +00:00
import "github.com/gin-gonic/gin"
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-30 01:58:10 +00:00
}
```
2014-07-03 14:16:40 +00:00
#### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
2014-06-30 01:58:10 +00:00
```go
func main() {
2014-07-04 17:44:07 +00:00
// Creates a gin router + logger and recovery (crash-free) middlewares
r := gin.Default()
2014-06-17 23:42:34 +00:00
2014-07-04 17:44:07 +00:00
r.GET("/someGet", getting)
r.POST("/somePost", posting)
r.PUT("/somePut", putting)
r.DELETE("/someDelete", deleting)
r.PATCH("/somePatch", patching)
r.HEAD("/someHead", head)
r.OPTIONS("/someOptions", options)
2014-07-04 17:44:07 +00:00
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
#### Parameters in path
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
// This handler will match /user/john but will not match neither /user/ or /user
2014-07-04 17:44:07 +00:00
r.GET("/user/:name", func(c *gin.Context) {
name := c.Params.ByName("name")
message := "Hello "+name
c.String(200, message)
})
// However, this one will match /user/john and also /user/john/send
r.GET("/user/:name/*action", func(c *gin.Context) {
name := c.Params.ByName("name")
action := c.Params.ByName("action")
message := name + " is " + action
2014-07-04 17:44:07 +00:00
c.String(200, message)
})
2014-07-04 17:44:07 +00:00
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
#### Grouping routes
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
2014-06-17 23:42:34 +00:00
2014-07-04 17:44:07 +00:00
// Simple group: v1
v1 := r.Group("/v1")
{
v1.POST("/login", loginEndpoint)
v1.POST("/submit", submitEndpoint)
v1.POST("/read", readEndpoint)
}
// Simple group: v2
v2 := r.Group("/v2")
{
v2.POST("/login", loginEndpoint)
v2.POST("/submit", submitEndpoint)
v2.POST("/read", readEndpoint)
}
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
#### Blank Gin without middlewares by default
Use
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
r := gin.New()
```
instead of
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
r := gin.Default()
```
#### Using middlewares
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
// Creates a router without any middleware by default
r := gin.New()
// Global middlewares
r.Use(gin.Logger())
r.Use(gin.Recovery())
// Per route middlewares, you can add as many as you desire.
r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
// Authorization group
// authorized := r.Group("/", AuthRequired())
// exactly the same than:
authorized := r.Group("/")
// per group middlewares! in this case we use the custom created
// AuthRequired() middleware just in the "authorized" group.
authorized.Use(AuthRequired())
{
authorized.POST("/login", loginEndpoint)
authorized.POST("/submit", submitEndpoint)
authorized.POST("/read", readEndpoint)
// nested group
testing := authorized.Group("testing")
testing.GET("/analytics", analyticsEndpoint)
}
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
#### JSON parsing and validation
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
type LoginJSON struct {
2014-07-04 17:44:07 +00:00
User string `json:"user" binding:"required"`
Password string `json:"password" binding:"required"`
2014-06-17 23:42:34 +00:00
}
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
2014-07-02 06:24:55 +00:00
2014-07-04 17:44:07 +00:00
r.POST("/login", func(c *gin.Context) {
var json LoginJSON
// If EnsureBody returns false, it will write automatically the error
// in the HTTP stream and return a 400 error. If you want custom error
// handling you should use: c.ParseBody(interface{}) error
if c.EnsureBody(&json) {
if json.User == "manu" && json.Password == "123" {
c.JSON(200, gin.H{"status": "you are logged in"})
} else {
c.JSON(401, gin.H{"status": "unauthorized"})
}
}
})
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
#### XML, and JSON rendering
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
2014-07-02 06:24:55 +00:00
2014-07-04 17:44:07 +00:00
// gin.H is a shortcup for map[string]interface{}
r.GET("/someJSON", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "hey", "status": 200})
})
r.GET("/moreJSON", func(c *gin.Context) {
// You also can use a struct
var msg struct {
Name string `json:"user"`
Message string
Number int
}
msg.Name = "Lena"
msg.Message = "hey"
msg.Number = 123
// Note that msg.Name becomes "user" in the JSON
// Will output : {"user": "Lena", "Message": "hey", "Number": 123}
c.JSON(200, msg)
})
r.GET("/someXML", func(c *gin.Context) {
c.XML(200, gin.H{"message": "hey", "status": 200})
})
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
####HTML rendering
Using LoadHTMLTemplates()
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
r.LoadHTMLTemplates("templates/*")
r.GET("/index", func(c *gin.Context) {
obj := gin.H{"title": "Main website"}
c.HTML(200, "index.tmpl", obj)
})
2014-07-02 06:24:55 +00:00
2014-07-04 17:44:07 +00:00
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
You can also use your own html template render
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
import "html/template"
2014-07-04 17:44:07 +00:00
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
r := gin.Default()
html := template.Must(template.ParseFiles("file1", "file2"))
r.HTMLTemplates = html
2014-07-02 06:24:55 +00:00
2014-07-04 17:44:07 +00:00
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-17 23:42:34 +00:00
}
```
#### Custom Middlewares
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func Logger() gin.HandlerFunc {
2014-07-04 17:44:07 +00:00
return func(c *gin.Context) {
t := time.Now()
2014-07-04 17:44:07 +00:00
// Set example variable
c.Set("example", "12345")
2014-07-04 17:44:07 +00:00
// before request
2014-07-04 17:44:07 +00:00
c.Next()
2014-07-04 17:44:07 +00:00
// after request
latency := time.Since(t)
log.Print(latency)
2014-07-03 22:01:28 +00:00
// access the status we are sending
status := c.Writer.Status()
log.Println(status)
2014-07-04 17:44:07 +00:00
}
2014-06-17 23:42:34 +00:00
}
func main() {
2014-07-04 17:44:07 +00:00
r := gin.New()
r.Use(Logger())
2014-07-02 06:24:55 +00:00
2014-07-04 17:44:07 +00:00
r.GET("/test", func(c *gin.Context) {
example := c.MustGet("example").(string)
2014-07-04 17:44:07 +00:00
// it would print: "12345"
log.Println(example)
})
2014-07-02 06:24:55 +00:00
2014-07-04 17:44:07 +00:00
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-30 01:58:10 +00:00
}
2014-06-17 23:42:34 +00:00
```
#### Using BasicAuth() middleware
```go
2014-07-04 02:47:34 +00:00
// similate some private data
var secrets = gin.H{
"foo": gin.H{"email": "foo@bar.com", "phone": "123433"},
"austin": gin.H{"email": "austin@example.com", "phone": "666"},
"lena": gin.H{"email": "lena@guapa.com", "phone": "523443"},
}
func main() {
2014-07-04 02:47:34 +00:00
r := gin.Default()
2014-07-04 02:47:34 +00:00
// Group using gin.BasicAuth() middleware
// gin.Accounts is a shortcut for map[string]string
authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
2014-07-04 02:47:34 +00:00
"foo": "bar",
"austin": "1234",
2014-07-04 02:47:34 +00:00
"lena": "hello2",
"manu": "4321",
}))
// /admin/secrets endpoint
// hit "localhost:8080/admin/secrets
authorized.GET("/secrets", func(c *gin.Context) {
// get user, it was setted by the BasicAuth middleware
2014-07-04 02:47:34 +00:00
user := c.Get(gin.AuthUserKey).(string)
if secret, ok := secrets[user]; ok {
2014-07-04 02:47:34 +00:00
c.JSON(200, gin.H{"user": user, "secret": secret})
} else {
2014-07-04 02:47:34 +00:00
c.JSON(200, gin.H{"user": user, "secret": "NO SECRET :("})
}
2014-07-04 02:47:34 +00:00
})
2014-07-04 02:47:34 +00:00
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
2014-06-30 01:58:10 +00:00
}
2014-06-17 23:42:34 +00:00
```
#### Goroutines inside a middleware
When starting inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy.
2014-06-17 23:42:34 +00:00
```go
func main() {
r := gin.Default()
r.GET("/long_async", func(c *gin.Context) {
// create copy to be used inside the goroutine
c_cp := c.Copy()
go func() {
// simulate a long task with time.Sleep(). 5 seconds
time.Sleep(5 * time.Second)
// note than you are using the copied context "c_cp", IMPORTANT
log.Println("Done! in path " + c_cp.Req.URL.Path)
}()
})
2014-06-17 23:42:34 +00:00
r.GET("/long_sync", func(c *gin.Context) {
// simulate a long task with time.Sleep(). 5 seconds
time.Sleep(5 * time.Second)
// since we are NOT using a goroutine, we do not have to copy the context
log.Println("Done! in path " + c.Req.URL.Path)
})
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
}
```
2014-06-17 23:42:34 +00:00
#### Custom HTTP configuration
2014-06-30 01:58:10 +00:00
Use `http.ListenAndServe()` directly, like this:
2014-06-17 23:42:34 +00:00
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
router := gin.Default()
http.ListenAndServe(":8080", router)
2014-06-17 23:42:34 +00:00
}
```
or
2014-06-30 01:58:10 +00:00
```go
2014-06-17 23:42:34 +00:00
func main() {
2014-07-04 17:44:07 +00:00
router := gin.Default()
s := &http.Server{
Addr: ":8080",
Handler: router,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
MaxHeaderBytes: 1 << 20,
}
s.ListenAndServe()
2014-06-17 23:42:34 +00:00
}
2014-06-30 20:57:25 +00:00
```