Go
परियोजना संरचना पर सर्वोत्तम अभ्यास

Gin के साथ Restfull प्रोजेक्ट्स API

जिन गोलांग में लिखा गया एक वेब फ्रेमवर्क है। इसमें 40 गुना अधिक तेज प्रदर्शन के साथ एक मार्टिनी जैसी एपीआई की सुविधा है। यदि आपको प्रदर्शन और अच्छी उत्पादकता की आवश्यकता है, तो आप जिन को प्यार करेंगे।

---

8 संकुल + main.go होगा

1. नियंत्रकों
2. कोर
3. libs
4. middlewares
5. जनता
6. रूटर
7. सेवाएं
8. परीक्षण
9. main.go

---

नियंत्रकों

नियंत्रकों पैकेज सभी एपीआई तर्क को संग्रहीत करेगा। आपका एपीआई जो भी हो, आपका तर्क यहाँ होगा

---

कोर

कोर पैकेज आपके सभी बनाए गए मॉडल, ओआरएम, आदि को स्टोर करेगा

---

libs

यह पैकेज परियोजनाओं में इस्तेमाल होने वाले किसी भी पुस्तकालय को संग्रहीत करेगा। लेकिन केवल मैन्युअल रूप से बनाई गई / आयातित लाइब्रेरी के लिए, जो कि go get package_name कमांड go get package_name करते समय उपलब्ध नहीं है। अपने स्वयं के हैशिंग एल्गोरिथ्म, ग्राफ, वृक्ष आदि हो सकते हैं।

---

middlewares

यह पैकेज प्रत्येक मिडलवेयर को स्टोर करता है जो प्रोजेक्ट में उपयोग किया जाता है, यह कॉर्स, डिवाइस-आईडी, नॉलेज आदि का निर्माण / सत्यापन हो सकता है

---

जनता

यह pacakge हर पब्लिक और स्टैटिक फाइल्स को स्टोर करेगा, html, css, जावास्क्रिप्ट, इमेज आदि हो सकता है

रूटर

यह पैकेज आपके REST API में हर रूट को स्टोर करेगा।

मार्गों को असाइन करने के लिए नमूना कोड देखें।

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

यदि आप देखते हैं, तो कारण है कि मैं हैंडलर को अलग करता हूं, हमें प्रत्येक राउटर को प्रबंधित करने में आसान है। इसलिए मैं एपीआई के बारे में टिप्पणी बना सकता हूं, कि एपिडोक के साथ यह संरचित प्रलेखन में उत्पन्न करेगा। तब मैं फ़ंक्शन को मौजूदा पैकेज में index.go में कॉल करूंगा

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

---

सेवाएं

यह पैकेज किसी भी उपयोग की गई सेवा से परियोजना में उपयोग किए जाने वाले किसी भी कॉन्फ़िगरेशन और सेटिंग को संग्रहित करेगा, मोंगोडब, रेडिस, मायस्कल, इलास्टिक्स खोज, आदि हो सकता है।

---

main.go

एपीआई का मुख्य प्रवेश द्वार। देव पर्यावरण सेटिंग्स, सिस्टम, पोर्ट, आदि के बारे में कोई भी विन्यास यहां कॉन्फ़िगर किया जाएगा।

उदाहरण:
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)
    }
}

पीएस: इस उदाहरण में हर कोड, विभिन्न परियोजनाओं से आता है

---

जीथब पर नमूना परियोजनाओं को देखें