在Go语言里，想拿到一个结构体上所有可导出的方法名称和签名，reflect包提供了最直接的途径。你只需要调用reflect.TypeOf(实例)得到reflect.Type，再遍历Methods()返回的切片即可。这个方法返回的每个reflect.Method都带有方法名、包路径、类型签名和底层函数值，足以支撑路由注册、序列化、注解扫描等场景。

理解reflect.Type与Methods方法

reflect.Type是一个接口，描述了Go类型的元信息。对于结构体来说，Methods()方法会返回一个[]reflect.Method切片，并且按方法名的字典序排序。需要注意的是，Methods()只包含可导出的方法，也就是方法名首字母大写的方法。如果方法名小写，反射层面拿不到，这是Go语言访问控制的约束。

reflect.Method结构体包含五个字段：Name是方法名，PkgPath表示方法所属包的路径，对于导出方法该字段为空字符串；Type是方法对应的函数类型，第一个参数固定是接收者；Func是底层函数值，可以通过它调用方法；Index是方法在类型方法集中的索引。下面这段代码演示了如何打印结构体的全部方法：

package main
import (
    "fmt"
    "reflect"
)
type User struct {
    ID   int
    Name string
}
func (u User) GetName() string {
    return u.Name
}
func (u *User) SetName(name string) {
    u.Name = name
}
func main() {
    t := reflect.TypeOf(User{})
    fmt.Printf("值类型方法数: %d\n", t.NumMethod())
    for i := 0; i < t.NumMethod(); i++ {
        m := t.Method(i)
        fmt.Printf("方法名: %s, 类型: %s\n", m.Name, m.Type)
    }
    pt := reflect.TypeOf(&User{})
    fmt.Printf("指针类型方法数: %d\n", pt.NumMethod())
    for i := 0; i < pt.NumMethod(); i++ {
        m := pt.Method(i)
        fmt.Printf("方法名: %s, 类型: %s\n", m.Name, m.Type)
    }
}

运行这段代码会发现，reflect.TypeOf(User{})只列出GetName一个方法，而reflect.TypeOf(&User{})列出了GetName和SetName两个方法。原因在于值类型的方法集不包含指针接收者方法。因此获取方法列表之前，要根据实际调用方式选择传入值或指针。

过滤方法与提取签名信息

实际项目里往往不是简单打印所有方法，而是希望筛选满足特定规则的方法，例如方法名包含某个前缀、参数个数符合要求，或者返回指定类型。拿到reflect.Method之后，可以进一步解析Type字段。由于方法类型是func(接收者, 参数...) 返回值...，第一个输入参数是接收者本身，判断入参和出参时需要排除第一个。

下面的例子展示了如何从指针类型中找出所有名称以Get开头且没有任何参数的方法，并获取其返回值类型。对于更复杂的筛选，可以结合NumIn()、NumOut()、In(i)、Out(i)等函数：

package main
import (
    "fmt"
    "reflect"
    "strings"
)
type Account struct {
    Balance float64
}
func (a *Account) GetBalance() float64 {
    return a.Balance
}
func (a *Account) SetBalance(v float64) {
    a.Balance = v
}
func (a *Account) GetOwner() string {
    return "owner"
}
func main() {
    t := reflect.TypeOf(&Account{})
    for i := 0; i < t.NumMethod(); i++ {
        m := t.Method(i)
        if strings.HasPrefix(m.Name, "Get") {
            // 方法签名的第0个参数是接收者，真正的业务参数从第1个开始
            if m.Type.NumIn() == 1 {
                fmt.Printf("候选方法: %s, 返回类型: %s\n", m.Name, m.Type.Out(0))
            }
        }
    }
}

这段代码中m.Type.NumIn() == 1意味着除了接收者之外没有其他参数，这样筛选出的方法就可以直接作为无参查询接口暴露出去。如果方法有参数，可以通过m.Type.In(1)、m.Type.In(2)依次获取参数类型；返回值则用m.Type.Out(0)等方式读取。反射保留的是静态类型信息，最终调用时还需要配合m.Func.Call传入具体参数。

另外，reflect.Type.MethodByName可以直接按名称查找单个方法，如果只是确认某个方法是否存在，用它比完整遍历更简洁。不过遍历方式更利于一次性建立方法索引，后续重复查询时不用多次反射。

构建一个简易RPC路由表

反射遍历方法列表的典型应用之一是实现一个轻量级RPC框架。启动服务时扫描某个服务结构体，把每个公开方法注册到路由表中，客户端根据方法名动态调用。这个过程要处理参数序列化、返回值包装等问题，但核心的方法发现就是Methods()遍历。

下面给出一个最小实现思路：定义服务结构体，遍历其指针类型的方法，生成路由映射，然后通过函数值调用目标方法。示例中为了简化，只支持无参方法并返回字符串，实际项目中可以把参数类型、返回类型记入路由信息，再结合编码层做更完整的调用。

package main
import (
    "fmt"
    "reflect"
)
type EchoService struct{}
func (s *EchoService) Ping() string {
    return "pong"
}
func (s *EchoService) Hello() string {
    return "hello"
}
func main() {
    routes := make(map[string]reflect.Method)
    t := reflect.TypeOf(&EchoService{})
    v := reflect.ValueOf(&EchoService{})
    for i := 0; i < t.NumMethod(); i++ {
        m := t.Method(i)
        routes[m.Name] = m
    }
    name := "Ping"
    if m, ok := routes[name]; ok {
        results := m.Func.Call([]reflect.Value{v})
        fmt.Printf("调用 %s 返回: %s\n", name, results[0].String())
    }
}

这个例子先遍历方法建立routes映射，再通过m.Func.Call实现动态调用。m.Func的第一个参数必须是对应的接收者值，这里的v是*EchoService类型，与方法签名一致。如果接收者是值类型，则需要传入值类型的reflect.Value。在实际框架中，参数往往从网络字节流解析出来，再根据m.Type.In(i)转换成对应类型的reflect.Value。

注意指针与值类型的方法集差异

前面已经提到，值类型和指针类型的Methods()结果不同。准确地说，reflect.TypeOf(T{})的方法集只包含值接收者方法，而reflect.TypeOf(&T{})的方法集包含值接收者和指针接收者方法。这个差异会直接影响路由扫描结果：如果只传入值类型，采用指针接收者实现的方法会全部丢失。

因此，构建服务路由或方法索引时，通常要对指针类型进行扫描。可以写一个工具函数统一处理：无论调用方传入值还是指针，内部都取指针类型的reflect.Type。例如：

func GetMethods(obj interface{}) []reflect.Method {
    t := reflect.TypeOf(obj)
    if t.Kind() == reflect.Ptr {
        t = t.Elem()
    }
    pt := reflect.PtrTo(t)
    methods := make([]reflect.Method, 0, pt.NumMethod())
    for i := 0; i < pt.NumMethod(); i++ {
        methods = append(methods, pt.Method(i))
    }
    return methods
}

该函数先通过reflect.TypeOf(obj)拿到原始类型，如果是指针就取Elem()得到结构体，再用reflect.PtrTo(t)构造出对应的指针类型，从而扫描完整的方法集。这样无论传入T{}还是&T{}，扫描结果都一致。

反射操作不可避免会带来性能消耗，尤其在启动阶段一次性扫描所有方法时影响不大，但如果每次请求都遍历方法列表，就要考虑缓存。Methods()内部会生成新的切片，频繁调用会产生额外分配。建议把扫描结果保存到包级变量中，并配合sync.Once确保只执行一次。

还有一点需要留意：未导出方法永远不会出现在Methods()结果中，即使通过reflect.Type.Method按索引访问也是如此。如果遇到需要调用内部方法的特殊场景，只能借助unsafe包或编译器特性，但这已经超出标准反射的使用范围，不建议在通用代码中尝试。