8000 GitHub - r8k/gin: 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. · GitHub
[go: up one dir, main page]

Skip to content
  • r8kPublic
    forked from gin-gonic/gin

    About

    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.

    Resources

    Stars

    0 stars

    Watchers

    0 watching

    Forks

     
     

    Latest commit

     

    History

    17 Commits

    Folders and files

    Repository files navigation

    #Gin Web Framework 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.
    Check out the official web site

    Start using it

    Run:

    go get github.com/gin-gonic/gin
    

    Then import it in your Golang code:

    import "github.com/gin-gonic/gin"
    

    ##API Examples

    Create most basic PING/PONG HTTP endpoint

    import "github.com/gin-gonic/gin"
    
    func main() {
        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")
    }

    Using GET, POST, PUT, PATCH and DELETE

    func main() {
        // Creates a gin router + logger and recovery (crash-free) middlewares
        r := gin.Default()
        
        r.GET("/someGet", getting)
        r.POST("/somePost", posting)
        r.PUT("/somePut", putting)
        r.DELETE("/someDelete", deleting)
        r.PATCH("/somePatch", patching)
    
        // Listen and server on 0.0.0.0:8080
        r.Run(":8080")
    }

    Parameters in path

    func main() {
        r := gin.Default()
        
        r.GET("/user/:name", func(c *gin.Context) {
            name := c.Params.ByName("name")
            message := "Hello "+name
            c.String(200, message)
        })
    }

    Grouping routes

    func main() {
        r := gin.Default()
        
        // 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")
    }

    Blank Gin without middlewares by default

    Use

    r := gin.New()

    instead of

    r := gin.Default()

    Using middlewares

    func main() {
        // 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")
    }

    JSON parsing and validation

    type LoginJSON struct {
        User     string `json:"user" binding:"required"`
        Password string `json:"password" binding:"required"`
    }
    
    func main() {
        r := gin.Default()
        
        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"})
                }
            }
        })
    }

    XML, and JSON rendering

    func main() {
        r := gin.Default()
        
        // 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 {
                Message string
                Status  int
            }
            msg.Message = "hey"
            msg.Status = 200
            c.JSON(200, msg.Status)
        })
        
        r.GET("/someXML", func(c *gin.Context) {
            c.XML(200, gin.H{"message": "hey", "status": 200})
        })
    }

    ####HTML rendering

    Using LoadHTMLTemplates()

    func main() {
        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)
        })
    }

    You can also use your own html template render

    import "html/template"
    func main() {
        r := gin.Default()
        html := template.ParseFiles("file1", "file2")
        r.HTMLTemplates = html
    }

    Custom Middlewares

    func Logger() gin.HandlerFunc {
        return func(c *gin.Context) {
            t : time.Now()
            
            // Set example variable
            c.Set("example", "12345")
            
            // before request
            
            c.Next()
            
            // after request
            latency := time.Since(t)
            log.Print(latency)
        }
    }
    
    func main() {
        r := gin.New()
        r.Use(Logger())
        
        r.GET("test", func(c *gin.Context){
            example := r.Get("example").(string)
            
            // it would print: "12345"
            log.Println(example)
        })
    }

    Custom HTTP configuration

    Use http.ListenAndServe() directly, like this:

    func main() {
        router := gin.Default()
        http.ListenAndServe(":8080", router)
    }

    or

    func main() {
        router := gin.Default()
    
        s := &http.Server{
    	    Addr:           ":8080",
    	    Handler:        router,
    	    ReadTimeout:    10 * time.Second,
    	    WriteTimeout:   10 * time.Second,
    	    MaxHeaderBytes: 1 << 20,
        }
        s.ListenAndServe()
    }

    About

    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.

    Resources

    Stars

    0 stars

    Watchers

    0 watching

    Forks

    Releases

    Packages

    Contributors

    Languages

    0