所以我正在使用类似于以下的代码，但无法让 RPC 在 FooHolder 中工作，在 FooHolder 中它保存满足接口(interface)的对象。我可能遗漏了一些东西，但它看起来应该可以工作——使用反射包它可以正确识别类型，但是当函数返回时出现了一些问题....

package main

import (
    "log"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
    "reflect"
)

type FooInterface interface {
    DoTheBartman(in *string, out *string) error
    DoThis(in *[]string, out *[]string) error
    NoProblems(in *int, out *int) error
}

type Foo struct {
    wibble string
}

func (f *Foo) DoTheBartman(in *string, out *string) error {
    log.Println("do the bartman")
    *out = "^^[ " + *in + "]^^"
    return nil
}

func (f *Foo) DoThis(in *[]string, out *[]string) error {
    log.Println("Doing this")
    log.Println("Type in - ", reflect.TypeOf(in))
    log.Println("Type *in - ", reflect.TypeOf(*in))
    log.Println("Type out - ", reflect.TypeOf(out))
    log.Println("Type *out - ", reflect.TypeOf(*out))

    *out = append(*in, "Hello")

    return nil
}

type FooHolder struct {
    TheFoos []FooInterface
}

func (fh *FooHolder) GetFoos(in *[]Foo, out *[]Foo) error {
    log.Println("Getting Foos...")
    log.Println("Type in - ", reflect.TypeOf(in))
    log.Println("Type *in - ", reflect.TypeOf(*in))
    log.Println("Type out - ", reflect.TypeOf(out))
    log.Println("Type *out - ", reflect.TypeOf(*out))

    return nil // This fails but with a nil... what's up with that.
}

^^ 这是失败的功能，不知道为什么？它返回一个 nil(它被报告为一个 nil 但错误退出 1

func (f *Foo) NoProblems(in *int, out *int) error {
    log.Println("No Problems doing maths")
    log.Println("Type in - ", reflect.TypeOf(in))
    log.Println("Type *in - ", reflect.TypeOf(*in))
    log.Println("Type out - ", reflect.TypeOf(out))
    log.Println("Type *out - ", reflect.TypeOf(*out))

    *out = 42 - (*in)
    return nil
}

// This all works just fine
func startServer(f FooInterface) {
    server := rpc.NewServer()
    server.Register(f)

    l, e := net.Listen("tcp", ":8222")
    if e != nil {
        log.Fatal("listen error:", e)
    }

    for {
        conn, err := l.Accept()
        if err != nil {
            log.Fatal(err)
        }
        log.Println("Incoming!")

        go server.ServeCodec(jsonrpc.NewServerCodec(conn))
    }
}

// It starts to go wrong here...
func startFooHolderServer(f *FooHolder) {
    server := rpc.NewServer()
    server.Register(f)

    l, e := net.Listen("tcp", ":8222")
    if e != nil {
        log.Fatal("listen error:", e)
    }

    for {
        conn, err := l.Accept()
        if err != nil {
            log.Fatal(err)
        }
        log.Println("Incoming!")

        go server.ServeCodec(jsonrpc.NewServerCodec(conn))
    }
}

func main() {

    foo1 := &Foo{}

    fooHolder := &FooHolder{}

    fooHolder.TheFoos = append(fooHolder.TheFoos, foo1)

    // go startServer(foo1)
    go startFooHolderServer(fooHolder)

    conn, err := net.Dial("tcp", "localhost:8222")

    if err != nil {
        panic(err)
    }
    defer conn.Close()

    c := jsonrpc.NewClient(conn)

    var foo []Foo
    log.Println("Type - ", reflect.TypeOf(foo))
    log.Println("Type - ", reflect.TypeOf(&foo))
    err = c.Call("FooHolder.GetFoos", foo, &foo)
    if err != nil {
        log.Fatal("RPC error:", err)
    }

    // No Problems?
    var baz int
    err = c.Call("Foo.NoProblems", baz, &baz)
    if err != nil {
        log.Fatal("RPC error:", err)
    }
    log.Println("Yay - baz is now", baz)

    stringArg := "Put stuff around me"
    err = c.Call("Foo.DoTheBartman", stringArg, &stringArg)
    if err != nil {
        log.Fatal("RPC error:", err)
    }
    log.Println("Yay - stringArg is now", stringArg)

    // Also No Problem
    bar := append([]string{"Hello"}, stringArg)
    log.Println("Type - ", reflect.TypeOf(bar))
    err = c.Call("Foo.DoThis", bar, &bar)
    if err != nil {
        log.Fatal("RPC error:", err)
    }
    log.Println("Yay - bar is now", bar)
}

输出:

rpc-demo $ go run demo.go 
2015/09/05 20:48:32 Incoming!
2015/09/05 20:48:32 Type -  []main.Foo
2015/09/05 20:48:32 Type -  *[]main.Foo
2015/09/05 20:48:32 Getting Foos...
2015/09/05 20:48:32 Type in -  *[]main.Foo
2015/09/05 20:48:32 Type *in -  []main.Foo
2015/09/05 20:48:32 Type out -  *[]main.Foo
2015/09/05 20:48:32 Type *out -  []main.Foo
2015/09/05 20:48:32 RPC error:invalid error <nil>
exit status 1
rpc-demo $ 

有没有人遇到过类似的情况 - 如果我声明一个新类型并将其扔掉并且我看不到前进的方向，这无济于事。

切线但可能相关的是，我编译了一个 Go 应用程序以存档并将其构建到 C 程序中，然后更改接口(interface)以匹配 Foo 而不是 Foo 接口(interface)并且成功了!很奇怪。

最佳答案

这是抛出该错误的行:https://github.com/golang/go/blob/master/src/net/rpc/jsonrpc/client.go#L89

它是客户端，如果 c.resp.Error != nil || 你可以看到它已经到达c.resp.Result == nil.

现在你没有返回任何错误，所以问题不在这里。

我认为问题在于您没有设置任何结果。 GetFoos 将 out 指针保留为 nil。将 out 设置为非零值，它应该可以工作。

关于使用 JSON-RPC 编码数据时出错 - 我是不是很笨？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32411270/