Rest golang gin gonic和在包中拆分文件

我是一个新手，正在尝试学习，我正在用一个gin gonic服务器设置一个应用程序。 我设法让它能够处理主包中的所有内容，我希望能够更好地组织它，将所有相关的apirest放在一个包中（由我管理），并将每个组的CRUD按文件分割

因此，在init函数中包的“main”文件中，我定义了：

Router := gin.New()
Router.Use(gin.Logger())
Router.Use(gin.Recovery())

我认为我可以在包的其他文件中这样使用它：

v1 := Router.Group("/api/v1/todos")
v1.Use(AuthRequired())
{
    v1.POST("/", CreateTodo)
    v1.GET("/", FetchAllTodo)
    v1.GET("/:id", FetchSingleTodo)
    v1.PUT("/:id", UpdateTodo)
    v1.DELETE("/:id", DeleteTodo)
}

或

但没有一个有效，我得到：

未定义：路由器中的路由器。组

圣菲 PS：我确实为这个包设置了一个子文件夹，如果它在一个文件中，我可以去构建它

---

我认为解决方案是将Router变量声明为*gin.Engine，但在编译过程中，我在Router.Group调用中遇到了一个紧急错误

让我发布更多的代码：

maincode.go：

package main

import (
    "fmt"
    "./apirest"
    "github.com/braintree/manners"
)

func main(){
    fmt.Printf("hello world.\n")
    //router.Run()
    manners.ListenAndServe(":8080", apirest.Router)
}

然后我将apirest包拆分为两个文件：

apirest.go（我手动清理，maybee我错过了导入）：

然后处理所有声明的todoCRUD.go文件，todoCRUD.go和apirest.go位于同一子文件夹apirest（和compile ok）中：

包apirest
进口(
“fmt”
“github.com/gin gonic/gin”
“gopkg.in/validator.v2”
“github.com/jinju/gorm”
“strconv”
“net/http”
“时间”
)
//待办事项定义和待办事项元素
类型Todo结构{
戈姆模型
时间，时间
时间到了，时间到了
OwnerID int`json:“OwnerID”验证：“非零”`
URL字符串`json:“URL”`
}
//转换后的Dodo版本将在无证书信息的情况下恢复api
类型TransformedTodo结构{
ID uint`json:“ID”`
时间，时间
时间到了，时间到了
OwnerID uint`json:“OwnerID”`
URL字符串`json:'URL`
}
//加载Todo permet de lancer le地图页Todo
func LoadTodo（）{
v1:=路由器组（“/api/v1/todos”）
{
v1.POST（“/”，CreateTodo）
v1.GET（“/”，FetchAllTodo）
v1.GET（“/：id”，FetchSingleTodo）
v1.PUT（“/：id”，UpdateTodo）
v1.删除（“/：id”，删除TODO）
}
}
//创建todo génération d'un todo
func CreateTodo（c*gin.Context）{
所有者：=strconv.Atoi（c.PostForm（“所有者ID”））
待办事项：=待办事项{
OwnerID:owner，
URL:c.PostForm（“URL”），
};
v:=validator.NewValidator（）
如果错误：=v.Validate（todo）；错误！=nil{
错误：=错误。（validator.ErrorMap）
var errOuts[]字符串
对于f，e:=范围误差{
errOuts=append（errOuts，fmt.Sprintf（“\t-%s（%v）\n”，f，e））
}
//c、 JSON（500，gin.H{“Error”：errs.Error（）}）
c、 JSON（500，gin.H{“Erreur sur le（s）champ（s）：”：errOuts}）
}否则{
数据库：=数据库（）
延迟db.Close（）
数据库保存（&todo）
c、 JSON（http.StatusCreated，gin.H{“status”：http.StatusCreated，“message”：“Todo项创建成功！”，“resourceId”：Todo.ID}）
}
}
//为我们的托多做准备
func FetchAllTodo（c*gin.Context）{
var todos[]Todo
变量_todos[]转换为
数据库：=数据库（）
延迟db.Close（）
db.Find（&todos）
如果（len（todos）我确实通过LoadTodo函数中的“发送”路由器使其工作：

在apirest.go中：

LoadTodo(Router)

在todoCRUD.go中：

func LoadTodo(r *gin.Engine){

它工作得很好…我希望我没有在代码中带来错误失败

斯泰芬尼
你能提供你的非工作来源吗？（根据你的解释，一切似乎都正常）
package apirest

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "gopkg.in/validator.v2"
    "github.com/jinzhu/gorm"
    "strconv"
    "net/http"
    "time"
)

//Todo definition d'un element todo
type Todo struct {
    gorm.Model
    CreatedAt   time.Time
    UpdatedAt   time.Time
    OwnerID     int    `json:"ownerid"  validate:"nonzero"`
    URL         string `json:"url"`
}

//TransformedTodo version pour le retour d'api sans certaines infos
type TransformedTodo struct {
    ID          uint   `json:"id"`
    CreatedAt   time.Time
    UpdatedAt   time.Time
    OwnerID     uint   `json:"ownerid"`
    URL         string `json:"url"`   
}

//LoadTodo permet de lancer le mappage todos
func LoadTodo(){
    v1 := Router.Group("/api/v1/todos")
    {
        v1.POST("/", CreateTodo)
        v1.GET("/", FetchAllTodo)
        v1.GET("/:id", FetchSingleTodo)
        v1.PUT("/:id", UpdateTodo)
        v1.DELETE("/:id", DeleteTodo)
    }
}

//CreateTodo génération d'un todo
func CreateTodo(c *gin.Context) {

    owner, _ := strconv.Atoi(c.PostForm("ownerid"))
    todo := Todo{
        OwnerID: owner,
        URL: c.PostForm("url"),
    };
    v := validator.NewValidator()
    if errs := v.Validate(todo); errs!=nil {
        errors := errs.(validator.ErrorMap)
        var errOuts []string
        for f, e := range errors {
            errOuts = append(errOuts, fmt.Sprintf("\t - %s (%v)\n", f, e))
        }
        //c.JSON(500, gin.H{"Error": errs.Error()})
        c.JSON(500, gin.H{"Erreur sur le(s) champ(s) : ": errOuts})
    } else {

        db, _ := Database()
        defer db.Close()
        db.Save(&todo)

        c.JSON(http.StatusCreated, gin.H{"status" : http.StatusCreated, "message" : "Todo item created successfully!", "resourceId": todo.ID})
    }
}

//FetchAllTodo récupération de tous les todos
func FetchAllTodo(c *gin.Context) {
    var todos []Todo
    var _todos []TransformedTodo

    db, _ := Database()
    defer db.Close()
    db.Find(&todos)

    if (len(todos) <= 0) {
        c.JSON(http.StatusNotFound, gin.H{"status" : http.StatusNotFound, "message" : "No todo found!"})
        return
    }

    //transforms the todos for building a good response,
    //je peux choisir des champs a ne pas display
    for _, item := range todos {
        status := false
        if (item.Status == 1) {
            status = true
        } else {
            status = false
        }
        _todos = append(_todos, TransformedTodo{ID: item.ID, URL:item.URL})
    }
    c.JSON(http.StatusOK, gin.H{"status" : http.StatusOK, "data" : _todos})
}

//FetchSingleTodo Récupération d'un seul todo en fonction de son id
func FetchSingleTodo(c *gin.Context) {
    var todo Todo
    todoID := c.Param("id")

    db, _ := Database()
    defer db.Close()
    db.First(&todo, todoID)

    if (todo.ID == 0) {
        c.JSON(http.StatusNotFound, gin.H{"status" : http.StatusNotFound, "message" : "No todo found!"})
        return
    }

    _todo := TransformedTodo{ID: todo.ID, URL:todo.URL}
    c.JSON(http.StatusOK, gin.H{"status" : http.StatusOK, "data" : _todo})
}

//UpdateTodo Mise à jour d'un todo
func UpdateTodo(c *gin.Context) {
    var todo Todo
    todoID := c.Param("id")
    db, _ := Database()
    defer db.Close()
    db.First(&todo, todoID)

    if (todo.ID == 0) {
        c.JSON(http.StatusNotFound, gin.H{"status" : http.StatusNotFound, "message" : "No todo found!"})
        return
    }

    db.Model(&todo).Update("title", c.PostForm("title"))
    db.Model(&todo).Update("completed", c.PostForm("completed"))
    c.JSON(http.StatusOK, gin.H{"status" : http.StatusOK, "message" : "Todo updated successfully!"})
}


//DeleteTodo Suppression d'un todo
func DeleteTodo(c *gin.Context) {
    var todo Todo
    todoID := c.Param("id")
    db, _ := Database()
    defer db.Close()
    db.First(&todo, todoID)

    if (todo.ID == 0) {
        c.JSON(http.StatusNotFound, gin.H{"status" : http.StatusNotFound, "message" : "No todo found!"})
        return
    }

    db.Delete(&todo)
    c.JSON(http.StatusOK, gin.H{"status" : http.StatusOK, "message" : "Todo deleted successfully!"})
}

LoadTodo(Router)

func LoadTodo(r *gin.Engine){