How to Implement Threadlocal Similar to Java？

[seepine]

For example, in Java, I can save user information in ThreadLocal and automatically inject information such as CreateId and CreateName into ORM hooks. How to implement similar functionality in go&echo and inject user information into ORM hooks.

[ismaildasci]

Go doesn't have ThreadLocal like Java, but context.Context is the idiomatic way to pass request-scoped data. Echo makes this easy since every handler gets a context.

1. Store user info in middleware:

func UserMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        user := getUserFromToken(c) // your auth logic
        c.Set("user", user)
        return next(c)
    }
}

2. Pass context to your DB/ORM layer:

func CreateOrder(c echo.Context, order *Order) error {
    ctx := c.Request().Context()
    // Pass ctx to your ORM
    return db.WithContext(ctx).Create(order).Error
}

3. In your ORM hooks, extract user from context:

For GORM, you can use callbacks:

func (o *Order) BeforeCreate(tx *gorm.DB) error {
    ctx := tx.Statement.Context
    if user, ok := ctx.Value("user").(*User); ok {
        o.CreateId = user.ID
        o.CreateName = user.Name
    }
    return nil
}

Important: You need to bridge Echo's context with Go's context.Context. One clean way:

func InjectUserToContext(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        user := c.Get("user")
        ctx := context.WithValue(c.Request().Context(), "user", user)
        c.SetRequest(c.Request().WithContext(ctx))
        return next(c)
    }
}

This way the user info flows through context.Context and is accessible anywhere downstream, including ORM hooks.

Unlike Java's ThreadLocal which is tied to a thread, Go's context is explicitly passed - which is actually safer since goroutines can be reused and you won't accidentally leak data between requests.

[seepine]

I found the github.com/timandy/routine and can do

package ctx
import "github.com/timandy/routine"

var threadLocal = routine.NewThreadLocal[echo.Context]()

func Get() echo.Context {
	return threadLocal.Get()
}
func Set(val echo.Context) {
	threadLocal.Set(val)
}
func Remove() {
	threadLocal.Remove()
}

Middleware

func ThreadLocal() echo.MiddlewareFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			ctx.Set(c)
			var resp = next(c)
			ctx.Remove()
			return resp
		}
	}
}

Anywhere

ctx.Get()

[aldas]

I think @ismaildasci answer is the proper solution here.

I can not imagine how this mw + ctx.Get() would work when somewhere in your code you start running goroutines. In perspective of Echo the value := c.Get("value") or value, err := echo.Context[sometypehere]("value") this the way to move data between middlewares to handler. And from there or from middleware if you really need - set it to standard library context.

You are trying to fit square peg to a round hole with this approach. it might work but it is not how it should be done.

[seepine]

@aldas
Yes, golang prefers explicit context passing through layers, but for someone like me who just switched from Java, ThreadLocal offers a balance.

[aldas]

You should lean into Go’s conventions rather than carrying over idioms or patterns from other languages. You are just creating technical debt for yourself.

As a Java developer, you’ve probably seen Java written like C - and it likely felt off. Bringing in "magic" like heavy injection, thread-locals, and similar patterns is the same kind of mistake: you’re trying to reshape the language ecosystem instead of adapting to the language.