All Projects → defval → inject

defval / inject

Licence: MIT license
[Archived] See

Programming Languages

24326 projects - #10 most used programming language

Projects that are alternatives of or similar to inject

A extremely fast ioc container for high performance applications
Stars: ✭ 63 (+28.57%)
Mutual labels:  ioc, dependency-injection, ioc-container, di
Lightweight dependency injector
Stars: ✭ 30 (-38.78%)
Mutual labels:  ioc, dependency-injection, ioc-container, injector
🛠 A full-featured dependency injection container for go programming language.
Stars: ✭ 156 (+218.37%)
Mutual labels:  ioc, dependency-injection, ioc-container, di
Powerful dependency injection for Objective-C ✨✨ (https://PILGRIM.PH is the pure Swift successor to Typhoon!!)✨✨
Stars: ✭ 2,711 (+5432.65%)
Mutual labels:  ioc, dependency-injection, ioc-container, di
🦘 A dependency injection container for C++11, C++14 and later
Stars: ✭ 297 (+506.12%)
Mutual labels:  ioc, dependency-injection, ioc-container
hiboot is a high performance web and cli application framework with dependency injection support
Stars: ✭ 150 (+206.12%)
Mutual labels:  ioc, dependency-injection, di
Typescript Ioc
A Lightweight annotation-based dependency injection container for typescript.
Stars: ✭ 427 (+771.43%)
Mutual labels:  ioc, dependency-injection, ioc-container
🦄 lightweight (<1kb) inversion of control javascript library for dependency injection written in typescript
Stars: ✭ 171 (+248.98%)
Mutual labels:  ioc, dependency-injection, ioc-container
Powerful dependency injection container for node.js
Stars: ✭ 27 (-44.9%)
Mutual labels:  ioc, dependency-injection, ioc-container
Dependency Injection and IoC framework for PHP
Stars: ✭ 5 (-89.8%)
Mutual labels:  ioc, dependency-injection, ioc-container
Node Dependency Injection
The NodeDependencyInjection component allows you to standarize and centralize the way objects are constructed in your application.
Stars: ✭ 140 (+185.71%)
Mutual labels:  ioc, dependency-injection, ioc-container
A lightweight yet powerful IoC container for Go projects
Stars: ✭ 160 (+226.53%)
Mutual labels:  ioc, dependency-injection, ioc-container
fast light brisk ioc/di container on nodejs; Node下快速 轻量的IoC/DI容器,依赖注入,配合装饰器使用
Stars: ✭ 12 (-75.51%)
Mutual labels:  ioc, dependency-injection, ioc-container
Dependency injection for iOS (Swift)
Stars: ✭ 317 (+546.94%)
Mutual labels:  ioc, dependency-injection, di
A very opinionated inversion of control (IoC) container and dependency injector for Typescript, Node.js or browser apps.
Stars: ✭ 36 (-26.53%)
Mutual labels:  ioc, dependency-injection, di
A dependency injection framework for D with support for autowiring.
Stars: ✭ 57 (+16.33%)
Mutual labels:  ioc, dependency-injection, ioc-container
Dependency Injection framework for Swift
Stars: ✭ 21 (-57.14%)
Mutual labels:  ioc, dependency-injection, ioc-container
Python Dependency Injector
Dependency injection framework for Python
Stars: ✭ 1,203 (+2355.1%)
Mutual labels:  ioc, dependency-injection, ioc-container
Container Ioc
Inversion of Control container & Dependency Injection for Javascript and Node.js apps powered by Typescript.
Stars: ✭ 89 (+81.63%)
Mutual labels:  ioc, dependency-injection, di
One of the very first IoC frameworks for .Net that has no reflection. An IoC that casts its services before thunder casts its bolts.
Stars: ✭ 40 (-18.37%)
Mutual labels:  ioc, dependency-injection, ioc-container


Documentation Release Build Status Code Coverage

This repository will be archived

After using this library in production for a year, I made some conclusions about library API and really useful features. I don't want to make breaking changes and have a v3 version. It's not that popular.

I put old and new ideas in goava/di.

How will dependency injection help me?

Dependency injection is one form of the broader technique of inversion of control. It is used to increase modularity of the program and make it extensible.



go get -u

This library follows SemVer strictly.


Let's learn to use Inject by example. We will code a simple application that processes HTTP requests.

The full tutorial code is available here


To start, we will need to create two fundamental types: http.Server and http.ServeMux. Let's create a simple constructors that initialize it:

// NewServer creates a http server with provided mux as handler.
func NewServer(mux *http.ServeMux) *http.Server {
	return &http.Server{
		Handler: mux,

// NewServeMux creates a new http serve mux.
func NewServeMux() *http.ServeMux {
	return &http.ServeMux{}

Supported constructor signature:

func([dep1, dep2, depN]) (result, [cleanup, error])

Now let's teach a container to build these types.

container := inject.New(
	// provide http server
    // provide http serve mux

The function inject.New() parse our constructors, compile dependency graph and return *inject.Container type for interaction. Container panics if it could not compile.

I think that panic at the initialization of the application and not in runtime is usual.


We can extract the built server from the container. For this, define the variable of extracted type and pass variable pointer to Extract function.

If extracted type not found or the process of building instance cause error, Extract return error.

If no error occurred, we can use the variable as if we had built it yourself.

// declare type variable
var server *http.Server
// extracting
err := container.Extract(&server)
if err != nil {
	// check extraction error


Note that by default, the container creates instances as a singleton. But you can change this behaviour. See Prototypes.


As an alternative to extraction we can use Invoke() function. It resolves function dependencies and call the function. Invoke function may return optional error.

// StartServer starts the server.
func StartServer(server *http.Server) error {
    return server.ListenAndServe()



Result dependencies will be lazy-loaded. If no one requires a type from the container it will not be constructed.


Inject make possible to provide implementation as an interface.

// NewServer creates a http server with provided mux as handler.
func NewServer(handler http.Handler) *http.Server {
	return &http.Server{
		Handler: handler,

For a container to know that as an implementation of http.Handler is necessary to use, we use the option inject.As(). The arguments of this option must be a pointer(s) to an interface like new(Endpoint).

This syntax may seem strange, but I have not found a better way to specify the interface.

Updated container initialization code:

container := inject.New(
	// provide http server
	// provide http serve mux as http.Handler interface
	inject.Provide(NewServeMux, inject.As(new(http.Handler)))

Now container uses provide *http.ServeMux as http.Handler in server constructor. Using interfaces contributes to writing more testable code.


Container automatically groups all implementations of interface to []<interface> group. For example, provide with inject.As(new(http.Handler) automatically creates a group []http.Handler.

Let's add some http controllers using this feature. Controllers have typical behavior. It is registering routes. At first, will create an interface for it.

// Controller is an interface that can register its routes.
type Controller interface {
	RegisterRoutes(mux *http.ServeMux)

Now we will write controllers and implement Controller interface.

// OrderController is a http controller for orders.
type OrderController struct {}

// NewOrderController creates a auth http controller.
func NewOrderController() *OrderController {
	return &OrderController{}

// RegisterRoutes is a Controller interface implementation.
func (a *OrderController) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("/orders", a.RetrieveOrders)

// Retrieve loads orders and writes it to the writer.
func (a *OrderController) RetrieveOrders(writer http.ResponseWriter, request *http.Request) {
	// implementation
// UserController is a http endpoint for a user.
type UserController struct {}

// NewUserController creates a user http endpoint.
func NewUserController() *UserController {
	return &UserController{}

// RegisterRoutes is a Controller interface implementation.
func (e *UserController) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("/users", e.RetrieveUsers)

// Retrieve loads users and writes it using the writer.
func (e *UserController) RetrieveUsers(writer http.ResponseWriter, request *http.Request) {
    // implementation

Just like in the example with interfaces, we will use inject.As() provide option.

container := inject.New(
	inject.Provide(NewServer),        // provide http server
	inject.Provide(NewServeMux),       // provide http serve mux
	// endpoints
	inject.Provide(NewOrderController, inject.As(new(Controller))),  // provide order controller
	inject.Provide(NewUserController, inject.As(new(Controller))),  // provide user controller

Now, we can use []Controller group in our mux. See updated code:

// NewServeMux creates a new http serve mux.
func NewServeMux(controllers []Controller) *http.ServeMux {
	mux := &http.ServeMux{}

	for _, controller := range controllers {

	return mux

Advanced features

Named definitions

In some cases you have more than one instance of one type. For example two instances of database: master - for writing, slave - for reading.

First way is a wrapping types:

// MasterDatabase provide write database access.
type MasterDatabase struct {

// SlaveDatabase provide read database access.
type SlaveDatabase struct {

Second way is a using named definitions with inject.WithName() provide option:

// provide master database
inject.Provide(NewMasterDatabase, inject.WithName("master"))
// provide slave database
inject.Provide(NewSlaveDatabase, inject.WithName("slave"))

If you need to extract it from container use inject.Name() extract option.

var db *Database
container.Extract(&db, inject.Name("master"))

If you need to provide named definition in other constructor use di.Parameter with embedding.

// ServiceParameters
type ServiceParameters struct {
	// use `di` tag for the container to know that field need to be injected.
	MasterDatabase *Database `di:"master"`
	SlaveDatabase *Database  `di:"slave"`

// NewService creates new service with provided parameters.
func NewService(parameters ServiceParameters) *Service {
	return &Service{
		MasterDatabase:  parameters.MasterDatabase,
		SlaveDatabase: parameters.SlaveDatabase,

Optional parameters

Also di.Parameter provide ability to skip dependency if it not exists in container.

// ServiceParameter
type ServiceParameter struct {
	Logger *Logger `di:"optional"`

Constructors that declare dependencies as optional must handle the case of those dependencies being absent.

You can use naming and optional together.

// ServiceParameter
type ServiceParameter struct {
	StdOutLogger *Logger `di:"stdout"`
	FileLogger   *Logger `di:"file,optional"`

Parameter Bag

If you need to specify some parameters on definition level you can use inject.ParameterBag provide option. This is a map[string]interface{} that transforms to di.ParameterBag type.

// Provide server with parameter bag
inject.Provide(NewServer, inject.ParameterBag{
	"addr": ":8080",

// NewServer create a server with provided parameter bag. Note: use di.ParameterBag type.
// Not inject.ParameterBag.
func NewServer(pb di.ParameterBag) *http.Server {
	return &http.Server{
		Addr: pb.RequireString("addr"),


If you want to create a new instance on each extraction use inject.Prototype() provide option.

inject.Provide(NewRequestContext, inject.Prototype())

todo: real use case


If a provider creates a value that needs to be cleaned up, then it can return a closure to clean up the resource.

func NewFile(log Logger, path Path) (*os.File, func(), error) {
    f, err := os.Open(string(path))
    if err != nil {
        return nil, nil, err
    cleanup := func() {
        if err := f.Close(); err != nil {
    return f, cleanup, nil

After container.Cleanup() call, it iterate over instances and call cleanup function if it exists.

container := inject.New(
	// ...

// do something
container.Cleanup() // file was closed

Cleanup now work incorrectly with prototype providers.


Dependency graph may be presented via (Graphviz). For it, load string representation:

var graph *di.Graph
if err = container.Extract(&graph); err != nil {
    // handle err

dotGraph := graph.String() // use string representation

And paste it to graphviz online tool:


I will be glad if you contribute to this library. I don't know much English, so contributing to the documentation is very meaningful to me.

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected]