rpcx路由（点对点方式）

即一个客户端只对应一个服务端

服务端

package main
import (
	"flag"
	"github.com/smallnest/rpcx/server"
	"github.com/rpcx-ecosystem/rpcx-examples3"
	"context"
	"fmt"
)
var (
	addr = flag.String("addr", "localhost:8972", "server address")
)
func main() {
	flag.Parse()
	s := server.NewServer()
	s.Register(new(Arith), "")
	s.Serve("tcp", *addr)
}

type Args struct {
	A int
	B int
}
type Reply struct {
	C int
}

type Arith int

func (t *Arith) Mul(ctx context.Context, args *Args, reply *Reply) error {
	reply.C = args.A * args.B
	fmt.Printf("call: %d * %d = %d\n", args.A, args.B, reply.C)
	return nil
}

客户端

package main

import (
	"github.com/smallnest/rpcx/client"
	"log"
	"service"
	"context"
	"flag"
)
type Args struct {
	A int
	B int
}
type Reply struct {
	C int
}
var (
	addr = flag.String("addr", "127.0.0.1:8972", "server address")
)
var (
	RPCTimeout     = 2 * time.Second
	RPCConnTimeout = 1 * time.Second
	xclient        client.XClient
)
func datainit(){
	d := client.NewPeer2PeerDiscovery("tcp@" + *addr, "")
	opt := client.DefaultOption
	opt.ConnectTimeout = RPCConnTimeout
	xclient = client.NewXClient("Arith", client.Failfast, client.RandomSelect, d, opt)
}

func rpcCall(args Args) error {
	ctx, cancel := context.WithTimeout(context.Background(), RPCTimeout)
	err := xclient.Call(ctx, "Mul", &args, &Reply{})
	cancel()
	return err
}

func main() {
	flag.Parse()
	datainit()
	args := Args{
		A: 10,
		B: 20,
	}
	err:=rpcCall(args)
	if err != nil {
		log.Fatalf("failed to call: %v", err)
	}
	log.Printf("%d * %d = %d", args.A, args.B, reply.C)
}