gocontainer package - github.com/vardius/gocontainer

gocontainer package - github.com/vardius/gocontainer - Go Packages

Package gocontainer is a simple dependency injection container

Take the following example: First file `main.go` simply gets the repository from the container and prints it we use **MustInvoke** method to simply present the way where we keep type safety

package main

import (
	"github.com/vardius/gocontainer/example/repository"
	"github.com/vardius/gocontainer"
)

func main() {
	gocontainer.MustInvoke("repository.mysql", func(r Repository) {
		fmt.Println(r)
	})
}

Our database implementation uses `init()` function to register db service

package database

import (
	"fmt"
	"database/sql"

	"github.com/vardius/gocontainer"
)

func NewDatabase() *sql.DB {
	db, _ := sql.Open("mysql", "dsn")

	return db
}

func init() {
	db := gocontainer.MustGet("db")

	gocontainer.Register("db", NewDatabase())
}

Our repository accesses earlier on registered db service and following the same patter uses `init()` function to register repository service within container

package repository

import (
	"fmt"
	"database/sql"

	"github.com/vardius/gocontainer"
	_ "github.com/vardius/gocontainer/example/database"
)

type Repository interface {}

func NewRepository(db *sql.DB) Repository {
	return &mysqlRepository{db}
}

type mysqlRepository struct {
	db *sql.DB
}

func init() {
	db := gocontainer.MustGet("db")

	gocontainer.Register("repository.mysql", NewRepository(db.(*sql.DB)))
}

You can disable global container instance by setting gocontainer.GlobalContainer to nil. This package allows you to create many containers.

package main

import (
	"github.com/vardius/gocontainer/example/repository"
	"github.com/vardius/gocontainer"
)

func main() {
	// disable global container instance
	gocontainer.GlobalContainer = nil

	mycontainer := gocontainer.New()
	mycontainer.Register("test", 1)
}

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)
	gocontainer.Deregister("test")

	fmt.Println(gocontainer.Get("test"))
}

Output:

<nil> false

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)
	o, ok := gocontainer.Get("test")

	fmt.Println(o)
	fmt.Println(ok)
}

Output:

1
true

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)

	fmt.Println(gocontainer.Has("test"))
}

Output:

true

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)
	gocontainer.Invoke("test", func(i int, ok bool) {
		fmt.Println(i)
		fmt.Println(ok)
	})

}

Output:

1
true

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)
	o := gocontainer.MustGet("test")

	fmt.Println(o)
}

Output:

1

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)
	gocontainer.MustInvoke("test", func(i int) {
		fmt.Println(i)
	})

}

Output:

1

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test1", 1)
	gocontainer.Register("test2", 2)

	gocontainer.MustInvokeMany("test1", "test2")(func(x int, y int) {
		fmt.Println(x, "|", y)
	})

}

Output:

1 | 2

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// disable global container instance
	gocontainer.GlobalContainer = nil

	mycontainer := gocontainer.New()
	mycontainer.Register("test", 1)

	fmt.Println(mycontainer.MustGet("test"))
}

Output:

1

package main

import (
	"fmt"

	gocontainer "github.com/vardius/gocontainer"
)

func main() {
	// called by gocontainer's init() function
	gocontainer.GlobalContainer = gocontainer.New()

	gocontainer.Register("test", 1)

	fmt.Println(gocontainer.MustGet("test"))
}

Output:

1

This section is empty.

Has checks if container has an object

func Invoke(id string, fn interface{})

Invoke gets a service safely typed by passing it to a closure will panic if callback is not a function

func MustGet(id string) interface{}

MustGet calls Get underneath will panic if object not found within container

func MustInvoke(id string, fn interface{})

MustInvoke calls MustGet underneath will panic if object not found within container

func MustInvokeMany(ids ...string) func(fn interface{})

MustInvokeMany calls MustInvoke underneath returns many services from container will panic if object not found within container

func Register(id string, object interface{})

type Container interface {
	Register(id string, object interface{})
	Deregister(id string)
	Has(id string) bool
	Get(id string) (interface{}, bool)
	MustGet(id string) interface{}
	Invoke(id string, fn interface{})
	MustInvoke(id string, fn interface{})
	MustInvokeMany(ids ...string) func(fn interface{})
}

Container interface

var (
	
	
	GlobalContainer Container
)

New creates new container