Go Dependency Injection

dependency-struct-closure.go

type UserHandlerDependencies struct {
	UserDatastore
	UserEnricher
}

func BuildUserHandler(deps UserHandlerDependencies) http.Handler {
  return http.HandlerFunc(rw http.ResponseWriter, req *http.Request) {
    // Parse Request
    user, err := deps.GetUser(username)
    enriched := deps.EnrichUser(user)
    // etc...
  }
}

explicit-closure.go

func NewGetUserHandler(datastore UserDatastore, enricher UserEnricher) http.Handler {
	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
		// Parse Request
		user, err := datastore.GetUser(username)
		enriched := enricher.EnrichUser(user)
		// etc...
	})
}

// Only works for 1-3ish dependencies

explicit-struct-method.go

type UserHandler struct {
	UserDatastore
	UserEnricher
}

func (userHandler) HandleGetUser(rw http.ResponseWriter, req *http.Request) {
	// Parse Request
	user, err := userHandler.GetUser(username)
	enriched := userHandler.EnrichUser(user)
	// etc...
}

// Overkill for 1-2 dependencies

mono-builder-closure.go

func NewGetUserHandler(deps interface{
	GetUserDatastore() UserDatastore
	GetUserEnricher() UserEnricher
}) http.Handler {
	datastore := deps.GetUserDatastore()
	enricher := deps.GetUserEnricher()
	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
		// Parse Request
		user, err := datastore.GetUser(username)
		enriched := enricher.EnrichUser(user)
		// etc...
	})
}

multi-builder-closure.go

func NewGetUserHandler(userDatastoreBuilder interface{
	GetUserDatastore() UserDatastore
}, userEnricherBuilder interface{
	GetUserEnricher() UserEnricher
}) http.Handler {
	datastore := userDatastirBuilder.GetUserDatastore()
	enricher := userEnricherBuilder.GetUserEnricher()
	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
		// Parse Request
		user, err := datastore.GetUser(username)
		enriched := enricher.EnrichUser(user)
		// etc...
	})
}

package-global.go

var UserDatastore interface{
	// actual used methods
} 
var UserEnricher interface{
	// actual used methods
}
// OR 
var UserDatastore users.Datastore
var UserEnricher users.Enricher

func HandleGetUser(rw http.ResponseWriter, req *http.Request) {
	// Parse Request
	user, err := UserDatastore.GetUser(username)
	enriched := UserEnricher.EnrichUser(user)
	// etc...
}

// Easy to forget, runtime error, unless there is a sane default