Golang如何通过反射获取方法名列表_Golang 方法名列表获取实践

package main

import (
    "fmt"
    "reflect"
    "strings"
)

// 定义一个示例结构体
type MyService struct {
    Name string
    id   int // 私有字段
}

// 定义一些方法
func (s *MyService) Start() string {
    return fmt.Sprintf("%s service started.", s.Name)
}

func (s MyService) Stop() string {
    return fmt.Sprintf("%s service stopped.", s.Name)
}

func (s *MyService) Restart(graceful bool) string {
    if graceful {
        return fmt.Sprintf("%s service gracefully restarted.", s.Name)
    }
    return fmt.Sprintf("%s service forcefully restarted.", s.Name)
}

func (s MyService) internalMethod() { // 私有方法
    fmt.Println("This is an internal method.")
}

// 另一个类型，用于演示
type AnotherService struct{}

func (a *AnotherService) DoSomething() {
    fmt.Println("Doing something...")
}

func main() {
    // 1. 从一个具体实例获取方法名列表 (通常更常见)
    myInstance := &MyService{Name: "WebServer"} // 注意这里使用指针类型，因为很多方法是定义在指针接收者上的
    t := reflect.TypeOf(myInstance)

    fmt.Printf("--- 方法列表 for type %s (from instance) ---\n", t.String())
    methodNames := getMethodNames(t)
    fmt.Println("方法名列表:", methodNames)
    fmt.Println("--------------------------------------------\n")

    // 2. 直接从类型获取方法名列表 (需要确保类型定义了方法)
    // 对于值类型接收者的方法，直接传入类型也可以
    tValue := reflect.TypeOf(MyService{})
    fmt.Printf("--- 方法列表 for type %s (from value type) ---\n", tValue.String())
    methodNamesValue := getMethodNames(tValue)
    fmt.Println("方法名列表:", methodNamesValue)
    fmt.Println("--------------------------------------------\n")

    // 3. 演示另一个类型
    anotherInstance := &AnotherService{}
    tAnother := reflect.TypeOf(anotherInstance)
    fmt.Printf("--- 方法列表 for type %s ---\n", tAnother.String())
    methodNamesAnother := getMethodNames(tAnother)
    fmt.Println("方法名列表:", methodNamesAnother)
    fmt.Println("--------------------------\n")

    // 4. 演示如何通过reflect.Value获取方法并调用 (扩展)
    v := reflect.ValueOf(myInstance)
    if method, ok := v.Type().MethodByName("Start"); ok {
        // 调用方法需要传入接收者实例
        // 注意：如果方法有参数，需要构造reflect.Value切片
        results := method.Func.Call([]reflect.Value{v})
        fmt.Printf("调用 Start 方法结果: %v\n", results[0].Interface())
    }
}

// getMethodNames 辅助函数，用于从 reflect.Type 获取所有导出方法名
func getMethodNames(t reflect.Type) []string {
    var names []string
    for i := 0; i < t.NumMethod(); i++ {
        method := t.Method(i)
        names = append(names, method.Name)
    }
    return names
}

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string
}

// 值接收者方法
func (u User) GetName() string {
    return u.Name
}

// 指针接收者方法
func (u *User) SetName(name string) {
    u.Name = name
}

func main() {
    // 1. 通过值类型实例进行反射
    userValue := User{Name: "Alice"}
    typeOfValue := reflect.TypeOf(userValue)
    fmt.Printf("通过值类型实例 (%T) 反射：\n", userValue)
    for i := 0; i < typeOfValue.NumMethod(); i++ {
        method := typeOfValue.Method(i)
        fmt.Printf("  - %s\n", method.Name)
    }
    // 预期输出：- GetName (SetName不会出现)

    fmt.Println("\n---------------------\n")

    // 2. 通过指针类型实例进行反射
    userPointer := &User{Name: "Bob"}
    typeOfPointer := reflect.TypeOf(userPointer)
    fmt.Printf("通过指针类型实例 (%T) 反射：\n", userPointer)
    for i := 0; i < typeOfPointer.NumMethod(); i++ {
        method := typeOfPointer.Method(i)
        fmt.Printf("  - %s\n", method.Name)
    }
    // 预期输出：- GetName, - SetName
}