155 lines
3.5 KiB
Go
155 lines
3.5 KiB
Go
package registry
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"reflect"
|
|
|
|
cda "git.loafle.net/commons_go/di/annotation"
|
|
cdur "git.loafle.net/commons_go/di/util/reflect"
|
|
"git.loafle.net/commons_go/logging"
|
|
)
|
|
|
|
func init() {
|
|
registry = newRegistry()
|
|
}
|
|
|
|
var registry ComponentRegistry
|
|
|
|
type ComponentRegistry interface {
|
|
RegisterType(t reflect.Type, ca *cda.ComponentAnnotation)
|
|
|
|
GetInstance(t reflect.Type) (interface{}, error)
|
|
GetInstanceByName(name string) (interface{}, error)
|
|
}
|
|
|
|
func newRegistry() ComponentRegistry {
|
|
r := &defaultComponentRegistry{}
|
|
r.definitionByType = make(map[reflect.Type]*TypeDefinition, 0)
|
|
r.definitionByName = make(map[string]*TypeDefinition, 0)
|
|
|
|
return r
|
|
}
|
|
|
|
type defaultComponentRegistry struct {
|
|
definitionByType map[reflect.Type]*TypeDefinition
|
|
definitionByName map[string]*TypeDefinition
|
|
}
|
|
|
|
func RegisterType(t reflect.Type, ca *cda.ComponentAnnotation) {
|
|
registry.RegisterType(t, ca)
|
|
}
|
|
func (cr *defaultComponentRegistry) RegisterType(t reflect.Type, ca *cda.ComponentAnnotation) {
|
|
if nil == t {
|
|
logging.Logger().Panic("DI: t[reflect.Type] is nil")
|
|
}
|
|
if !cdur.IsTypeKind(t, reflect.Struct, true) {
|
|
logging.Logger().Panic(fmt.Sprintf("DI: t[reflect.Type] must be specified but is %v", t))
|
|
}
|
|
|
|
td, err := cr.buildDefinition(t)
|
|
if nil != err {
|
|
logging.Logger().Panic(fmt.Sprintf("DI: %v", err))
|
|
}
|
|
|
|
if _, ok := cr.definitionByType[td.RealType]; ok {
|
|
logging.Logger().Panic(fmt.Sprintf("DI: The type[%s] of Component is exist already", td.FullName))
|
|
}
|
|
cr.definitionByType[td.RealType] = td
|
|
|
|
names := make([]string, 0)
|
|
if nil != ca {
|
|
if nil != ca.Names && 0 < len(ca.Names) {
|
|
for _, n := range ca.Names {
|
|
names = append(names, n)
|
|
}
|
|
}
|
|
}
|
|
if 0 == len(names) {
|
|
names = append(names, td.FullName)
|
|
}
|
|
|
|
for _, n := range names {
|
|
if eTD, ok := cr.definitionByName[n]; ok {
|
|
logging.Logger().Panic(fmt.Sprintf("DI: The name[%s] of Component is exist already type[%s]", n, eTD.FullName))
|
|
}
|
|
cr.definitionByName[n] = td
|
|
}
|
|
}
|
|
|
|
func GetInstance(t reflect.Type) (interface{}, error) {
|
|
return registry.GetInstance(t)
|
|
}
|
|
func (cr *defaultComponentRegistry) GetInstance(t reflect.Type) (interface{}, error) {
|
|
if nil == t {
|
|
return nil, fmt.Errorf("DI: t[reflect.Type] is nil")
|
|
}
|
|
|
|
var err error
|
|
|
|
rt, _, _ := cdur.GetTypeInfo(t)
|
|
td, ok := cr.definitionByType[rt]
|
|
if !ok {
|
|
td, err = cr.buildDefinition(t)
|
|
if nil != err {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
log.Printf("%v", td)
|
|
|
|
return nil, nil
|
|
}
|
|
|
|
func GetInstanceByName(name string) (interface{}, error) {
|
|
return registry.GetInstanceByName(name)
|
|
}
|
|
func (cr *defaultComponentRegistry) GetInstanceByName(name string) (interface{}, error) {
|
|
|
|
return nil, nil
|
|
}
|
|
|
|
func (cr *defaultComponentRegistry) buildDefinition(t reflect.Type) (*TypeDefinition, error) {
|
|
if nil == t {
|
|
return nil, fmt.Errorf("t[reflect.Type] is nil")
|
|
}
|
|
|
|
rt, pkgName, tName := cdur.GetTypeInfo(t)
|
|
cd := &TypeDefinition{}
|
|
cd.FullName = FullName(pkgName, tName)
|
|
cd.PkgName = pkgName
|
|
cd.TypeName = tName
|
|
cd.Type = t
|
|
cd.RealType = rt
|
|
|
|
nf := rt.NumField()
|
|
if 0 < nf {
|
|
fields := make(map[string]*FieldDefinition)
|
|
for i := 0; i < nf; i++ {
|
|
f := rt.Field(i)
|
|
as, err := cda.ParseAnnotation(f.Tag)
|
|
if nil != err {
|
|
return nil, err
|
|
}
|
|
if nil != as && 0 < len(as) {
|
|
fRT, fPkgName, fTName := cdur.GetTypeInfo(f.Type)
|
|
|
|
fd := &FieldDefinition{
|
|
PkgName: fPkgName,
|
|
TypeName: fTName,
|
|
Type: f.Type,
|
|
RealType: fRT,
|
|
Annotations: as,
|
|
}
|
|
fields[f.Name] = fd
|
|
}
|
|
}
|
|
|
|
if 0 < len(fields) {
|
|
cd.Fields = fields
|
|
}
|
|
}
|
|
|
|
return cd, nil
|
|
}
|