问题[go](coding)

我喜欢 Redis 流，因为它可以充当物联网数据库。向流中添加数据的主要 Redis 命令是 XADD：

XADD log * name Some_name_to_write text Some_text_to_write

它运行良好。

然后我尝试使用Redigo执行相同的操作：

type LogEntry struct {
    Name string `json:"name"`
    Text string `json:"text"`
}

func (l *LogEntry) Push() error {
    var args []string // XADD arguments

    log.Printf("Log Entry: %+v\n", l)
    args = make([]string, 6)
    args = append(args, "log") // Stream key
    args = append(args, "*")   // Auto-generated stream ID
    args = append(args, "name", l.Name)
    args = append(args, "text", l.Text)
    log.Printf("Args for XADD: %+v\n", args)

    new := make([]any, len(args))
    for index, value := range args {
        new[index] = value
    }

    _, err := connection.Do("XADD", new...)
    if err != nil {
        log.Println("XADD error", err)
        return err
    }

    return nil
}

connection这里是redis.Conn。

此代码产生以下输出：

2025-04-08 16:03:08 2025/04/08 13:03:08 Log Entry: &{Name:Some_name_to_write Text:Some_text_to_write}
2025-04-08 16:03:08 2025/04/08 13:03:08 Args for XADD: [      log * name Some_name_to_write text Some_text_to_write]
2025-04-08 16:03:08 2025/04/08 13:03:08 XADD error ERR Invalid stream ID specified as stream command argument

因此，我看到的参数与conn.Do我之前在 CLI 中使用的完全相同。

这里出了什么问题？

我正在学习《Go 编程语言》这本书，当它介绍字符串时，它说 Go 使用 utf-8 编码系统，因此很容易检查一个字符串是否是另一个基本字符串的前缀/后缀。使用以下函数：

func HasPrefix(s, prefix string) bool {
    return len(s) >= len(prefix) && s[:len(prefix)] == prefix
}

func HasSuffix(s, suffix string) bool {
    return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}

我想知道当使用上述函数检查前缀/后缀时，是否存在任何编码系统会失败？

我尝试了许多不同的方法将我的桌子扩展到剩余的可用应用程序空间。

重现我的问题的简单方法是：

package main

import (
    "fmt"
    "strconv"
    "time"

    "fyne.io/fyne/v2"
    "fyne.io/fyne/v2/app"
    "fyne.io/fyne/v2/container"
    "fyne.io/fyne/v2/dialog"
    "fyne.io/fyne/v2/theme"
    "fyne.io/fyne/v2/widget"
)

type Reminders struct {
    ID        int64
    EventName string
    EventDay  time.Time
}

func getReminderSlice() [][]any {
    var slice [][]any

    reminders := []Reminders{{ID: 0, EventName: "First Event Name", EventDay: time.Now()},
        {ID: 1, EventName: "Second Name", EventDay: time.Now()}}

    slice = append(slice, []any{
        "ID",
        "Event Name",
        "Event Day",
        // "Start At",
        // "End At",
        // "Event Duration",
        // "Event Place",
        // "Priority",
        // "Description",
        "Delete?",
    })

    for _, r := range reminders {
        var currentRow []any

        currentRow = append(currentRow, strconv.FormatInt(r.ID, 10))
        currentRow = append(currentRow, r.EventName)
        currentRow = append(currentRow, r.EventDay.Format("2006-01-02"))
        // currentRow = append(currentRow, r.EventStartHour.Format("15:04"))
        // currentRow = append(currentRow, r.EventEndHour.Format("15:04"))
        // currentRow = append(currentRow, strconv.FormatFloat(r.EventDuration, 'f', -1, 64))
        // currentRow = append(currentRow, r.EventPlace)
        // currentRow = append(currentRow, strconv.Itoa(int(r.Priority)))
        // currentRow = append(currentRow, r.Description)
        // currentRow = append(currentRow, widget.NewButton("Delete", func() {}))

        slice = append(slice, currentRow)
    }
    return slice
}

func main() {
    data := getReminderSlice()

    myApp := app.New()
    myWindow := myApp.NewWindow("Table Widget")
    myWindow.Resize(fyne.NewSize(850, 530))

    // Create a table
    list := widget.NewTable(
        func() (int, int) {
            return len(data), len(data[0])
        },
        func() fyne.CanvasObject {
            container := container.NewVBox(widget.NewLabel(""))
            return container
        },
        func(i widget.TableCellID, o fyne.CanvasObject) {
            if i.Col == (len(data[0])-1) && i.Row != 0 {
                // last cell, put in a button
                w := widget.NewButtonWithIcon("Delete", theme.DeleteIcon(),
                    func() {
                        dialog.ShowConfirm("Delete?", "This will delete Event",
                            func(delete bool) {
                                if delete {
                                    fmt.Println("Deleted")

                                }
                                // refresh the reminders table
                                // refreshRemindersTable(db, uimanager)
                            }, myWindow)
                    })
                w.Importance = widget.HighImportance
                o.(*fyne.Container).Objects = []fyne.CanvasObject{
                    w,
                }
            } else {
                o.(*fyne.Container).Objects = []fyne.CanvasObject{
                    widget.NewLabel(data[i.Row][i.Col].(string)),
                }
            }
        })

    // trying to streach up table
    remindersContainer := container.NewBorder(
        nil,
        nil,
        nil,
        nil,
        container.NewAdaptiveGrid(1, list))
    colWidths := []float32{50, 150, 150, 150, 150, 150, 150, 150, 150}
    for i := range colWidths {
        list.SetColumnWidth(i, colWidths[i])
    }

    // tabs

    tabs := container.NewAppTabs(
        container.NewTabItemWithIcon("Reminders", theme.HomeIcon(), remindersContainer),
        // here will be the second tab
        // container.NewTabItemWithIcon("ToDo!", theme.ListIcon(), remindersContainer),
    )

    tabs.SetTabLocation(container.TabLocationLeading)

    // create toolbar

    toolbar := widget.NewToolbar(
        widget.NewToolbarSpacer(),
        widget.NewToolbarAction(theme.DocumentCreateIcon(), func() {
        }),
        widget.NewToolbarAction(theme.ViewRefreshIcon(), func() {}),
        widget.NewToolbarAction(theme.SettingsIcon(), func() {}),
    )

    // Creating finaly looking container
    finalContent := container.NewVBox(toolbar, tabs)
    myWindow.SetContent(finalContent)
    myWindow.ShowAndRun()
}

将最终容器的各个部分组装到 NewVBox（工具栏、选项卡、内容表）后，表会变小。水平位置时无法很好地伸展。如果仅使用带表的选项卡，则一切看起来都很好。

我尝试了很多不同的方法来解决这个问题，但就是搞不清楚到底是什么问题。我希望最终的内容能够占据下面的所有可用空间。

希望我能清楚地表达我的想法。

我正在尝试设置 FX 模块，但我有疑虑，找不到前进的方向。基本上，我有一个用于服务器的模块：

    func NewGRPCServer(
    lc fx.Lifecycle, log *zap.Logger, tracer trace.Tracer,
    srvsInterceptors []grpc.UnaryServerInterceptor, serverOpt []grpc.ServerOption,
) *grpc.Server {
    defaultRecoveryHandler := func(ctx context.Context, r interface{}) (err error) {
        logger.FromContext(ctx).Error("recovered from panic", zap.Any("panic", r), zap.Stack("stacktrace"))

        return status.Error(codes.Internal, "unexpected error")
    }

    interceptors := append([]grpc.UnaryServerInterceptor{
        LoggerToContextInterceptor(log),
        TracerToContextInterceptor(tracer),
        grpc_recovery.UnaryServerInterceptor(grpc_recovery.WithRecoveryHandlerContext(defaultRecoveryHandler)),
    }, srvsInterceptors...)

    otelHandler := otelgrpc.NewServerHandler(
        otelgrpc.WithTracerProvider(otel.GetTracerProvider()),
    )

    serverOpts := []grpc.ServerOption{
        grpc.ChainUnaryInterceptor(interceptors...),
        grpc.StatsHandler(otelHandler),
        grpc.KeepaliveEnforcementPolicy(
            keepalive.EnforcementPolicy{
                MinTime:             60 * time.Second,
                PermitWithoutStream: true,
            }),
        grpc.KeepaliveParams(
            keepalive.ServerParameters{
                Time:    60 * time.Second,
                Timeout: 10 * time.Second,
            },
        ),
    }

    serverOpts = append(serverOpts, serverOpt...)

    server := grpc.NewServer(serverOpts...)

    grpc_health_v1.RegisterHealthServer(server, health.NewServer())
    reflection.Register(server)

    return server
}

// NewListener creates a new network listener for the gRPC server using the gRPC server address parsed from the config.
func NewListener(cfg Config) (net.Listener, error) {
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", cfg.GRPC))
    if err != nil {
        return nil, fmt.Errorf("dial connection: %w", err)
    }

    return lis, nil
}

func GRPCModule() fx.Option {
    return fx.Module(
        "grpc",
        fx.Provide(
            fx.Annotate(
                NewGRPCServer,
                fx.ParamTags(``, ``, ``, `optional:"true"`, `optional:"true"`),
            ),
        ),
        fx.Invoke(func(lc fx.Lifecycle, server *grpc.Server, config Config, log *zap.Logger) {
            lc.Append(fx.Hook{
                OnStart: func(ctx context.Context) error {
                    lis, err := NewListener(config)
                    if err != nil {
                        return err
                    }

                    go func(srv *grpc.Server, logger *zap.Logger) {
                        logger.Info("Starting gRPC server")
                        if err := srv.Serve(lis); err != nil && err != grpc.ErrServerStopped {
                            logger.Error("gRPC server failed", zap.Error(err))
                        }
                    }(server, log)

                    return nil
                },
                OnStop: func(ctx context.Context) error {
                    server.GracefulStop()
                    return nil
                },
            })
        }),
    )
}

以及一个用于 UI 的模块：

func NewGRPCUIServer(
    lc fx.Lifecycle,
    logger *zap.Logger,
    tracer trace.Tracer,
    config Config,
) (*http.Server, error) {
    logger.Info("enter on new grpc ui server.")

    rpcGrpcHost := fmt.Sprintf("0.0.0.0:%d", config.GRPC)
    keepAliveOpt := grpc.WithKeepaliveParams(keepalive.ClientParameters{
        Time:                60 * time.Second,
        Timeout:             10 * time.Second,
        PermitWithoutStream: true,
    })

    cc, err := grpc.NewClient(
        rpcGrpcHost,
        grpc.WithTransportCredentials(insecure.NewCredentials()),
        grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
        keepAliveOpt,
    )
    if err != nil {
        logger.Error("Failed to connect to gRPC server for UI", zap.Error(err))
        return nil, err
    }

    h, err := standalone.HandlerViaReflection(context.Background(), cc, rpcGrpcHost)
    if err != nil {
        logger.Error("Failed to create UI handler", zap.Error(err))
        return nil, err
    }

    mux := http.NewServeMux()
    mux.Handle("/grpc-ui/", http.StripPrefix("/grpc-ui", h))

    return httplib.NewHTTPServerFx(
        lc,
        httplib.Config{
            ServerAddr:         fmt.Sprintf(":%d", config.UI),
            ServerReadTimeout:  15 * time.Second,
            ServerWriteTimeout: 15 * time.Second,
        },
        logger,
        tracer,
        mux,
    )
}

type GRPCUIParams struct {
    fx.In

    WebServer *http.Server `name:"grpc-ui-server"`
    Logger    *zap.Logger
}

func GRPCUIModule() fx.Option {
    return fx.Module(
        "x:ui",
        fx.Provide(
            NewGRPCUIServer,
            fx.Annotate(
                NewGRPCUIServer,
                fx.ParamTags(``, ``, ``, ``, ``),
                fx.ResultTags(`name:"grpc-ui-server"`),
            ),
        ),
        fx.Invoke(func(params GRPCUIParams) {
            params.Logger.Info("gRPC UI Server initialized:", zap.String("address", params.WebServer.Addr))
        }),
    )
}

但由于某种原因，它在handlerViaReflection处失败了：

h, err := standalone.HandlerViaReflection(context.Background(), cc, rpcGrpcHost)
if err != nil {
    logger.Error("Failed to create UI handler", zap.Error(err))
    return nil, err
}

由于 gRPC 服务器尚未启动，因此出现错误。我在服务器模块中放置了一个断点：

fx.Invoke(func(lc fx.Lifecycle, server *grpc.Server, config Config, log *zap.Logger) {
    lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error {
            lis, err := NewListener(config)
            if err != nil {
                return err
            }

            go func(srv *grpc.Server, logger *zap.Logger) {
                logger.Info("Starting gRPC server")
                if err := srv.Serve(lis); err != nil && err != grpc.ErrServerStopped {
                    logger.Error("gRPC server failed", zap.Error(err))
                }
            }(server, log)

            return nil
        },

而且它不会进入；它总是先进入 UI 模块。它创建服务器：NewGRPCServer，但从不初始化它。有人知道我该如何解决这个问题吗？

我在 Golang 中使用 Viper 从环境变量加载配置值。但是，如果未设置所需的环境变量，我希望 viper.Unmarshal 返回错误。

默认情况下，如果缺少环境变量，viper.Unmarshal 不会失败 - 它只是将零值分配给结构字段。

这是我的代码：

package main

import (
    "fmt"
    "log"

    "github.com/spf13/viper"
)

type Config struct {
    DatabaseURL string `mapstructure:"DATABASE_URL"`
}

func main() {
    viper.AutomaticEnv()

    var config Config
    if err := viper.Unmarshal(&config); err != nil {
        log.Fatalf("Error unmarshaling config: %v", err)
    }

    fmt.Println("Config:", config)
}

如果没有设置DATABASE_URL，config.DatabaseURL只是一个空字符串，而不会导致错误。

我尝试使用 viper.BindEnv("DATABASE_URL")，但是当 DATABASE_URL 丢失时 Unmarshal 仍然不会失败。

在 Viper 中，Unmarshal 函数通过 DecoderConfigOption 接受钩子。查看 viper，我发现 DecoderConfig 结构体有一个 ErrorUnset 字段：

// If ErrorUnset is true, then it is an error for there to exist  
// fields in the result that were not set in the decoding process  
// (extra fields). This only applies to decoding to a struct. This  
// will affect all nested structs as well.  
ErrorUnset bool 

但是，我不确定如何正确地将此配置作为 Unmarshal 中的钩子传递。如果有人知道如何使用 DecoderConfigOption 启用 ErrorUnset，谢谢！

如果未设置所需的环境变量，如何让 viper.Unmarshal DecodeHook 返回错误？

我正在使用 Swaggo 来记录我的 Go API 端点。我有一个处理程序函数，其中我在 JSON 结构字段中定义了一个带有示例标签的结构，但这些示例并未出现在生成的 Swagger UI 中。

// @Summary Register a new user
// @Description Creates a new user account. In development environment, the user is activated immediately. Otherwise, an activation email is sent.
// @Tags users
// @Accept json
// @Produce json
// @Param request body main.application.registerUserHandler.input true "User registration details"
// @Success 202 {object} object{user=data.User}
// @Router /users [post]
func (app *application) registerUserHandler(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Name     string `json:"name" example:"John Doe"`
        Email    string `json:"email" example:"[email protected]"`
        Password string `json:"password" example:"SecurePass123!"`
    }
    // ... rest of the handler ...
}

Swagger 文档生成正确，但结构中示例标签的示例值未显示在请求主体模式中。

有没有办法让 Swaggo 识别嵌套/内联结构中的示例标签？

我正在学习Go Channel。我在Go

package main
import "fmt"
func sample(mychan chan string) {
    fmt.Println("Go Go Go Go")
    fmt.Println("message received from channel is ", <-mychan)
}
func main() {
    messageChan := make(chan string)
    go sample(messageChan)
    messageChan <- "hello"
}

发生的情况是，有时它会显示“消息已收到...”语句。有时它不显示。它总是显示“Go Go Go ..”语句。那么为什么它会跳过“消息已收到”语句。这是怎么回事呢？我很困惑。

我有一个简单的条形图，上面叠加了一条线。条形和线是由不同的数据生成的，因此图表会歪曲条形的大小，因为线数据明显大于条形数据。我想在图表右侧为线条设置单独的 y 轴以防止这种情况发生，但我找不到有关如何执行此操作的 go-echarts 文档。

这是图表当前的图像。如您所见，条形几乎看不出来。

下面是我的代码。该行添加到代码底部。有人知道如何在该行的右侧添加 y 轴吗？

// Sort the dates so that the x-axis is ordered.
    var dates []string
    for date := range data {
        dates = append(dates, date)
    }
    sort.Strings(dates)

    // Build series data for the bars (profit) and line (transaction count).
    var barData []opts.BarData
    for _, date := range dates {
        stat := data[date]
        barData = append(barData, opts.BarData{Value: stat.Profit})
    }

    // Create the bar chart for profit.
    bar := charts.NewBar()
    bar.SetGlobalOptions(
        charts.WithTitleOpts(opts.Title{
            Title:    "Daily Profit",
            Subtitle: "Profit in USDT",
        }),
        charts.WithLegendOpts(opts.Legend{
            Show: opts.Bool(false),
        }),
        charts.WithDataZoomOpts(opts.DataZoom{
            Type:  "slider",
            Start: 50,
            End:   100,
        }),
        // First y-axis (index 0) for Profit USDT; no explicit index needed.
        charts.WithYAxisOpts(
            opts.YAxis{
                Type: "value",
            },
        ),
    )
    bar.SetXAxis(dates).AddSeries("Profit USDT", barData)

    // Build series data for the bars (profit) and line (transaction count).
    var lineData []opts.LineData
    for _, date := range dates {
        stat := data[date]
        lineData = append(lineData, opts.LineData{Value: stat.Count, YAxisIndex: 1})
    }

    // Create the bar chart for profit.
    line := charts.NewLine()
    line.SetXAxis(dates).
        AddSeries("Transaction Count", lineData)
    line.SetGlobalOptions(
        // First y-axis (index 0) for Profit USDT; no explicit index needed.
        charts.WithYAxisOpts(
            opts.YAxis{
                Type: "value",
                Position: "right",
            },
        ),
    )
    line.ExtendYAxis(opts.YAxis{Type: "value", Position: "right", Show: opts.Bool(true)})
    
    bar.Overlap(line)

    return bar

我有以下代码。这是一个学习练习，因此它没有做任何明显有用的事情。如果 wg.Add 值为 1，它就会起作用。如果 wg.Add 值为 2，它就会失败。如果我删除通道逻辑，它就会在 wg.Add 值为 2 的情况下起作用。

对我做错的事情有什么想法吗？

package main

import (
    "fmt"
    "sync"
)

func popMessage(wg *sync.WaitGroup, m *sync.Mutex, i *int, c chan<- int) {
    m.Lock()
    *i++
    c <- *i
    m.Unlock()
    fmt.Printf("pop %d\n", *i)
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    var m sync.Mutex
    var intPtr *int

    c := make(chan int, 1)
    wg.Add(2)

    intPtr = new(int)
    *intPtr = 1
    go popMessage(&wg, &m, intPtr, c)
    go popMessage(&wg, &m, intPtr, c)
    go popMessage(&wg, &m, intPtr, c)
    wg.Wait()
    fmt.Printf("final %d\n", *intPtr)
    for x := range c {
        fmt.Printf("channel %d\n", x)
    }
}

一直在开发一个小型 Web 应用程序，想尝试使用 nginx 和 Golang 作为后端。这是我的第一个 Golang Web 项目，因此对 Golang 还很陌生。无论如何，我的 HTML 登录页面的反向代理存在问题：

<!DOCTYPE html>
<html>

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link rel="stylesheet" href="loginStyle.css">
  <title>Cosmic Cloud Login</title>
</head>

<body>

  <div class="loginContainer">
    <h1 class="headerText">Login</h1>
    <p>Please enter your login information</p>
    <form action="/login" method="POST">
      <div class="inputGroup">
        <label for="Username">Username</label>
        <input type="Username" id="Username" name="Username" placeholder="Enter your username" required>
      </div>

      <div class="inputGroup">
        <label for="Password">Password</label>
        <input type="Password" id="Password" name="Password" placeholder="Enter your password" required>
      </div>
      <button type="submit" class="loginButton">Login</button>
    </form>


  </div>

</body>

</html>

nginx.conf文件如下：

   server {
          listen 80;
   location / {
          root /var/www/html;
          index index.html;
   }

   location /login {
          proxy_pass http://0.0.0.0:8080;
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
   }
   }

Go文件如下：

package main 


import (
    "fmt"
    "net/http"
)



var validUsername = "test"
var validPassword = "test1234"

func loginHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Invalid Request method", http.StatusMethodNotAllowed)
        return 
    }

    username := r.FormValue("Username")
    password := r.FormValue("Password")

    if username == validUsername && password == validPassword {
        fmt.Fprint(w, "Login Successfull!")
    } else {
        http.Error(w, "Invalid Username or Password", http.StatusUnauthorized)

    }
}

func main() {
    http.HandleFunc("/login", loginHandler)
    fmt.Println("Server is running on :8080")
    http.ListenAndServe(":8080", nil)
} 

发送 post 请求时，除非您指定端口 8080，否则 golang 后端永远不会收到它。（例如“http://IP/login”不起作用）（“http://IP:8080/login”起作用）我在本地计算机和网络上的另一台计算机上都尝试过。TLDR：nginx 无法正确将 POST 请求从 nginx Web 服务器（端口 80）发送到 Golang 后端正在监听的端口（端口 8080）。非常感谢您的帮助，谢谢！

编辑：此外，这可能不是防火墙问题，因为我在测试环境中禁用了 ufw。