A lightweight yet powerful IoC dependency injection container for the Go programming language
Alternatives To Container
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Inversifyjs9,7284,7401,43616 days ago77October 14, 2021266mitTypeScript
A powerful and lightweight inversion of control container for JavaScript & Node.js apps powered by TypeScript.
26910 days ago37August 03, 202253mitSwift
Dependency injection framework for Swift with iOS/macOS/Linux
Loopback Next4,4581622916 days ago133August 25, 2022245otherTypeScript
LoopBack makes it easy to build modern API applications that require complex integrations.
9 days ago18April 12, 20224apache-2.0C#
💖 ASP.NET Core 6.0/7.0 全家桶教程,前后端分离后端接口,vue教程姊妹篇,官方文档:
Autofac4,09910,8723,53713 days ago75May 25, 202218mitC#
An addictive .NET IoC container
Tsyringe3,8892916716 days ago23May 27, 202271mitTypeScript
Lightweight dependency injection container for JavaScript/TypeScript
Typedi3,4903104096 days ago26January 15, 202137mitTypeScript
Simple yet powerful dependency injection tool for JavaScript and TypeScript.
Awilix2,7232941952 months ago75May 02, 20224mitTypeScript
Extremely powerful Inversion of Control (IoC) container for Node.JS
1622 years ago137July 03, 202033apache-2.0Objective-C
Powerful dependency injection for Objective-C ✨✨ (https://PILGRIM.PH is the pure Swift successor to Typhoon!!)✨✨
Python Dependency Injector2,70355619 days ago287March 30, 2022129bsd-3-clausePython
Dependency injection framework for Python
Alternatives To Container
Select To Compare

Alternative Project Comparisons

Go Reference CI CodeQL Go Report Card Coverage Status Mentioned in Awesome Go


GoLobby Container is a lightweight yet powerful IoC (dependency injection) container for Go projects. It's built neat, easy-to-use, and performance-in-mind to be your ultimate requirement.


  • Singleton and Transient bindings
  • Named dependencies (bindings)
  • Resolve by functions, variables, and structs
  • Must helpers that convert errors to panics
  • Optional lazy loading of bindings
  • Global instance for small applications
  • 100% Test coverage!


Required Go Versions

It requires Go v1.11 or newer versions.


To install this package, run the following command in your project directory.

go get

Next, include it in your application:

import ""


GoLobby Container is used to bind abstractions to their implementations. Binding is the process of introducing appropriate concretes (implementations) of abstractions to an IoC container. In this process, you also determine the resolving type, singleton or transient. In singleton bindings, the container provides an instance once and returns it for all the requests. In transient bindings, the container always returns a brand-new instance for each request. After the binding process, you can ask the IoC container to make the appropriate implementation of the abstraction that your code needs. Then your code will depend on abstractions, not implementations!

Quick Start

The following example demonstrates a simple binding and resolving.

// Bind Config interface to JsonConfig struct
err := container.Singleton(func() Config {
    return &JsonConfig{...}

var c Config
err := container.Resolve(&c)
// `c` will be the instance of JsonConfig

Typed Binding


The following snippet expresses singleton binding.

err := container.Singleton(func() Abstraction {
  return Implementation

// If you might return an error...

err := container.Singleton(func() (Abstraction, error) {
  return Implementation, nil

It takes a resolver (function) whose return type is the abstraction and the function body returns the concrete (implementation).

The example below shows a singleton binding.

err := container.Singleton(func() Database {
  return &MySQL{}


The example below shows a transient binding.

err := container.Transient(func() Shape {
  return &Rectangle{}

Named Bindings

You may have different concretes for an abstraction. In this case, you can use named bindings instead of typed bindings. Named bindings take the dependency name into account as well. The rest is similar to typed bindings. The following examples demonstrate some named bindings.

// Singleton
err := container.NamedSingleton("square", func() Shape {
    return &Rectangle{}
err := container.NamedSingleton("rounded", func() Shape {
    return &Circle{}

// Transient
err := container.NamedTransient("sql", func() Database {
    return &MySQL{}
err := container.NamedTransient("noSql", func() Database {
    return &MongoDB{}

Resolver Errors

The process of creating concrete (resolving) might face an error. In this case, you can return the error as the second return value like the example below.

err := container.Transient(func() (Shape, error) {
  return nil, errors.New("my-app: cannot create a Shape implementation")

It could be applied to other binding types.


Container resolves the dependencies with the Resolve(), Call(), and Fill() methods.

Using References

The Resolve() method takes reference of the abstraction type and fills it with the appropriate concrete.

var a Abstraction
err := container.Resolve(&a)
// `a` will be an implementation of the Abstraction

Example of resolving using references:

var m Mailer
err := container.Resolve(&m)
// `m` will be an implementation of the Mailer interface
m.Send("[email protected]", "Hello Milad!")

Example of named-resolving using references:

var s Shape
err := container.NamedResolve(&s, "rounded")
// `s` will be an implementation of the Shape that named rounded

Using Closures

The Call() method takes a receiver (function) with arguments of abstractions you need. It calls it with parameters of appropriate concretes.

err := container.Call(func(a Abstraction) {
    // `a` will be an implementation of the Abstraction

Example of resolving using closures:

err := container.Call(func(db Database) {
  // `db` will be an implementation of the Database interface

You can also resolve multiple abstractions like the following example:

err := container.Call(func(db Database, s Shape) {

You are able to raise an error in your receiver function, as well.

err := container.Call(func(db Database) error {
  return db.Ping()
// err could be `db.Ping()` error.

Caution: The Call() method does not support named bindings.

Using Structs

The Fill() method takes a struct (pointer) and resolves its fields.

The example below expresses how the Fill() method works.

type App struct {
    mailer Mailer   `container:"type"`
    sql    Database `container:"name"`
    noSql  Database `container:"name"`
    other  int

myApp := App{}

err := container.Fill(&myApp)

// [Typed Bindings]
// `myApp.mailer` will be an implementation of the Mailer interface

// [Named Bindings]
// `myApp.sql` will be a sql implementation of the Database interface
// `myApp.noSql` will be a noSql implementation of the Database interface

// `myApp.other` will be ignored since it has no `container` tag

Binding time

You can resolve dependencies at the binding time if you need previous dependencies for the new one.

The following example shows resolving dependencies at binding time.

// Bind Config to JsonConfig
err := container.Singleton(func() Config {
    return &JsonConfig{...}

// Bind Database to MySQL
err := container.Singleton(func(c Config) Database {
    // `c` will be an instance of `JsonConfig`
    return &MySQL{
        Username: c.Get("DB_USERNAME"),
        Password: c.Get("DB_PASSWORD"),

Standalone Instance

By default, the Container keeps your bindings in the global instance. Sometimes you may want to create a standalone instance for a part of your application. If so, create a standalone instance like the example below.

c := container.New()

err := c.Singleton(func() Database {
    return &MySQL{}

err := c.Call(func(db Database) {

The rest stays the same. The global container is still available.

Must Helpers

You might believe that the container shouldn't raise any error and/or you prefer panics. In this case, Must helpers are for you. Must helpers are global methods that panic instead of returning errors.

c := container.New()
// Global instance:
// c := container.Global

container.MustSingleton(c, func() Shape {
    return &Circle{a: 13}

container.MustCall(c, func(s Shape) {
    // ...

// Other Must Helpers:
// container.MustSingleton()
// container.MustSingletonLazy()
// container.MustNamedSingleton()
// container.MustNamedSingletonLazy()
// container.MustTransient()
// container.MustTransientLazy()
// container.MustNamedTransient()
// container.MustNamedTransientLazy()
// container.MustCall()
// container.MustResolve()
// container.MustNamedResolve()
// container.MustFill()

Lazy Binding

Both the singleton and transient binding calls have a lazy version. Lazy versions defer calling the provided resolver function until the first call. For singleton bindings, It calls the resolver function only once and stores the result.

Lazy binding methods:

  • container.SingletonLazy()
  • container.NamedSingletonLazy()
  • container.TransientLazy()
  • container.NamedTransientLazy()


The package Container inevitably uses reflection for binding and resolving processes. If performance is a concern, try to bind and resolve the dependencies where it runs only once, like the main and init functions.


GoLobby Container is released under the MIT License.

Popular Inversion Of Control Projects
Popular Dependency Injection Projects
Popular Software Architecture Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Dependency Injection
Golang Package
Ioc Container
Di Container