如何判断复合接口上的方法是否可调用，避免程序panic？

你的问题核心是：当结构体通过嵌入接口“凑出”接口方法签名，但嵌入的接口字段是nil时，常规的nil检查无法判断调用该方法会panic——因为接口变量的方法值本身不是nil，但实际执行时会触发nil接口调用方法的panic。

这里提供几种可行的解决办法：

方法一：用反射提前检查方法是否可安全调用 #

通过反射可以判断结构体是自己实现了方法，还是依赖嵌入的nil接口。如果是后者，检查嵌入的接口字段是否非nil：

package main

import (
    "reflect"
)

type MyInterface interface {
    MyMethod()
}

type MyType1 struct {
    MyInterface
}

type MyType2 struct {
    MyInterface
}

func (mt MyType1) MyMethod() {
    println("MyType1.MyMethod called")
}

// 检查MyMethod是否可安全调用
func isMyMethodCallable(i MyInterface) bool {
    if i == nil {
        return false
    }
    v := reflect.ValueOf(i)
    // 先检查当前类型是否直接实现了MyMethod
    if _, ok := v.Type().MethodByName("MyMethod"); ok {
        return true
    }
    // 再检查是否嵌入了MyInterface字段，且该字段非nil
    embedField, ok := v.Type().FieldByName("MyInterface")
    if ok && embedField.Type == reflect.TypeOf((*MyInterface)(nil)).Elem() {
        embedVal := v.FieldByName("MyInterface")
        return !embedVal.IsNil()
    }
    return false
}

func main() {
    var myInstance MyInterface

    var mt1 MyType1
    myInstance = mt1
    if isMyMethodCallable(myInstance) {
        myInstance.MyMethod()
    }

    var mt2 MyType2
    myInstance = mt2
    if isMyMethodCallable(myInstance) {
        myInstance.MyMethod()
    } else {
        println("MyMethod cannot be called safely")
    }
}

方法二：用recover捕获调用时的panic #

如果不想用反射，可以在调用方法时通过defer+recover捕获panic，避免程序崩溃：

package main

import "fmt"

type MyInterface interface {
    MyMethod()
}

type MyType1 struct {
    MyInterface
}

type MyType2 struct {
    MyInterface
}

func (mt MyType1) MyMethod() {
    println("MyType1.MyMethod called")
}

// 安全调用MyMethod，返回错误而非panic
func safeCallMyMethod(i MyInterface) error {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("call MyMethod failed: %v\n", r)
        }
    }()
    i.MyMethod()
    return nil
}

func main() {
    var myInstance MyInterface

    var mt1 MyType1
    myInstance = mt1
    safeCallMyMethod(myInstance)

    var mt2 MyType2
    myInstance = mt2
    safeCallMyMethod(myInstance)
}

方法三：从类型设计上避免问题 #

最根本的解决方式是不要让结构体仅通过嵌入nil接口来实现接口。要么自己实现MyMethod，要么在使用前确保嵌入的接口字段被正确初始化：

// 比如给mt2的MyInterface字段赋值一个有效的实现
var mt2 MyType2
mt2.MyInterface = mt1 // mt1是有效的MyInterface实现
myInstance = mt2
myInstance.MyMethod() // 此时调用不会panic

内容的提问来源于stack exchange，提问作者Pedram