我是 Golang 的新手，我已经在 Golang 和 MongoDB 中创建了一个 api。 经过艰苦的努力，成功地将 Controller 和模型包分开，现在我想在一个单独的路由器包中定义路由，并像 Controller ​​和模型一样在主包中访问它们。我正在使用 gorilla/mux 包进行路由。任何人都可以提供帮助拜托，谢谢!
这是我的所有代码:

RESTMONGOMVC/main.go

package main

import (
    "RESTMONGOMVC/controllers"
    "log"
    "net/http"

    "github.com/gorilla/mux"

    "gopkg.in/mgo.v2"
)

var (
    session    *mgo.Session
    collection *mgo.Collection
    err        error
)

func getSession() *mgo.Session {
    // Connect to our local mongo
    s, err := mgo.Dial("mongodb://localhost")

    // Check if connection error, is mongo running?
    if err != nil {
        panic(err)
    }

    // Deliver session
    return s
}
func main() {
    var err error
    r := mux.NewRouter()
    uc := controllers.NewNoteController(getSession())
    r.HandleFunc("/api/notes", uc.GetNotes).Methods("GET")
    r.HandleFunc("/api/notes", uc.CreateNote).Methods("POST")
    r.HandleFunc("/api/notes/{id}", uc.UpdateNote).Methods("PUT")
    r.HandleFunc("/api/notes/{id}", uc.DeleteNote).Methods("DELETE")
    http.Handle("/api/", r)
    http.Handle("/", http.FileServer(http.Dir(".")))
    log.Println("Starting Mongodb Session")
    session, err = mgo.Dial("localhost")
    if err != nil {
        panic(err)
    }
    defer session.Close()
    session.SetMode(mgo.Monotonic, true)
    collection = session.DB("notesdb").C("notes")
    log.Println("Listening on 8080")
    http.ListenAndServe(":8080", nil)
}

Controller /note.go

package controllers

import (
    "RESTMONGOMVC/models"
    "encoding/json"
    "log"
    "net/http"
    "time"

    "github.com/gorilla/mux"

    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

var (
    session    *mgo.Session
    collection *mgo.Collection
    err        error
)

type (
    // UserController represents the controller for operating on the User resource
    NoteController struct {
        session *mgo.Session
    }
)

// NewUserController provides a reference to a UserController with provided mongo session
func NewNoteController(s *mgo.Session) *NoteController {
    return &NoteController{s}
}
func (uc NoteController) GetNotes(w http.ResponseWriter, r *http.Request) {
    var notes []models.Note
    iter := collection.Find(nil).Iter()
    result := models.Note{}
    for iter.Next(&result) {
        notes = append(notes, result)
    }
    w.Header().Set("Content-Type", "application/json")
    j, err := json.Marshal(models.NotesResource{Notes: notes})
    if err != nil {
        panic(err)
    }
    w.Write(j)
}

func (uc NoteController) CreateNote(w http.ResponseWriter, r *http.Request) {
    var noteResource models.NoteResource

    err := json.NewDecoder(r.Body).Decode(&noteResource)
    if err != nil {
        panic(err)
    }
    note := noteResource.Note
    //get a new Id
    obj_id := bson.NewObjectId()
    note.Id = obj_id
    note.CreatedOn = time.Now()
    //Insert into document collection
    err = collection.Insert(&note)
    if err != nil {
        panic(err)
    } else {
        log.Printf("Inserted New Record with Title :%s", note.Title)
    }
    j, err := json.Marshal(models.NoteResource{Note: note})
    if err != nil {
        panic(err)
    }
    w.Header().Set("Content-Type", "application/json")
    w.Write(j)
}

func (uc NoteController) UpdateNote(w http.ResponseWriter, r *http.Request) {
    var err error
    //get id from incoming url
    vars := mux.Vars(r)
    id := bson.ObjectIdHex(vars["id"])
    //decode the incoming Note into json
    var noteResource models.NoteResource
    err = json.NewDecoder(r.Body).Decode(&noteResource)
    if err != nil {
        panic(err)
    }
    //partial update on mongodb
    err = collection.Update(bson.M{"_id": id},
        bson.M{"$set": bson.M{
            "title":      noteResource.Note.Title,
            "decription": noteResource.Note.Description,
        }})
    if err == nil {
        log.Printf("Updated Note : %s", id, noteResource.Note.Title)
    } else {
        panic(err)
    }
    w.WriteHeader(http.StatusNoContent)
}
func (uc NoteController) DeleteNote(w http.ResponseWriter, r *http.Request) {
    var err error
    vars := mux.Vars(r)
    id := vars["id"]
    //Remove from database
    err = collection.Remove(bson.M{"_id": bson.ObjectIdHex(id)})
    if err != nil {
        log.Printf("Could not find the Note %s to delete", id)
    }
    w.WriteHeader(http.StatusNoContent)
}

模型/note.go

package models 
 import ( 
    "time" 
    "gopkg.in/mgo.v2/bson" 
  ) 
 type Note struct { 
    Id          bson.ObjectId `bson:"_id" json:"id"` 
    Title       string        `json:"title"` 
    Description string        `json:"description"` 
    CreatedOn   time.Time     `json:"craetedOn"` 
 } 
 type NoteResource struct { 
    Note Note `json:"note"` 
 } 
 type NotesResource struct { 
    Notes []Note `json:"notes"` 
 } 

最佳答案

我不是编程专家，但这是我管理路由/处理程序的方式。

路线/routes.go

package routes

import (
    "github.com/gorilla/mux"
)

//NewRouter is main routing entry point
func NewRouter() *mux.Router {
    r := mux.NewRouter()

    indexHandler(r)  // Index handler
    fileServer(r) // Fileserver to serve static files
    otherLogicalHandler(r) // Other domain/business logic scoped handler

    return r
}

routes/indexHandler.go

package routes

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/myusername/project/models"
)

func indexHandler(r *mux.Router) {
    r.HandleFunc("/", indexMainHandler).Methods("GET")
    // Other endpoints goes there if you want to list it in this current indexHandler.go file
    // Example: r.HandleFunc("/signup", signupMainHandler).Methods("GET")
}

// Handlers

func indexMainHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html; charset=UTF-8")

    // Call your model/s there
    mydata, err := models.GetMyDataFunction()
    if err != nil {
        // Handle your error there
        return
    }

    utils.ExecuteTemplate(w, "index.html", struct {
        Title                 string
        // Use your model data for templates there
        MyData             []models.MyData
        // Other models/data can go there if multiple data objects used per page.
    }{
        Title: "Main Page",
        MyData:             mydata,
    })
}

// func signupMainHandler(w http.ResponseWriter, r *http.Request) ...
// Basically repeat the same logic as in indexMainHandler function

routes/fileServer.go

package routes

import (
    "net/http"

    "github.com/gorilla/mux"
)

func fileServer(r *mux.Router) {
    fs := http.FileServer(http.Dir("static"))
    r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", fs))
}

routes/otherLogicalHandler.go

...等等。

如你所见，它们都属于包路由，但分为多个文件。文件名实际上并不重要。您可以根据需要命名它们。 模型位于models 目录中，也属于单个package models 包。 每次创建新的路由文件时，记得在 routes.go 文件中调用它。

希望这对某些人有所帮助。

关于mongodb - 在 Golang 和 MongoDB 中将路由拆分为单独的包，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31086315/