Documentation ¶
Overview ¶
Package structs provides a common policy to call a handler dynamically by the struct field tag.
Index ¶
- Variables
- func Reflect(structValuePtr any) error
- func ReflectContext(ctx, structValuePtr any) error
- func ReflectValue(structValue reflect.Value) error
- func ReflectValueContext(ctx any, structValue reflect.Value) error
- func Register(name string, handler handler.Handler)
- func RegisterRunner(name string, handler handler.Runner)
- func Unregister(name string)
- type Reflector
- func (r *Reflector) Reflect(structValuePtr any) error
- func (r *Reflector) ReflectContext(ctx, structValuePtr any) error
- func (r *Reflector) ReflectValue(value reflect.Value) error
- func (r *Reflector) ReflectValueContext(ctx any, value reflect.Value) error
- func (r *Reflector) Register(name string, handler handler.Handler)
- func (r *Reflector) Unregister(name string)
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var DefaultReflector = NewReflector()
DefaultReflector is the default global struct field reflector.
Functions ¶
func ReflectContext ¶ added in v0.2.0
ReflectContext is equal to DefaultReflector.ReflectContext(ctx, structValuePtr).
func ReflectValue ¶
ReflectValue is equal to ReflectValueContext(nil, structValue).
func ReflectValueContext ¶ added in v0.2.0
ReflectValueContext is equal to DefaultReflector.ReflectValueContext(ctx, structValue).
func RegisterRunner ¶ added in v0.3.0
RegisterRunner is equal to Register(name, handler).
func Unregister ¶
func Unregister(name string)
Unregister is equal to DefaultReflector.Unregister(name).
Types ¶
type Reflector ¶
type Reflector struct {
// contains filtered or unexported fields
}
Reflector is used to reflect the tags of the fields of the struct and call the field handler by the tag name with the tag value.
Example ¶
parseInt := func(s string) (interface{}, error) { return strconv.ParseInt(s, 10, 64) } compareInt := func(isMin bool) handler.Runner { return func(_ interface{}, _, v reflect.Value, t reflect.StructField, a interface{}) error { value := v.Interface().(int64) if isMin { if min := a.(int64); value < min { return fmt.Errorf("%s: the value %d is less then %d", t.Name, value, min) } } else { if max := a.(int64); value > max { return fmt.Errorf("%s: the value %d is greater then %d", t.Name, value, max) } } return nil } } sf := NewReflector() sf.Register("min", handler.New(parseInt, compareInt(true))) sf.Register("max", handler.New(parseInt, compareInt(false))) sf.Register("default", handler.SimpleRunner(func(v reflect.Value, s interface{}) error { if !v.IsZero() { return nil } i, err := strconv.ParseInt(s.(string), 10, 64) if err != nil { return fmt.Errorf("invalid default value '%s': %s", s, err) } v.SetInt(i) return nil })) sf.Register("datamask", handler.SimpleRunner(func(v reflect.Value, s interface{}) error { switch s.(string) { case "username": name := v.Interface().(string) if r, _ := utf8.DecodeRuneInString(name); r != utf8.RuneError { v.SetString(string(r) + "**") } else { return fmt.Errorf("the name is not utf8") } case "password": v.SetString("******") default: return fmt.Errorf("unknown datamust type '%v'", s) } return nil })) /// Example 1: Check and validate the request arguments type Request struct { Page int64 `default:"1" min:"1"` PageSize int64 `default:"10" min:"10" max:"100"` } request := Request{Page: 2} if err := sf.Reflect(&request); err != nil { fmt.Printf("reflect failed: %v\n", err) } else { fmt.Printf("Request.Page: %d\n", request.Page) fmt.Printf("Request.PageSize: %d\n", request.PageSize) } /// Example 2: Mask the response result data type Person struct { Username string `datamask:"username"` Password string `datamask:"password"` request Request Request Request `reflect:"-"` // Stop to reflect struct recursively. } type Response struct { Persons []Person } response := Response{Persons: []Person{ {Username: "谢谢", Password: "123456789"}, }} if err := sf.Reflect(&response); err != nil { fmt.Printf("reflect failed: %v\n", err) } else { fmt.Printf("Response.Username: %s\n", response.Persons[0].Username) fmt.Printf("Response.Password: %s\n", response.Persons[0].Password) fmt.Printf("Response.Request.Page: %d\n", response.Persons[0].Request.Page) fmt.Printf("Response.Request.PageSize: %d\n", response.Persons[0].Request.PageSize) fmt.Printf("Response.request.Page: %d\n", response.Persons[0].request.Page) fmt.Printf("Response.request.PageSize: %d\n", response.Persons[0].request.PageSize) }
Output: Request.Page: 2 Request.PageSize: 10 Response.Username: 谢** Response.Password: ****** Response.Request.Page: 0 Response.Request.PageSize: 0 Response.request.Page: 0 Response.request.PageSize: 0
func (*Reflector) ReflectContext ¶ added in v0.2.0
ReflectContext reflects all the fields of the struct.
If the field is a struct or slice/array of structs, and has a tag named "reflect" with the value "-", it stops to reflect the struct field recursively.
func (*Reflector) ReflectValue ¶
ReflectValue is equal to ReflectValueContext(nil, value).
func (*Reflector) ReflectValueContext ¶ added in v0.2.0
ReflectValueContext is the same as ReflectContext, but uses reflect.Value instead of a pointer to a struct.
func (*Reflector) Unregister ¶
Unregister unregisters the field handler by the tag name.
Directories ¶
Path | Synopsis |
---|---|
Package field provides some functions about the struct field.
|
Package field provides some functions about the struct field. |
Package handler provides a handler interface.
|
Package handler provides a handler interface. |
setdefault
Package setdefault provides a handler to set the default of the struct field.
|
Package setdefault provides a handler to set the default of the struct field. |
setter
Package setter provides a handler to set the struct field to a value.
|
Package setter provides a handler to set the struct field to a value. |
validate
Package validate provides a handler to validate the struct field.
|
Package validate provides a handler to validate the struct field. |