找不到我应用程序中的某些功能

学习Golang要努力，但是不要急！今天的这篇文章《找不到我应用程序中的某些功能》将会介绍到等等知识点，如果你想深入学习Golang，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

我是 golang 新手，我一直在尝试创建一个应该存储有关应用程序信息的包。

我的 application 具有以下结构

type application struct {
    environment     environment.applicationenvironment
    vendor          string
    name            string
    version         version.versiondescriptor
    jsonlog         bool
    configuration   *config
    micro           *gomicro
}

我也有这两个方法，我遇到的问题是每当我尝试调用第二个方法时，它都会抛出以下错误

.\main.go:11:17: app.getenvironmentprefix undefined (type *application.application has no field or method getenvironmentprefix)

这是我正在讨论的两种方法：

// get application environment type
func (application *application) getenvironmenttype() environment.environmenttype {
    return application.getenvironmentdetails().type
}

// get application environment prefix
func (application *application) getenvironmentprefix() string {
    str := strings.replace(application.getvendor() + "_" + application.getname(), " ", "_", -1)
    str = strings.replace(str, ".", "_", -1)
    return strings.toupper(str)
}

在实现第二种方法之前我所做的唯一一件事是运行了 go 模块 init。

我尝试删除所有获取的模块，我尝试过 go clean（有很多选项），但是，在 go 模块 init 之后实现的方法都不起作用。

我必须在it中执行go模块，因为否则go-micro会抛出很多错误。

我的环境是：

• 操作系统：windows 10 1909
• go 版本：1.13.4 windows/amd64
• ide：goland（它还管理 gopath，ide 之外无法访问 go）

附注这就是 main.go 的样子

package main

import (
    "fmt"
    "github.com/username_omitted/service/application"
)

func main() {
    app := application.createapplication()
    fmt.println(app.getenvironmenttype()) // works just fine
    fmt.println(app.getenvironmentprefix()) // does not work

}

p.p.s。也许会有帮助，这里是 repository/application/application.go 内 application.go 文件的完整结构

package application

import (
    format "fmt"
    "github.com/USERNAME_OMITTED/service/context"
    "github.com/USERNAME_OMITTED/service/environment"
    "github.com/USERNAME_OMITTED/service/helpers"
    "github.com/USERNAME_OMITTED/service/log"
    "github.com/USERNAME_OMITTED/service/version"
    "github.com/sirupsen/logrus"
    "strings"
)

type Application struct {
    Environment     environment.ApplicationEnvironment
    Vendor          string
    Name            string
    Version         version.VersionDescriptor
    JsonLog         bool
    configuration   *Config
    micro           *GoMicro
}

// Create new application
func CreateApplication() *Application {
    var Vendor string = helpers.GetEnvironmentVariable(
        "APPLICATION_VENDOR",
        "USERNAME_OMITTED",
    )

    var Name string = helpers.GetEnvironmentVariable(
        "APPLICATION_NAME",
        helpers.AppendTimestampToString("New Application"),
    )

    var Version string = helpers.GetEnvironmentVariable(
        "APPLICATION_VERSION",
        "1.0.0.0",
    )

    application := &Application {
        Vendor:         normalizeVendorName(Vendor),
        Name:           normalizeApplicationName(Name),
        Environment:    environment.GetApplicationEnvironment(),
        JsonLog:        false,
    }

    err := application.Version.UnmarshalText([]byte(Version))
    if err != nil {
        application.Version = version.DefaultVersion
    }

    application.initializeLogger()

    context.WithValue("application", application)
    return application
}

// Force application to output log in JSON format
func (application *Application) ForceJsonLog() {
    application.JsonLog = true
    application.initializeLogger()
}

// Get application vendor name
func (application *Application) GetVendor() string {
    return application.Vendor
}

// Get application name
func (application *Application) GetName() string {
    return application.Name
}

// Get application version descriptor
func (application *Application) GetVersionDescriptor() version.VersionDescriptor {
    return application.Version
}

// Get application version represented as string
func (application *Application) GetVersion() string {
    return application.GetVersionDescriptor().String()
}

// Get application environment full details
func (application *Application) GetEnvironmentDetails() environment.ApplicationEnvironment {
    return application.Environment
}

// Get application environment name
func (application *Application) GetEnvironmentName() string {
    return application.GetEnvironmentDetails().Name
}

// Get application environment type
func (application *Application) GetEnvironmentType() environment.EnvironmentType {
    return application.GetEnvironmentDetails().Type
}

// Get application environment prefix
func (application *Application) GetEnvironmentPrefix() string {
    str := strings.Replace(application.GetVendor() + "_" + application.GetName(), "-", "_", -1)
    str = strings.Replace(str, ".", "_", -1)
    return strings.ToUpper(str)
}

// Get service name for the application
func (application *Application) GetServiceName() string {
    return format.Sprintf("%s.%s_%s-%s",
        application.GetVendor(),
        application.GetName(),
        application.GetVersion(),
        strings.ToLower(application.GetEnvironmentName()),
    )
}

// Initialize application configuration
func (application *Application) InitializeConfiguration() error {
    if application.configuration == nil {
        application.configuration = &Config{}
    }
    return application.configuration.Initialize(application)
}

// Initialize application as Go Micro Service
func (application *Application) InitializeGoMicroService() error {
    microService := &GoMicro{}
    err := microService.Initialize(application)
    if err != nil {
        return err
    }
    application.micro = microService
    return nil
}

// Initialize application logger
func (application *Application) initializeLogger() {
    logger := logrus.New()
    var customFields = logrus.Fields{}

    if application.JsonLog || application.Environment.Type == environment.Production {
        logger.SetFormatter(&logrus.JSONFormatter{
            FieldMap: logrus.FieldMap {
                logrus.FieldKeyMsg:     "message",
                logrus.FieldKeyTime:    "timestamp",
            },
        })
        customFields = logrus.Fields{
            "application": logrus.Fields{
                "vendor": application.GetVendor(),
                "name": application.GetName(),
                "version": application.GetVersion(),
                "environment": strings.ToLower(application.GetEnvironmentName()),
            },
            "service": application.GetServiceName(),
        }
    } else {
        logger.SetFormatter(&logrus.TextFormatter{
            FieldMap: logrus.FieldMap{
                logrus.FieldKeyMsg:     "message",
                logrus.FieldKeyTime:    "timestamp",
            },
        })
        customFields = logrus.Fields{
            "service": application.GetServiceName(),
        }
    }

    log.SetLogger(logger.WithFields(customFields))
}


// Normalize Application Vendor Name
func normalizeVendorName(Vendor string) string {
    var newName string = strings.ToLower(Vendor)
    return newName
}

// Normalize Application Name
func normalizeApplicationName(Name string) string {
    var newName string = strings.ToLower(Name)
    newName = strings.ReplaceAll(newName, " ", "-")
    return newName
}

解决方案

在你的 main.go 中，你正在导入：

"github.com/username_omitted/service/application"

但是您提到 repository/application/application.go 是应用程序包所在的位置。听起来您需要将导入语句更改为：

"github.com/USERNAME_OMITTED/application"

本篇关于《找不到我应用程序中的某些功能》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！