From d7ef4e8d24f161c13cb02a4ac5071501a71beb8e Mon Sep 17 00:00:00 2001 From: Richard Park Date: Mon, 2 Dec 2019 21:58:00 +0900 Subject: [PATCH] FieldAnnotation is added --- definitions.go | 31 +++++++++++++++++++++++++++++ go.mod | 2 +- go.sum | 4 ++-- registry.go | 53 +++++++++++++++++++++++++++++++++++++++++++++++++- types.go | 10 ++++++---- 5 files changed, 92 insertions(+), 8 deletions(-) diff --git a/definitions.go b/definitions.go index fd4d78c..6165539 100644 --- a/definitions.go +++ b/definitions.go @@ -16,6 +16,7 @@ type TypeDefinition struct { RealType reflect.Type TypeAnnotations map[reflect.Type]annotation.Annotation + FieldAnnotations map[string]map[reflect.Type]annotation.Annotation MethodAnnotations map[string]map[reflect.Type]annotation.Annotation Fields []*FieldDefinition } @@ -44,6 +45,36 @@ func (td *TypeDefinition) GetTypeAnnotationByType(at reflect.Type, includeEmbedd return nil } +func (td *TypeDefinition) GetFieldAnnotationByType(at reflect.Type, methodName string) annotation.Annotation { + if nil == td.FieldAnnotations { + return nil + } + + fs, ok := td.FieldAnnotations[methodName] + if !ok { + return nil + } + + return fs[at] +} + +func (td *TypeDefinition) GetFieldAnnotationsByType(at reflect.Type) map[string]annotation.Annotation { + if nil == td.FieldAnnotations { + return nil + } + + fas := make(map[string]annotation.Annotation) + for k, v := range td.FieldAnnotations { + a, ok := v[at] + if !ok { + continue + } + fas[k] = a + } + + return fas +} + func (td *TypeDefinition) GetMethodAnnotationByType(at reflect.Type, methodName string) annotation.Annotation { if nil == td.MethodAnnotations { return nil diff --git a/go.mod b/go.mod index 492f87e..164332e 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,6 @@ module git.loafle.net/loafer/di-go go 1.13 require ( - git.loafle.net/loafer/annotation-go v0.0.0-20191113135342-a3974dc21898 + git.loafle.net/loafer/annotation-go v0.0.0-20191202124147-cb9404f54278 git.loafle.net/loafer/util-go v0.0.0-20191113132317-6eeae49d258d ) diff --git a/go.sum b/go.sum index a471600..66e0c27 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,5 @@ -git.loafle.net/loafer/annotation-go v0.0.0-20191113135342-a3974dc21898 h1:3moCEHhGfzHTQVBde+IkvB42oDGUdpCDkBWjN5ZnoL8= -git.loafle.net/loafer/annotation-go v0.0.0-20191113135342-a3974dc21898/go.mod h1:1yow6wwbB3nWq6Asgt3BAPfXJTjZeqgMYF+VVPlj9Xk= +git.loafle.net/loafer/annotation-go v0.0.0-20191202124147-cb9404f54278 h1:ncGi8FZ/raFuzqR9689YyLQqM4Tq639c8jL1p4rjtfY= +git.loafle.net/loafer/annotation-go v0.0.0-20191202124147-cb9404f54278/go.mod h1:1yow6wwbB3nWq6Asgt3BAPfXJTjZeqgMYF+VVPlj9Xk= git.loafle.net/loafer/util-go v0.0.0-20191112142134-9a567d18b779/go.mod h1:HGVw9FNJIc/UFDIzxmoIj5K2+D9Eadal5jjHOq0NFOU= git.loafle.net/loafer/util-go v0.0.0-20191113132317-6eeae49d258d h1:ESDbDHHzH2Ysq+thQrO/OQtyDkVhzNzshjn0SJIqa0g= git.loafle.net/loafer/util-go v0.0.0-20191113132317-6eeae49d258d/go.mod h1:HGVw9FNJIc/UFDIzxmoIj5K2+D9Eadal5jjHOq0NFOU= diff --git a/registry.go b/registry.go index b1e5cd8..7b28872 100644 --- a/registry.go +++ b/registry.go @@ -26,6 +26,8 @@ type Regist interface { GetInstancesByAnnotationType(t reflect.Type) ([]interface{}, error) GetTypeAnnotation(instanceType reflect.Type, annotationType reflect.Type) annotation.Annotation + GetFieldAnnotation(instanceType reflect.Type, annotationType reflect.Type, methodName string) annotation.Annotation + GetFieldAnnotations(instanceType reflect.Type, annotationType reflect.Type) map[string]annotation.Annotation GetMethodAnnotation(instanceType reflect.Type, annotationType reflect.Type, methodName string) annotation.Annotation GetMethodAnnotations(instanceType reflect.Type, annotationType reflect.Type) map[string]annotation.Annotation } @@ -274,6 +276,30 @@ func (r *Registry) GetTypeAnnotation(instanceType reflect.Type, annotationType r return def.GetTypeAnnotationByType(annotationType, false) } +func GetFieldAnnotation(instanceType reflect.Type, annotationType reflect.Type, methodName string) annotation.Annotation { + return registry.GetFieldAnnotation(instanceType, annotationType, methodName) +} +func (r *Registry) GetFieldAnnotation(instanceType reflect.Type, annotationType reflect.Type, methodName string) annotation.Annotation { + def, ok := r.definitionByType[instanceType] + if !ok { + return nil + } + + return def.GetFieldAnnotationByType(annotationType, methodName) +} + +func GetFieldAnnotations(instanceType reflect.Type, annotationType reflect.Type) map[string]annotation.Annotation { + return registry.GetFieldAnnotations(instanceType, annotationType) +} +func (r *Registry) GetFieldAnnotations(instanceType reflect.Type, annotationType reflect.Type) map[string]annotation.Annotation { + def, ok := r.definitionByType[instanceType] + if !ok { + return nil + } + + return def.GetFieldAnnotationsByType(annotationType) +} + func GetMethodAnnotation(instanceType reflect.Type, annotationType reflect.Type, methodName string) annotation.Annotation { return registry.GetMethodAnnotation(instanceType, annotationType, methodName) } @@ -333,9 +359,14 @@ func parseFields(t reflect.Type, td *TypeDefinition) { } parseFields(f.Type, td) } else { - if parseMethodAnnotation(&f, td) { + if annotation.FieldAnnotationType == f.Type && parseFieldAnnotation(&f, td) { continue } + + if annotation.MethodAnnotationType == f.Type && parseMethodAnnotation(&f, td) { + continue + } + as, err := annotation.Parse(f.Tag) if nil != err { return @@ -384,6 +415,26 @@ func parseTypeAnnotation(f *reflect.StructField, td *TypeDefinition) bool { return false } +func parseFieldAnnotation(f *reflect.StructField, td *TypeDefinition) bool { + if annotation.FieldAnnotationType != f.Type { + return false + } + + as, err := annotation.Parse(f.Tag) + if nil != err { + return false + } + + if nil != as && 0 < len(as) { + if nil == td.FieldAnnotations { + td.FieldAnnotations = make(map[string]map[reflect.Type]annotation.Annotation, 0) + } + td.FieldAnnotations[f.Name[1:]] = as + return true + } + return false +} + func parseMethodAnnotation(f *reflect.StructField, td *TypeDefinition) bool { if annotation.MethodAnnotationType != f.Type { return false diff --git a/types.go b/types.go index b8bd66e..144922d 100644 --- a/types.go +++ b/types.go @@ -24,9 +24,10 @@ var ComponentAnnotationType = reflect.TypeOf((*ComponentAnnotation)(nil)) type ComponentAnnotation struct { annotation.TypeAnnotation `@annotation:"@Component"` - Name string `json:"name"` - InitMethod string `json:"initMethod"` // func (receiver interface{}, cr ComponentRegistry) error - DestroyMethod string `json:"destroyMethod"` // func (receiver interface{}, cr ComponentRegistry) error + + Name string `json:"name"` + InitMethod string `json:"initMethod"` // func (receiver interface{}, cr ComponentRegistry) error + DestroyMethod string `json:"destroyMethod"` // func (receiver interface{}, cr ComponentRegistry) error } var InjectAnnotationType = reflect.TypeOf((*InjectAnnotation)(nil)) @@ -41,5 +42,6 @@ var ResourceAnnotationType = reflect.TypeOf((*ResourceAnnotation)(nil)) type ResourceAnnotation struct { annotation.TypeAnnotation `@annotation:"@Resource"` - Name string `json:"name"` + + Name string `json:"name"` }