GoLang--TCP RPC模板

Server部分

woker.go

package shared

import (
    "net"
    "net/rpc"
    "fmt"
)

type Worker struct {
    address string
    l       net.Listener
}

func (wk *Worker) DoTask(args struct{} ,resp *string) error{
    fmt.Println("DoTask...")
    *resp = "Hello, I'm from RPC server!"
    return nil
}

func RunWorker(
    address string,
) {
    wk := new(Worker)
    wk.address = address

    rpc.Register(wk)

    tcpAddr, _ := net.ResolveTCPAddr("tcp", ":9000")
    l, _ := net.ListenTCP("tcp", tcpAddr)
    wk.l = l

    for {
        conn, err := l.Accept()
        fmt.Println("processing connection")
        if err != nil {
            continue
        }
        rpc.ServeConn(conn)
    }
}



/*
type Calculator struct {
    address string
    l       net.Listener
}

func StartServer(address string){
    cal := new(Calculator)
    cal.address = address
    cal.startRPCServer()
}
*/

main.go

package main

import (
    "fmt"
    "shared"
)

func main() {
    shared.RunWorker("localhost:9000")
    fmt.Scan()
}

Client部分

main.go

package main

import (
    "log"
    "net/rpc"
    "fmt"
)

func main() {
    client, err := rpc.Dial("tcp", "localhost:9000")
    if err != nil {
        log.Fatal("error: ", err)
    }
    var reply string
    err = client.Call("Worker.DoTask", new(struct{}), &reply)
    if err != nil {
        log.Println(err)
    }else {
        fmt.Println(reply)
    }
}

TCP远程调用方法模板

func TCPRPCCall(
    address string,
    srvMethod string,
    args interface{},
    reply interface{},
    ) {
    client, err := rpc.Dial("tcp", address)
    if err != nil {
        log.Fatal("error: ", err)
    }
    err = client.Call(srvMethod, args, reply)
}