func GetAnnotations(object interface{}) (annotations *Annotations) {
	if object == nil {
		return
	}
	reflectType, ok := reflector.GetObjectType(object)
	if ok {
		ov := reflector.IndirectValue(object)
		reflectObject := &types.ReflectObject{
			Interface: object,
			Type:      reflectType,
			Value:     ov,
		}
		if reflectType.Kind() == reflect.Struct {
			annotations = new(Annotations)
			for i := 0; i < reflectType.NumField(); i++ {
				ann := new(Annotation)
				ann.Field = new(Field)
				f := reflectType.Field(i)
				typ := f.Type
				iTyp := reflector.IndirectType(typ)
				if f.Anonymous {
					_, ok = reflector.GetEmbeddedFieldByType(typ, at.Annotation{}, reflect.Struct)
					if ok {
						if ov.IsValid() && ov.CanAddr() && ov.Type().Kind() == reflect.Struct{
							ann.Field.Value = ov.FieldByName(f.Name)
						}
						ann.Field.StructField = f
						ann.Parent = reflectObject
						annotations.Items = append(annotations.Items, ann)
					}
				} else {
					if iTyp.Name() == "" && typ.Kind() == reflect.Struct {
						fieldObjVal := ov.FieldByName(f.Name)
						if f.Name == strings.Title(f.Name) {
							childAnnotations := GetAnnotations(fieldObjVal.Addr().Interface())
							annotations.Children = append(annotations.Children, childAnnotations)
						}
					}
				}
			}
		}
	}
	return
}
GetAnnotations iterate annotations of a struct
package annotation
import (
	"fmt"
	"hidevops.io/hiboot/pkg/at"
	"hidevops.io/hiboot/pkg/log"
	"hidevops.io/hiboot/pkg/types"
	"hidevops.io/hiboot/pkg/utils/mapstruct"
	"hidevops.io/hiboot/pkg/utils/reflector"
	"hidevops.io/hiboot/pkg/utils/str"
	"hidevops.io/hiboot/pkg/utils/structtag"
	"reflect"
	"strings"
)
type Field struct{
	StructField reflect.StructField
	Value reflect.Value
}
type Annotation struct{
	Field *Field
	Parent *types.ReflectObject
}
type Annotations struct{
	Items    []*Annotation
	Children []*Annotations
}
func IsAnnotation(object interface{}) (yes bool)  {
	typ, ok := reflector.GetObjectType(object)
	if !ok {
		return
	}
	annTyp := reflect.TypeOf(at.Annotation{})
	if typ == annTyp {
		yes = true
		return
	}
	k := typ.Kind()
	if k == reflect.Struct {
		numField := typ.NumField()
		for i := 0; i < numField; i++ {
			v := typ.Field(i)
			if v.Anonymous {
				if v.Type == annTyp {
					yes = true
					break
				}
			}
		}
	}
	return
}
func GetAnnotation(object interface{}, att interface{}) (annotation *Annotation) {
	if object == nil {
		return
	}
	atType := reflect.TypeOf(att)
	switch object.(type) {
	case *Annotations:
		ans := object.(*Annotations)
		if ans == nil {
			return
		}
		for _, item := range ans.Items {
			if item.Field.StructField.Type == atType {
				annotation = item
				return
			}
		}
	}
	structField, ok := reflector.GetEmbeddedFieldType(object, att)
	if ok {
		fieldType := reflector.IndirectType(structField.Type)
		if atType != reflect.TypeOf(at.Annotation{}) {
			_, ok = reflector.GetEmbeddedFieldByType(fieldType, at.Annotation{}, reflect.Struct)
		}
		if ok {
			ov := reflector.IndirectValue(object)
			reflectObject := &types.ReflectObject{
				Interface: object,
				Type:      fieldType,
				Value:     ov,
			}
			annotation = new(Annotation)
			annotation.Field = new(Field)
			if ov.IsValid() && ov.CanAddr() && ov.Type().Kind() == reflect.Struct {
				annotation.Field.Value = ov.FieldByName(fieldType.Name())
			}
			annotation.Field.StructField = structField
			annotation.Parent = reflectObject
		}
	}
	return
}