Mastering Go Reflection: Principles, Pitfalls, and a Practical DI Container

1. How Reflection Works

Go's reflection is built on the interface and type system, primarily using reflect.TypeOf to obtain type information and reflect.ValueOf to obtain a runtime value wrapper.

2. Common Use Cases

Function Invocation

func bridge(funcPtr interface{}, args ...interface{}) {
    in := make([]reflect.Value, len(args))
    for i, arg := range args {
        in[i] = reflect.ValueOf(arg)
    }
    reflect.ValueOf(funcPtr).Call(in)
}

ORM and Struct Filling

sv := reflect.ValueOf(user).Elem()
sv.FieldByName("Name").SetString("Alice")
sv.FieldByName("Age").SetInt(25)

Dynamic Type Checking and Dispatch

v := reflect.ValueOf(data)
switch v.Kind() {
case reflect.String:
    fmt.Println("string:", v.String())
case reflect.Int:
    fmt.Println("int:", v.Int())
}

Dependency Injection and Plugins

Using reflect.New to create objects dynamically enables modular plugin architectures.

Generic Data Mapper

func mapToStruct(data map[string]interface{}, dest interface{}) error {
    dv := reflect.ValueOf(dest)
    if dv.Kind() != reflect.Ptr || dv.Elem().Kind() != reflect.Struct {
        return errors.New("target must be a struct pointer")
    }
    elem := dv.Elem()
    for key, val := range data {
        field := elem.FieldByName(strings.Title(key))
        if field.IsValid() && field.CanSet() {
            field.Set(reflect.ValueOf(val))
        }
    }
    return nil
}

3. Common Pitfalls

Forgetting to pass a pointer when using Elem().

Type mismatches when calling Set().

Unexported fields cannot be modified. reflect.New returns a pointer; you must call .Elem() to get the value.

High‑frequency reflection calls can degrade performance.

4. Optimization and Best Practices

Prefer static types and interfaces; use reflection only when necessary.

Cache reflection results to avoid repeated type lookups.

Perform expensive reflection during initialization rather than hot paths.

Handle errors with recover() or proper exception handling.

Consider code generation for performance‑critical sections.

5. Practical Example: Lightweight DI Container

type Container struct {
    instances map[string]reflect.Value
}
func NewContainer() *Container {
    return &Container{instances: make(map[string]reflect.Value)}
}
func (c *Container) Register(name string, instance interface{}) {
    c.instances[name] = reflect.ValueOf(instance)
}
func (c *Container) Resolve(name string) interface{} {
    if v, ok := c.instances[name]; ok {
        return v.Interface()
    }
    return nil
}

This container registers and resolves objects via reflection, supporting automatic instantiation of complex dependencies.

6. Conclusion

Reflection is a double‑edged sword: it enables flexible frameworks, ORMs, serialization, and dependency injection, but can introduce performance overhead and reduce code readability. Use it in generic frameworks, initialization phases, or cross‑module bridges, and avoid it in high‑performance core business logic.