Go Restfull Projects API with Gin


Esempio

Gin è una struttura web scritta in Golang. È dotato di un'API di tipo martini con prestazioni molto migliori, fino a 40 volte più veloci. Se hai bisogno di prestazioni e buona produttività, amerai il Gin.


Ci saranno 8 pacchetti + main.go

  1. controllori
  2. nucleo
  3. libs
  4. middleware
  5. pubblico
  6. router
  7. Servizi
  8. test
  9. main.go

struttura dei progetti


controllori

Il pacchetto Controller memorizzerà tutta la logica dell'API. Qualunque sia la tua API, la tua logica accadrà qui

controllori


nucleo

Il pacchetto principale memorizzerà tutti i modelli creati, ORM, ecc

nucleo


libs

Questo pacchetto memorizzerà qualsiasi libreria utilizzata nei progetti. Ma solo per la libreria creata / importata manualmente, che non è disponibile quando si usa go get package_name comandi go get package_name . Potrebbe essere il tuo algoritmo di hashing, il grafico, l'albero ecc.

libs


middleware

Questo pacchetto memorizza tutti i middleware utilizzati nel progetto, potrebbe essere la creazione / validazione di cors, id-dispositivo, auth ecc

middleware


pubblico

Questo pacakge memorizzerà tutti i file pubblici e statici, potrebbe essere html, css, javascript, immagini, ecc

pubblico

router

Questo pacchetto memorizzerà tutte le rotte nella tua API REST.

router

Vedi codice di esempio su come assegnare i percorsi.

auth_r.go

import (      
    auth "simple-api/controllers/v1/auth"
    "gopkg.in/gin-gonic/gin.v1"    
)

func SetAuthRoutes(router *gin.RouterGroup) {

/**
 * @api {post} /v1/auth/login Login
 * @apiGroup Users
 * @apiHeader {application/json} Content-Type Accept application/json
 * @apiParam {String} username User username
 * @apiParam {String} password User Password
 * @apiParamExample {json} Input
 *    {
 *      "username": "your username",
 *        "password"     : "your password"        
 *    }
 * @apiSuccess {Object} authenticate Response
 * @apiSuccess {Boolean} authenticate.success Status
 * @apiSuccess {Integer} authenticate.statuscode Status Code
 * @apiSuccess {String} authenticate.message Authenticate Message
 * @apiSuccess {String} authenticate.token Your JSON Token
 * @apiSuccessExample {json} Success
 *    {
 *        "authenticate": {     
 *               "statuscode": 200,
 *              "success": true,
 *           "message": "Login Successfully",
 *              "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ"
 *            }
 *      }
 * @apiErrorExample {json} List error
 *    HTTP/1.1 500 Internal Server Error
 */

    router.POST("/auth/login" , auth.Login)
}

Se vedi, il motivo per cui separo il gestore è, per facilitare noi a gestire ogni router. Quindi posso creare commenti sull'API, che con apidoc lo genererà in una documentazione strutturata. Quindi chiamerò la funzione in index.go nel pacchetto corrente

index.go

package v1


import (
    "gopkg.in/gin-gonic/gin.v1"
    token "simple-api/middlewares/token"
    appid "simple-api/middlewares/appid"
)
func InitRoutes(g *gin.RouterGroup)  {
    g.Use(appid.AppIDMiddleWare())
    SetHelloRoutes(g)
    SetAuthRoutes(g) // SetAuthRoutes invoked 
    g.Use(token.TokenAuthMiddleWare())  //secure the API From this line to bottom with JSON Auth
    g.Use(appid.ValidateAppIDMiddleWare())
    SetTaskRoutes(g)
    SetUserRoutes(g)
}

Servizi

Questo pacchetto memorizzerà qualsiasi configurazione e impostazione da utilizzare nel progetto da qualsiasi servizio utilizzato, potrebbe essere mongodb, redis, mysql, elasticsearch, ecc.

Servizi


main.go

L'ingresso principale dell'API. Qui verrà configurata qualsiasi configurazione relativa alle impostazioni dell'ambiente, ai sistemi, alla porta, ecc.

Esempio:
main.go

package main
import (
    "fmt"
    "net/http"
    "gopkg.in/gin-gonic/gin.v1"
    "articles/services/mysql"
    "articles/routers/v1"
    "articles/core/models"
)

var router  *gin.Engine;

func init() {
    mysql.CheckDB()
    router = gin.New();
    router.NoRoute(noRouteHandler())
    version1:=router.Group("/v1")
    v1.InitRoutes(version1)

}

func main() {
    fmt.Println("Server Running on Port: ", 9090)
    http.ListenAndServe(":9090",router)
}   

func noRouteHandler() gin.HandlerFunc{
    return  func(c *gin.Context) {
    var statuscode     int
    var message        string         = "Not Found"
    var data         interface{} = nil
    var listError [] models.ErrorModel = nil
    var endpoint    string = c.Request.URL.String()
    var method        string = c.Request.Method

    var tempEr models.ErrorModel
    tempEr.ErrorCode     = 4041    
    tempEr.Hints         = "Not Found !! \n Routes In Valid. You enter on invalid Page/Endpoint"
    tempEr.Info            = "visit http://localhost:9090/v1/docs to see the available routes"
    listError             = append(listError,tempEr)
    statuscode             = 404
    responseModel := &models.ResponseModel{
        statuscode,
        message,
        data,
        listError,
        endpoint,
        method,
    } 
    var content gin.H = responseModel.NewResponse();   
    c.JSON(statuscode,content)
    }
}

ps: ogni codice in questo esempio proviene da diversi progetti


vedi esempi di progetti su github