在Golang中如何在其他包文件中使用struct？

我是刚来戈朗的新手，需要一些帮助

正如您在下面的代码中所看到的，我正在尝试在Golang中创建RESTAPI。我使用

mux

（Gorilla mux）和

pq

（PostgreSQL驱动程序）作为第三方库。我不想使用ORM

在

application.go

文件中，我有

InitializeRoutes

函数，其中包含所有可用路线的列表<代码>获取因素函数处理其中一条路径。我试图在另一个名为

factors.go

的文件中定义

GetFactors

函数逻辑。内部

factors.go

文件我想使用

Application

struct，它是在

Application.go

中定义的。如何正确制作？现在你可以看到，它们在不同的包中。这就是为什么

factors.go

文件看不到

应用程序

结构

项目结构：

main.go
application.go
controllers
    factors.go

package main

import (
    "database/sql"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "rest-api/configurations"
)

type Application struct {
    Router *mux.Router
    Database *sql.DB
}

func (application *Application) Initialization() {
    var err error
    application.Database, err = configurations.DatabaseConnection()
    if err != nil {
        log.Fatal(err)
    }

    application.Router = mux.NewRouter()
    application.Router.StrictSlash(true)

    application.InitializeRoutes()
}

func (application *Application) Run(address string) {
    log.Fatal(http.ListenAndServe(address, application.Router))
}

func (application *Application) InitializeRoutes() {
    application.Router.HandleFunc("/api/factors", application.GetFactors).Methods("GET")
    // other code
}

package controllers

import (
    "net/http"
)

func (application *Application) GetFactors(rw http.ResponseWriter, request *http.Request) {
    // code
}

import (
    "your_project_name/routes"
)

func main()  {
    // code
    router := mux.NewRouter()
    routes.Use(router)
    // code
}

package routes

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

func Use(router *mux.Router) {
    router.HandleFunc("/api/factors", controllers.GetFactors).Methods("GET")
}

package controllers

var GetFactors = func(res http.ResponseWriter, req *http.Request) {
    // code
}

main.go:

package main

func main()  {
    application := Application{}
    application.Initialization()
    application.Run("localhost:8000")
}

应用程序。转到：

main.go
application.go
controllers
    factors.go

package main

import (
    "database/sql"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "rest-api/configurations"
)

type Application struct {
    Router *mux.Router
    Database *sql.DB
}

func (application *Application) Initialization() {
    var err error
    application.Database, err = configurations.DatabaseConnection()
    if err != nil {
        log.Fatal(err)
    }

    application.Router = mux.NewRouter()
    application.Router.StrictSlash(true)

    application.InitializeRoutes()
}

func (application *Application) Run(address string) {
    log.Fatal(http.ListenAndServe(address, application.Router))
}

func (application *Application) InitializeRoutes() {
    application.Router.HandleFunc("/api/factors", application.GetFactors).Methods("GET")
    // other code
}

package controllers

import (
    "net/http"
)

func (application *Application) GetFactors(rw http.ResponseWriter, request *http.Request) {
    // code
}

import (
    "your_project_name/routes"
)

func main()  {
    // code
    router := mux.NewRouter()
    routes.Use(router)
    // code
}

package routes

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

func Use(router *mux.Router) {
    router.HandleFunc("/api/factors", controllers.GetFactors).Methods("GET")
}

package controllers

var GetFactors = func(res http.ResponseWriter, req *http.Request) {
    // code
}

控制器/因素。转到：

main.go
application.go
controllers
    factors.go

package main

import (
    "database/sql"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "rest-api/configurations"
)

type Application struct {
    Router *mux.Router
    Database *sql.DB
}

func (application *Application) Initialization() {
    var err error
    application.Database, err = configurations.DatabaseConnection()
    if err != nil {
        log.Fatal(err)
    }

    application.Router = mux.NewRouter()
    application.Router.StrictSlash(true)

    application.InitializeRoutes()
}

func (application *Application) Run(address string) {
    log.Fatal(http.ListenAndServe(address, application.Router))
}

func (application *Application) InitializeRoutes() {
    application.Router.HandleFunc("/api/factors", application.GetFactors).Methods("GET")
    // other code
}

package controllers

import (
    "net/http"
)

func (application *Application) GetFactors(rw http.ResponseWriter, request *http.Request) {
    // code
}

import (
    "your_project_name/routes"
)

func main()  {
    // code
    router := mux.NewRouter()
    routes.Use(router)
    // code
}

package routes

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

func Use(router *mux.Router) {
    router.HandleFunc("/api/factors", controllers.GetFactors).Methods("GET")
}

package controllers

var GetFactors = func(res http.ResponseWriter, req *http.Request) {
    // code
}

---

最后，我决定重新设计项目结构

main.go
routes
    routes.go
controllers
    factors.go
models
    factors.go

main.go：

main.go
application.go
controllers
    factors.go

package main

import (
    "database/sql"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "rest-api/configurations"
)

type Application struct {
    Router *mux.Router
    Database *sql.DB
}

func (application *Application) Initialization() {
    var err error
    application.Database, err = configurations.DatabaseConnection()
    if err != nil {
        log.Fatal(err)
    }

    application.Router = mux.NewRouter()
    application.Router.StrictSlash(true)

    application.InitializeRoutes()
}

func (application *Application) Run(address string) {
    log.Fatal(http.ListenAndServe(address, application.Router))
}

func (application *Application) InitializeRoutes() {
    application.Router.HandleFunc("/api/factors", application.GetFactors).Methods("GET")
    // other code
}

package controllers

import (
    "net/http"
)

func (application *Application) GetFactors(rw http.ResponseWriter, request *http.Request) {
    // code
}

import (
    "your_project_name/routes"
)

func main()  {
    // code
    router := mux.NewRouter()
    routes.Use(router)
    // code
}

package routes

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

func Use(router *mux.Router) {
    router.HandleFunc("/api/factors", controllers.GetFactors).Methods("GET")
}

package controllers

var GetFactors = func(res http.ResponseWriter, req *http.Request) {
    // code
}

路线/路线。开始：

main.go
application.go
controllers
    factors.go

package main

import (
    "database/sql"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "rest-api/configurations"
)

type Application struct {
    Router *mux.Router
    Database *sql.DB
}

func (application *Application) Initialization() {
    var err error
    application.Database, err = configurations.DatabaseConnection()
    if err != nil {
        log.Fatal(err)
    }

    application.Router = mux.NewRouter()
    application.Router.StrictSlash(true)

    application.InitializeRoutes()
}

func (application *Application) Run(address string) {
    log.Fatal(http.ListenAndServe(address, application.Router))
}

func (application *Application) InitializeRoutes() {
    application.Router.HandleFunc("/api/factors", application.GetFactors).Methods("GET")
    // other code
}

package controllers

import (
    "net/http"
)

func (application *Application) GetFactors(rw http.ResponseWriter, request *http.Request) {
    // code
}

import (
    "your_project_name/routes"
)

func main()  {
    // code
    router := mux.NewRouter()
    routes.Use(router)
    // code
}

package routes

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

func Use(router *mux.Router) {
    router.HandleFunc("/api/factors", controllers.GetFactors).Methods("GET")
}

package controllers

var GetFactors = func(res http.ResponseWriter, req *http.Request) {
    // code
}

控制器/因素。转到：

main.go
application.go
controllers
    factors.go

package main

import (
    "database/sql"
    "github.com/gorilla/mux"
    "log"
    "net/http"
    "rest-api/configurations"
)

type Application struct {
    Router *mux.Router
    Database *sql.DB
}

func (application *Application) Initialization() {
    var err error
    application.Database, err = configurations.DatabaseConnection()
    if err != nil {
        log.Fatal(err)
    }

    application.Router = mux.NewRouter()
    application.Router.StrictSlash(true)

    application.InitializeRoutes()
}

func (application *Application) Run(address string) {
    log.Fatal(http.ListenAndServe(address, application.Router))
}

func (application *Application) InitializeRoutes() {
    application.Router.HandleFunc("/api/factors", application.GetFactors).Methods("GET")
    // other code
}

package controllers

import (
    "net/http"
)

func (application *Application) GetFactors(rw http.ResponseWriter, request *http.Request) {
    // code
}

import (
    "your_project_name/routes"
)

func main()  {
    // code
    router := mux.NewRouter()
    routes.Use(router)
    // code
}

package routes

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

func Use(router *mux.Router) {
    router.HandleFunc("/api/factors", controllers.GetFactors).Methods("GET")
}

package controllers

var GetFactors = func(res http.ResponseWriter, req *http.Request) {
    // code
}

---

在Go中，不能在一个包中对另一个包中定义的类型声明方法。要能够声明

GetFactors

，您必须将

应用程序

移动到

控制器

包中。Go也不允许循环导入，例如，如果包A导入包B，那么包B无法导入包A，因此，在重构设计时请记住这一点。@mkopriva我认为这里的主要问题是go无法导入包main，

Application

可以放在

main

以外的任何包中，然后导入该包就可以使用它。@nurzhanogerbek

main

包不能被其他包导入。您可以将

应用程序

移动到软件包

控制器

，或创建另一个软件包，例如，

软件包应用程序

。然后您将导入程序包控制器或应用程序，您将在其中使用

应用程序

@NurzhanNogerbek。最好的建议是：从简单开始，不要将解决方案强制置于一些随机概念（如干燥或固体等）下，使其复杂化，直到您了解如何在Go中执行此操作。