init

Author: yoyofx

.gitignore

@@ -0,0 +1,2 @@
+.idea
+*.sum

default_serviceprovider.go

@@ -0,0 +1,36 @@
+package dependencyinjection
+
+import (
+	"github.com/goava/di"
+	"unsafe"
+)
+
+type DefaultServiceProvider struct {
+	container *di.Container
+}
+
+func (d DefaultServiceProvider) GetService(refObject interface{}) (err error) {
+	err = d.container.Resolve(refObject)
+	return err
+}
+
+func (d DefaultServiceProvider) GetServiceByName(refObject interface{}, name string) (err error) {
+	err = d.container.Resolve(refObject, di.Name(name))
+	return err
+}
+
+func (d DefaultServiceProvider) GetServiceByTags(refObject interface{}, tags map[string]string) (err error) {
+	p := unsafe.Pointer(&tags)
+	var tag di.Tags
+	tag = *(*di.Tags)(p)
+	err = d.container.Resolve(refObject, tag)
+	return err
+}
+
+func (d DefaultServiceProvider) GetGraph() string {
+	return ""
+}
+
+func (d DefaultServiceProvider) InvokeService(fn interface{}) error {
+	return d.container.Invoke(fn)
+}

default_serviceprovider_factory.go

@@ -0,0 +1,30 @@
+package dependencyinjection
+
+import (
+	"github.com/goava/di"
+)
+
+func (sc ServiceCollection) Build() IServiceProvider {
+	var providers []di.Option
+	for _, desc := range sc.serviceDescriptors {
+
+		var providerOptions []di.ProvideOption
+		if desc.Implements != nil {
+			providerOptions = append(providerOptions, di.As(desc.Implements))
+		}
+		if desc.Name != "" {
+			providerOptions = append(providerOptions, di.WithName(desc.Name))
+		}
+		//prototype is create a new instance on each call.
+		if desc.Lifetime != Singleton {
+			//providerOptions = append(providerOptions)
+		}
+
+		provider := di.Provide(desc.Provider, providerOptions...)
+		providers = append(providers, provider)
+
+	}
+	container, _ := di.New(providers...)
+
+	return &DefaultServiceProvider{container}
+}

di_test.go

@@ -0,0 +1,49 @@
+package dependencyinjection
+
+import (
+	"github.com/goava/di"
+	"github.com/magiconair/properties/assert"
+	"math/rand"
+	"strconv"
+	"testing"
+	"time"
+	"unsafe"
+)
+
+type A struct {
+	Name string
+}
+
+var ls string
+
+func NewA() *A {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	ls = "A-" + strconv.Itoa(r.Int())
+	return &A{Name: ls}
+}
+
+func Test_DI_Register(t *testing.T) {
+	services := NewServiceCollection()
+
+	services.AddSingleton(NewA)
+
+	serviceProvider := services.Build()
+
+	var env *A
+	_ = serviceProvider.GetService(&env)
+	assert.Equal(t, env.Name, ls)
+
+	_ = serviceProvider.GetService(&env)
+	assert.Equal(t, env.Name, ls)
+
+	_ = serviceProvider.GetService(&env)
+	assert.Equal(t, env.Name, ls)
+}
+
+func Test_MapConvertTags(t *testing.T) {
+	tags := map[string]string{"name": "A1"}
+	p := unsafe.Pointer(&tags)
+	var tag di.Tags
+	tag = *(*di.Tags)(p)
+	assert.Equal(t, tag != nil, true)
+}

go.mod

@@ -0,0 +1,10 @@
+module github.com/yoyofxteam/dependencyinjection
+
+go 1.16
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/goava/di v1.10.0
+	github.com/magiconair/properties v1.8.5
+	github.com/yoyofxteam/reflectx v0.2.3
+)

servicecollection.go

@@ -0,0 +1,81 @@
+package dependencyinjection
+
+import (
+	"github.com/yoyofxteam/reflectx"
+	"strings"
+)
+
+type ServiceCollection struct {
+	serviceDescriptors    []*ServiceDescriptor
+	serviceDescriptorMaps map[string]int
+}
+
+func NewServiceCollection() *ServiceCollection {
+	return &ServiceCollection{serviceDescriptorMaps: make(map[string]int)}
+}
+
+//Singleton
+//Scoped
+//Transient
+func (sc *ServiceCollection) AddServiceDescriptor(sd *ServiceDescriptor) {
+	typeName := sd.Name
+	if typeName == "" {
+		typeName, _ = reflectx.GetCtorFuncOutTypeName(sd.Provider)
+		typeName = strings.ToLower(typeName)
+	}
+
+	index := len(sc.serviceDescriptors)
+	defIndex, exist := sc.serviceDescriptorMaps[typeName]
+	if exist {
+		sc.serviceDescriptors[defIndex] = sd
+	} else {
+		sc.serviceDescriptorMaps[typeName] = index
+		sc.serviceDescriptors = append(sc.serviceDescriptors, sd)
+	}
+}
+
+func (sc *ServiceCollection) AddSingleton(provider interface{}) {
+	sd := NewServiceDescriptorByProvider(provider, Singleton)
+	sc.AddServiceDescriptor(sd)
+}
+
+func (sc *ServiceCollection) AddSingletonAndName(name string, provider interface{}) {
+	sc.AddSingletonByName(name, provider)
+	sc.AddSingleton(provider)
+}
+
+func (sc *ServiceCollection) AddSingletonByName(name string, provider interface{}) {
+	sd := NewServiceDescriptorByName(name, provider, Singleton)
+	sc.AddServiceDescriptor(sd)
+}
+
+func (sc *ServiceCollection) AddSingletonByImplementsAndName(name string, provider interface{}, implements interface{}) {
+	sc.AddSingletonByName(name, provider)
+	sc.AddSingletonByImplements(provider, implements)
+}
+
+func (sc *ServiceCollection) AddSingletonByImplements(provider interface{}, implements interface{}) {
+	sd := NewServiceDescriptorByImplements(provider, implements, Singleton)
+	sc.AddServiceDescriptor(sd)
+}
+
+func (sc *ServiceCollection) AddSingletonByNameAndImplements(name string, provider interface{}, implements interface{}) {
+	sd := NewServiceDescriptorByImplements(provider, implements, Singleton)
+	sd.Name = name
+	sc.AddServiceDescriptor(sd)
+}
+
+func (sc *ServiceCollection) AddTransient(provider interface{}) {
+	sd := NewServiceDescriptorByProvider(provider, Transient)
+	sc.AddServiceDescriptor(sd)
+}
+
+func (sc *ServiceCollection) AddTransientByName(name string, provider interface{}) {
+	sd := NewServiceDescriptorByName(name, provider, Transient)
+	sc.AddServiceDescriptor(sd)
+}
+
+func (sc *ServiceCollection) AddTransientByImplements(provider interface{}, implements interface{}) {
+	sd := NewServiceDescriptorByImplements(provider, implements, Transient)
+	sc.AddServiceDescriptor(sd)
+}

servicedescriptor.go

@@ -0,0 +1,24 @@
+package dependencyinjection
+
+type ServiceDescriptor struct {
+	Name       string
+	Provider   interface{}
+	Implements interface{}
+	Lifetime   ServiceLifetime
+}
+
+func NewServiceDescriptor(name string, provider interface{}, implements interface{}, lifetime ServiceLifetime) *ServiceDescriptor {
+	return &ServiceDescriptor{Name: name, Provider: provider, Implements: implements, Lifetime: lifetime}
+}
+
+func NewServiceDescriptorByProvider(provider interface{}, lifetime ServiceLifetime) *ServiceDescriptor {
+	return &ServiceDescriptor{Provider: provider, Lifetime: lifetime}
+}
+
+func NewServiceDescriptorByName(name string, provider interface{}, lifetime ServiceLifetime) *ServiceDescriptor {
+	return &ServiceDescriptor{Name: name, Provider: provider, Lifetime: lifetime}
+}
+
+func NewServiceDescriptorByImplements(provider interface{}, implements interface{}, lifetime ServiceLifetime) *ServiceDescriptor {
+	return &ServiceDescriptor{Provider: provider, Implements: implements, Lifetime: lifetime}
+}

servicelifetime.go

@@ -0,0 +1,9 @@
+package dependencyinjection
+
+type ServiceLifetime int32
+
+const (
+	Singleton ServiceLifetime = 0
+	Scoped    ServiceLifetime = 1
+	Transient ServiceLifetime = 2
+)

serviceprovider.go

@@ -0,0 +1,9 @@
+package dependencyinjection
+
+type IServiceProvider interface {
+	GetService(refObject interface{}) error
+	GetServiceByName(refObject interface{}, name string) error
+	GetServiceByTags(refObject interface{}, tags map[string]string) (err error)
+	GetGraph() string
+	InvokeService(fn interface{}) error
+}

serviceprovider_factory.go

@@ -0,0 +1,5 @@
+package dependencyinjection
+
+type IServiceProviderFactory interface {
+	CreateServiceProvider() IServiceProvider
+}