go-zero 的 middleware 放哪？有没有 http 目录

middleware 放哪？有没有专门的 http 目录

两步结论：① 没有名为 http 的目录；② 中间件建议放 internal/middleware/，而「HTTP 层」其实由 internal/handler 承担。

一套清晰的 middleware 布局

HTTP 中间件统一收口在 internal/middleware/，路由注册仍然在 internal/handler/routes.go。下面是一份标准骨架。

go-zero 的 HTTP 中间件类型

go-zero 的 HTTP 中间件就是 rest.Middleware 类型：func(next http.HandlerFunc) http.HandlerFunc。约定写法是用一个结构体包一层，方便注入依赖。

// internal/middleware/jwt.go
package middleware

import (
    "net/http"
    "github.com/zeromicro/go-zero/rest"
)

// 需要依赖时，用结构体包一层，构造器注入
type JwtMiddleware struct {
    Secret string
}

func NewJwtMiddleware(secret string) *JwtMiddleware {
    return &JwtMiddleware{Secret: secret}
}

// Handle 的签名正好就是 rest.Middleware
func (m *JwtMiddleware) Handle(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if !m.valid(token) {                  // 校验
            httpx.Error(w, errors.New("unauthorized"))
            return                            // 不放行
        }
        // 把 userId 透传给下游（走 context，不是 svc）
        ctx := context.WithValue(r.Context(), "uid", uid)
        next(w, r.WithContext(ctx))         // 放行
    }
}

// 不需要依赖的轻量中间件，可以直接是函数
func LogMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        logx.Infof("req %s %s", r.Method, r.URL.Path)
        next(w, r)
    }
}

全局中间件 vs 路由级中间件

两种注册方式：server.Use() 对所有路由生效；rest.WithMiddlewares() 只对某组路由生效。推荐在 routes.go 里集中管理。

① 全局（main.go 里 Use）

// user.go (main)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()

// 所有请求都过一遍：访问日志 + 跨域
server.Use(middleware.LogMiddleware)
server.Use(middleware.NewCorsMiddleware().Handle)

handler.RegisterHandlers(server, svcCtx)
server.Start()

② 路由级（routes.go 里 WithMiddlewares）

// internal/handler/routes.go
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
    server.AddRoutes(
        []rest.Route{
            {Method: http.MethodPost, Path: "/login", Handler: LoginHandler(serverCtx)},
            {Method: http.MethodGet,  Path: "/profile", Handler: ProfileHandler(serverCtx)},
        },
        // 只对这组路由套 JWT 鉴权
        rest.WithMiddlewares([]rest.Middleware{
            middleware.NewJwtMiddleware(serverCtx.Config.Auth.AccessSecret).Handle,
        }),
    )

    // 登录接口不套 JWT（否则永远进不来），单独加
    server.AddRoutes([]rest.Route{
        {Method: http.MethodPost, Path: "/login", Handler: LoginHandler(serverCtx)},
    })
}

用 DSL 声明中间件（goctl 帮你接好）

不想手动改 routes.go？可以在 .api 的 @server 里声明 middleware:，goctl 生成时会在 routes.go 留好调用位，你只管实现。

// user.api
@server(
    jwt:    Auth
    middleware: AuthMiddleware   # 声明：这组接口要过 AuthMiddleware
)
service user-api {
    @handler profile
    get /profile
}

// goctl 生成后，routes.go 会写出引用；你实现 internal/middleware/authmiddleware.go
// 命名约定：XxxMiddleware → NewXxxMiddleware().Handle

zrpc 没有 middleware，只有拦截器

go-zero 的 RPC 层（zrpc）不叫 middleware，叫拦截器 interceptor。写法不同，但目录约定一样——放 internal/middleware/ 或 internal/rpc/middleware。

// 服务端拦截器（在 main 注册）
s := zrpc.MustNewServer(c.RpcServerConf, func(g *grpc.Server) {
    user.RegisterUserServer(g, server.NewUserServer(ctx))
}, rpcserver.WithUnaryServerInterceptor(myInterceptor))
// 客户端拦截器：zrpc.WithUnaryClientInterceptor(...)

// 拦截器签名（和 HTTP 中间件不一样）
func myInterceptor(ctx context.Context, req interface{},
    info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    // 前置：日志/鉴权/限流
    resp, err := handler(ctx, req)   // 放行
    // 后置：统计/报错
    return resp, err
}

你的两个问题，一句话版