~/Go Reflection Uncovered Powerful Use Cases

Jan 12, 2019

Reflection in Go allows runtime inspection and manipulation of types, values, and metadata. This article explores advanced use cases for reflect in Go, targeting scenarios where static typing does not suffice.

Type Inspection

Using TypeOf, you can determine the dynamic type of an object at runtime. This is essential for libraries that need to process arbitrary data, such as serialization frameworks.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import (
    "fmt"
    "reflect"
)

func PrintType(i interface{}) {
    t := reflect.TypeOf(i)
    fmt.Println("Type:", t.String())
}

PrintType(42)          // "Type: int"
PrintType("hello")     // "Type: string"

Struct Tag Parsing

Reflection enables reading field tags, commonly used for encoding or validation purposes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func PrintTags(i interface{}) {
    t := reflect.TypeOf(i)
    for i := 0; i < t.NumField(); i++ {
        tag := t.Field(i).Tag.Get("json")
        fmt.Printf("Field %s tag: %s\n", t.Field(i).Name, tag)
    }
}

PrintTags(User{})

More details at StructTag documentation.

Dynamic Value Setting

Using ValueOf and Elem, you can set struct field values dynamically.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type Config struct {
    Port int
}

c := Config{}
v := reflect.ValueOf(&c).Elem()
f := v.FieldByName("Port")
if f.CanSet() {
    f.SetInt(8080)
}

Interface Implementation Checks

Checking if a type implements an interface at runtime helps in plugin design.

1
2
3
4
5
6
7

type Stringer interface {
    String() string
}

t := reflect.TypeOf("test")
stringerType := reflect.TypeOf((*Stringer)(nil)).Elem()
fmt.Println(t.Implements(stringerType)) // false

Support for Generic-like Patterns

Reflection supports patterns that simulate generics, such as validating arbitrary collections or performing transformations.

1
2
3
4
5
6
7
8
9

func PrintSliceElemTypes(slice interface{}) {
    v := reflect.ValueOf(slice)
    for i := 0; i < v.Len(); i++ {
        fmt.Println(reflect.TypeOf(v.Index(i).Interface()))
    }
}

PrintSliceElemTypes([]int{1,2,3})
PrintSliceElemTypes([]string{"a", "b"})

See Go blog generics post.

Deep Copy and Cloning

Libraries implement deep copy using reflection to traverse and clone arbitrary objects recursively.

func DeepCopy(src, dst interface{}) error { srcVal := reflect.ValueOf(src) dstVal := reflect.ValueOf(dst) dstVal.Elem().Set(srcVal.Elem()) return nil }

Dynamic Data Validation

Validation frameworks like validator rely heavily on reflection to inspect fields, tags, and values.

Mocking and Test Frameworks

Reflection enables test frameworks like testify to inspect function signatures and call methods dynamically for assertions and mocks.

ORMs and Database Mappers

Object Relational Mappers use reflection internally for mapping database columns to struct fields, reading tags, and constructing queries at runtime.

Serialization and Deserialization

Reflection drives libraries like encoding/json and protobuf for recursive traversal and dynamic encoding of fields based on their types and tags.

Plugin and Middleware Design

Plugins and middleware leverage reflection to apply arbitrary wrappers or callbacks at runtime, enabling flexible composition.

Limitations and Performance

Reflection introduces some overhead, and use should be limited to scenarios where static typing is impractical. Avoid heavy use in performance-critical sections.

Conclusion

Reflection in Go enables dynamic runtime capabilities otherwise unavailable in statically typed systems. Use it judiciously, following effective Go practices.