Go
Best practices voor projectstructuur

Restfull Projects API met Gin

Gin is een webkader geschreven in Golang. Het beschikt over een martini-achtige API met veel betere prestaties, tot 40 keer sneller. Als je prestaties en een goede productiviteit nodig hebt, zul je dol zijn op Gin.

---

Er zullen 8 pakketten + main.go zijn

1. controllers
2. kern
3. libs
4. middelware
5. openbaar
6. routers
7. Diensten
8. testen
9. main.go

---

controllers

Controllers pakket slaat alle API-logica op. Wat uw API ook is, uw logica zal hier gebeuren

---

kern

In het kernpakket worden al uw gemaakte modellen, ORM, enz. Opgeslagen

---

libs

In dit pakket wordt elke bibliotheek opgeslagen die in projecten wordt gebruikt. Maar alleen voor handmatig gemaakte / geïmporteerde bibliotheek, die niet beschikbaar is bij het gebruik van go get package_name . Zou je eigen hashing-algoritme, grafiek, boom etc. kunnen zijn

---

middelware

Dit pakket slaat elke middleware op die in het project wordt gebruikt, bijvoorbeeld creatie / validatie van cors, device-id, auth enz.

---

openbaar

In deze pacakge worden alle openbare en statische bestanden opgeslagen, zoals HTML, CSS, JavaScript, afbeeldingen, enz

routers

Dit pakket slaat alle routes op in uw REST API.

Zie voorbeeldcode voor het toewijzen van routes.

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)
}

Als u ziet, is de reden dat ik de handler scheid, om ons eenvoudig te maken om elke routers te beheren. Ik kan dus opmerkingen over de API maken, die dit met apidoc in gestructureerde documentatie zullen genereren. Dan zal ik de functie in index.go in het huidige pakket aanroepen

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)
}

---

Diensten

Dit pakket slaat elke configuratie en instelling op die gebruikt wordt in het project vanuit elke gebruikte service, kan mongodb, redis, mysql, elastisch zoeken, etc. zijn

---

main.go

De hoofdingang van de API. Elke configuratie over de dev-omgevingsinstellingen, systemen, poort, enz. Wordt hier geconfigureerd.

Voorbeeld:
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: elke code in dit voorbeeld komt uit verschillende projecten

---

zie voorbeeldprojecten op github