在Go中实现返回类型与调用结构体一致的复用函数

需求说明 #

想要在Go中实现类似Java通过T extends MyClass<T>这种自限定泛型的功能：让方法的返回类型始终等于调用该方法的结构体类型，调用后无需类型转换即可直接访问结构体的专属字段。

Java示例实现 #

Java中可以通过自限定泛型实现该效果：

public class MyClass<Type extends MyClass<Type>> {
    public Type myMethod() {
        // 执行逻辑
        return (Type) this;
    }
}

public class Test1 extends MyClass<Test1> {
    public String A;
    
    Test1(String A) {
        this.A = A;
    }
}

public class Test2 extends MyClass<Test2> {
    public String B;

    Test2(String B) {
        this.B = B;
    }
}

使用时可以直接调用方法并访问子类字段：

Test1 t1 = new Test1("hello");
Test2 t2 = new Test2("world");
System.out.println(t1.myMethod().A); // 输出 "hello"
System.out.println(t2.myMethod().B); // 输出 "world"

你尝试的Go代码 #

你尝试用泛型方法实现，但Go不支持这种写法：

type test1 struct {
    A string
}

type test2 struct {
    B string
}

func (val Type) MyMethod() Type {
    // Do something
    return val
}

func main() {
    t1 := test1{A: "hello"}
    t2 := test2{B: "world"}
    fmt.Println(t1.MyMethod().A) // Prints "hello"
    fmt.Println(t2.MyMethod().B) // Prints "world"
}

Go的正确实现方案 #

Go没有继承机制，也不支持Java风格的自限定泛型，以下是三种符合Go语言习惯的实现方式：

方式1：为每个结构体单独实现方法 #

这是最直接且符合Go设计理念的方案，为每个需要的结构体定义同名方法，直接返回自身类型：

package main

import "fmt"

type test1 struct {
    A string
}

// test1专属的MyMethod，返回test1类型
func (t test1) MyMethod() test1 {
    // 这里添加你的业务逻辑
    return t
}

type test2 struct {
    B string
}

// test2专属的MyMethod，返回test2类型
func (t test2) MyMethod() test2 {
    // 这里添加你的业务逻辑
    return t
}

func main() {
    t1 := test1{A: "hello"}
    t2 := test2{B: "world"}
    fmt.Println(t1.MyMethod().A) // 输出 "hello"
    fmt.Println(t2.MyMethod().B) // 输出 "world"
}

方式2：提取通用逻辑到公共函数 #

如果多个结构体的MyMethod存在重复逻辑，可以将通用部分提取到公共函数中，在各方法内调用：

package main

import "fmt"

// 公共逻辑函数，供所有结构体的MyMethod调用
func commonBusinessLogic() {
    // 这里是多个方法共享的逻辑，比如日志、参数校验等
}

type test1 struct {
    A string
}

func (t test1) MyMethod() test1 {
    commonBusinessLogic()
    // test1专属逻辑
    return t
}

type test2 struct {
    B string
}

func (t test2) MyMethod() test2 {
    commonBusinessLogic()
    // test2专属逻辑
    return t
}

func main() {
    t1 := test1{A: "hello"}
    t2 := test2{B: "world"}
    fmt.Println(t1.MyMethod().A)
    fmt.Println(t2.MyMethod().B)
}

方式3：泛型函数（非方法形式） #

如果想通过单一函数处理多种类型，可以使用Go的泛型约束，但这种方式是独立函数而非结构体方法：

package main

import "fmt"

// 定义泛型约束，包含所有需要处理的结构体类型
type MyType interface {
    test1 | test2
}

// 泛型函数，接收任意MyType类型，返回同类型
func MyMethod[T MyType](val T) T {
    // 通用逻辑
    return val
}

type test1 struct {
    A string
}

type test2 struct {
    B string
}

func main() {
    t1 := test1{A: "hello"}
    t2 := test2{B: "world"}
    fmt.Println(MyMethod(t1).A) // 输出 "hello"
    fmt.Println(MyMethod(t2).B) // 输出 "world"
}

总结 #

Go不支持Java风格的自限定泛型与继承，最符合Go idiomatic的实现是为每个结构体单独实现同名方法。如果存在通用逻辑，提取到公共函数中复用即可，避免代码重复。

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