di

type Constructor ¶

type Constructor interface{}

Constructor is a function with follow signature:

func NewHTTPServer(addr string, handler http.Handler) (server *http.Server, cleanup func(), err error) {
	server := &http.Server{
		Addr: addr,
	}
	cleanup = func() {
		server.Close()
	}
	return server, cleanup, nil
}

This constructor function teaches container how to build server. Arguments (addr and handler) in this function is a dependencies. They will be resolved automatically when someone needs a server. Constructor may have unlimited count of dependencies, but note that container should know how build each of them. Second result of this function is a optional cleanup callback. It describes that container will do on shutdown. Third result is a optional error. Sometimes our types cannot be constructed.

type Container ¶

type Container struct {
	// contains filtered or unexported fields
}

Container is a dependency injection container.

func New(options ...Option) (_ *Container, err error)

func NewHTTPServer(mux *http.ServeMux) *http.Server {
	return &http.Server{
		Handler: mux,
	}
}

func NewHTTPServeMux() *http.ServeMux {
	return http.ServeMux{}
}

func StartServer(server *http.Server) error {
	return server.ListenAndServe()
}

container, err := di.New(
	di.Provide(NewHTTPServer),
	di.Provide(NewHTTPServeMux),
	di.Invoke(StartServer),
)
if err != nil {
	// handle error
}

func (c *Container) AddParent(parent *Container) error

func (c *Container) Apply(options ...Option) error

err := container.Apply(
	di.Provide(NewHTTPServer),
)
if err != nil {
	// handle error
}

func (c *Container) Cleanup()

func (c *Container) Has(target Pointer, options ...ResolveOption) (bool, error)

var server *http.Server
if container.Has(&server) {
	// handle server existence
}

func (c *Container) Invoke(invocation Invocation, options ...InvokeOption) error

func (c *Container) Iterate(target Pointer, fn IterateFunc, options ...ResolveOption) error

 var servers []*http.Server
 iterFn := func(tags di.Tags, loader ValueFunc) error {
		i, err := loader()
		if err != nil {
			return err
		}
		// do stuff with result: i.(*http.Server)
		return nil
 }
 container.Iterate(&servers, iterFn)

func (c *Container) Provide(constructor Constructor, options ...ProvideOption) error

func (c *Container) ProvideValue(value Value, options ...ProvideOption) error

func (c *Container) Resolve(ptr Pointer, options ...ResolveOption) error

var server *http.Server
if err := container.Resolve(&server); err != nil {
	// handle error
}

type Decorator ¶ added in v1.11.0

type Decorator func(value Value) error

Decorator can modify container instance.

type Inject ¶ added in v1.1.0

type Inject struct {
	// contains filtered or unexported fields
}

Inject indicates that struct public fields will be injected automatically.

type Application struct {
	di.Inject

	Server *http.Server // will be injected
}

You can specify tags for injected types:

 type Application struct {
 	di.Inject

	Public 	*http.Server `type:"public"` 	// *http.Server with type:public tag combination will be injected
	Private *http.Server `type:"private"` 	// *http.Server with type:private tag combination will be injected
 }

type Interface ¶

type Interface interface{}

Interface is a pointer to interface, like new(http.Handler). Tell container that provided type may be used as interface.

type Invocation ¶

type Invocation interface{}

Invocation is a function whose signature looks like:

func StartServer(server *http.Server) error {
	return server.ListenAndServe()
}

Like a constructor invocation may have unlimited count of arguments and they will be resolved automatically. The invocation can return an optional error. Error will be returned as is.

type InvokeOption ¶

type InvokeOption interface {
	// contains filtered or unexported methods
}

InvokeOption is a functional option interface that modify invoke behaviour.

type InvokeParams ¶

type InvokeParams struct {
	// The function
	Fn interface{}
}

InvokeParams is a invoke parameters.

type IterateFunc ¶ added in v1.4.0

type IterateFunc func(tags Tags, value ValueFunc) error

IterateFunc function that will be called on each instance in iterate selection.

type Option ¶

type Option interface {
	// contains filtered or unexported methods
}

Option is a functional option that configures container. If you don't know about functional options, see https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis. Below presented all possible options with their description:

• di.Provide - provide constructors
• di.ProvideValue - provide value
• di.Invoke - add invocations
• di.Resolve - resolves type

func Invoke(fn Invocation, options ...InvokeOption) Option

func Options(options ...Option) Option

account := di.Options(
  di.Provide(NewAccountController),
  di.Provide(NewAccountRepository),
)
auth := di.Options(
  di.Provide(NewAuthController),
  di.Provide(NewAuthRepository),
)
container, err := di.New(
  account,
  auth,
)
if err != nil {
  // handle error
}

func Provide(constructor Constructor, options ...ProvideOption) Option

func ProvideValue(value Value, options ...ProvideOption) Option

func Resolve(target Pointer, options ...ResolveOption) Option

type Pointer ¶ added in v1.3.0

type Pointer interface{}

type ProvideOption ¶

type ProvideOption interface {
	// contains filtered or unexported methods
}

ProvideOption is a functional option interface that modify provide behaviour. See di.As(), di.WithName().

func As(interfaces ...Interface) ProvideOption

func NewServeMux() *http.ServeMux {
	return &http.ServeMux{}
}

func NewServer(handler *http.Handler) *http.Server {
	return &http.Server{
		Handler: handler,
	}
}

container, err := di.New(
	di.Provide(NewServer),
	di.Provide(NewServeMux, di.As(new(http.Handler)),
)
if err != nil {
	// handle error
}
var server *http.Server
if err := container.Resolve(&http.Server); err != nil {
	// handle error
}

var handlers []http.Handler
if err := container.Resolve(&handlers); err != nil {
	// handle error
}

func Decorate(decorators ...Decorator) ProvideOption

func WithName(name string) ProvideOption

type ProvideParams ¶

type ProvideParams struct {
	Tags       Tags
	Interfaces []Interface
	Decorators []Decorator
}

ProvideParams is a Provide() method options. Name is a unique identifier of type instance. Provider is a constructor function. Interfaces is a interface that implements a provider result type.

type ResolveOption ¶

type ResolveOption interface {
	// contains filtered or unexported methods
}

ResolveOption is a functional option interface that modify resolve behaviour.

func Name(name string) ResolveOption

type ResolveParams ¶

type ResolveParams struct {
	Tags Tags
}

ResolveParams is a resolve parameters.

type StdTracer ¶ added in v1.6.0

type StdTracer struct {
}

StdTracer traces dependency injection cycle to stdout.

func (s StdTracer) Trace(format string, args ...interface{})

type Tags ¶ added in v1.3.0

type Tags map[string]string

Tags is a string representation of key value pairs.

type Server struct {
	di.Tags `http:"true" server:"true"`
}
_, err := di.New(
	di.Provide(func() *Server { return &Server{} }),
)
var s *Server
c.Resolve(&s, di.Tags{"http": "true", "server": "true"})

func (t Tags) String() string

type Tracer ¶ added in v1.6.0

type Tracer interface {
	// Trace prints library logs.
	Trace(format string, args ...interface{})
}

Tracer traces dependency injection cycle.

type Value ¶ added in v1.9.0

type Value interface{}

Value is a variable of provided or resolved type.

type ValueFunc ¶ added in v1.4.0

type ValueFunc func() (interface{}, error)

ValueFunc is a lazy-loading wrapper for iteration.