dix

README

dix 中文

dix is a dependency injection tool based on the design of dig.

The main difference between dix and dig is that dix can complete more complex dependency injection management and better dependency isolation relying on namespace, and dix can also dynamically bind objects to dependent functions, object change notifications, etc.

dix is very convenient to use, through Dix you can publish and update objects and monitor binding, etc.

CHANGELOG

example

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/pubgo/dix"
	"github.com/pubgo/xerror"
)

type Hello interface {
	Hello()
}

type testHello struct {
	i int
}

func (t testHello) Hello() {
	fmt.Println("config testHello")
}

type Config struct {
	Prefix string
}

func (Config) Hello() {
	fmt.Println("Hello Config")
}

func init() {
	dix.Go(func(h *testHello) {
		fmt.Println("h *testHello")
	})

	xerror.Exit(dix.Dix(func(h Hello) {
		h.Hello()
	}))

	xerror.Exit(dix.Dix(func(cfg *Config) (*log.Logger, error) {
		fmt.Println("cfg *Config")
		return log.New(os.Stdout, cfg.Prefix, log.Llongfile), nil
	}))

	xerror.Exit(dix.Dix(func(l *log.Logger) {
		l.Print("You've been invoked")
	}))

	type ll struct {
		L *log.Logger
		H Hello
	}
	xerror.Exit(dix.Dix(func(l ll) {
		l.L.Print("You've been invoked")
		l.H.Hello()
	}))
}

func main() {
	i := 0
	for {
		var cfg Config
		xerror.Exit(json.Unmarshal([]byte(fmt.Sprintf(`{"prefix": "[foo%d] "}`, i)), &cfg))
		dix.Go(&cfg)

		fmt.Println(dix.Graph())
		fmt.Print("==================================================================================\n")
		time.Sleep(time.Second)
		xerror.Exit(dix.Dix(&testHello{i: i}))
		fmt.Println(dix.Graph())
		time.Sleep(time.Second)
		i++
	}
}

Documentation

Index

• func Dix(data ...interface{}) error
• func Go(data ...interface{})
• func Graph() string
• func Init(opts ...Option) error
• func New(opts ...Option) *dix
• func Start() error
• func Stop() error
• type Option
  • func WithAllowNil(nilValueAllowed bool) Option
  • func WithInvoker(invoker invokerFn) Option
  • func WithRand(r *rand.Rand) Option
  • func WithStrict(strict bool) Option
• type Options
• type StartCtx
• type StopCtx

Functions

func Dix

func Dix(data ...interface{}) error

Dix ...

func Go

func Go(data ...interface{})

Go the dix must be ok

func Graph

func Graph() string

Graph dix graph

func Init

func Init(opts ...Option) error

Init ...

func New

func New(opts ...Option) *dix

func Start

func Start() error

func Stop

func Stop() error

Types

type Option

type Option func(c *Options)

func WithAllowNil

func WithAllowNil(nilValueAllowed bool) Option

func WithInvoker

func WithInvoker(invoker invokerFn) Option

func WithRand

func WithRand(r *rand.Rand) Option

func WithStrict

func WithStrict(strict bool) Option

type Options

type Options struct {
	Rand            *rand.Rand
	InvokerFn       invokerFn
	NilValueAllowed bool
	Strict          bool
}

type StartCtx

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

type StopCtx

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