使用golang迭代开发小项目--rpc远程调用

//服务端
type Args struct {  // 请求参数
  A, B int
}

type Quotient struct {  // 一个响应的类型
  Quo, Rem int
}

type Arith int

// 定义了乘法和除法
func (t *Arith) Multiply(args *Args, reply *int) error {
  *reply = args.A * args.B
  return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
  if args.B == 0 {
    return errors.New("divide by zero")
  }
  quo.Quo = args.A / args.B
  quo.Rem = args.A % args.B
  return nil
}

func main() {
  serv := rpc.NewServer()
  arith := new(Arith)
  serv.Register(arith)  // 服务注册

    // 通过http 监听，到时做协议转换
  http.ListenAndServe("0.0.0.0:3000", serv)
}
//客户端
func main() {
  client, err := rpc.DialHTTP("tcp", "127.0.0.1:3000")
  if err != nil {
    log.Fatal("dialing:", err)
  }

  dones := make([]chan *rpc.Call, 0, 10)

  // 先同步发起请求
  for i := 0; i < 10; i++ {
    quotient := new(Quotient)
    args := &Args{i + 10, i}
    divCall := client.Go("Arith.Divide", args, quotient, nil)
    dones = append(dones, divCall.Done)
    log.Print("send", i)
  }
  log.Print("---------------")

  // 之后异步读取
  for idx, done := range dones {
    replyCall := <-done // will be equal to divCall
    args := replyCall.Args.(*Args)
    reply := replyCall.Reply.(*Quotient)
    log.Printf("%d / %d = %d, %d %% %d = %d\n", args.A, args.B, reply.Quo,
      args.A, args.B, reply.Rem)
    log.Print("recv", idx)
  }
}

//server.go
package zihurpc

import (
	"net/http"
	"net/rpc"
)

type Server struct {
	*rpc.Server
}

func NewServer() *Server {
	return &Server{&rpc.Server{}}
}

func (s *Server) Register(rcvr interface{}) error {
	return s.Server.Register(rcvr)
}

func (s *Server) Serve() {
	http.ListenAndServe("0.0.0.0:30001", s.Server)
}
//client.go
package zihurpc

import (
	"log"
	"net/rpc"
)

type Client struct {
	*rpc.Client
}

func NewClient() *Client {
	client, err := rpc.DialHTTP("tcp", "127.0.0.1:30001")
	if err != nil {
		log.Fatal("dialing:", err)
	}
	return &Client{client}
}

func (c *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
	return c.Client.Call(serviceMethod, args, reply)
}
//gdb_service_calculate.go
package myservice

type Args struct { // 请求参数
	A, B int
}

type Reply struct { // 响应参数
	C int
}

type Arith int

// 定义了加法和减法
func (t *Arith) Add(args *Args, reply *Reply) error {
	reply.C = args.A + args.B
	return nil
}

func (t *Arith) Sub(args *Args, reply *Reply) error {
	reply.C = args.A - args.B
	return nil
}
//zihurpc_test.go
package zihurpc

import (
	"log"
	"testing"
	gdb "zihurpc/myservice"

	"github.com/stretchr/testify/assert"
)

func init() {
	server := NewServer()
	err := server.Register(new(gdb.Arith))
	if err != nil {
		log.Fatal(err)
	}
	go server.Serve()
}

func TestClient_Call(t *testing.T) {
	client := NewClient()
	defer client.Close()
        //add test
	args := &gdb.Args{A: 1, B: 2}
	reply := &gdb.Reply{}
	client.Call("Arith.Add", args, reply)
	assert.Equal(t, reply.C, 3, nil)
}

syntax = "proto3";

package myservice;

option go_package="./;myservice";

service LookUpScoreService {
//第一要首字母大写，否则rpc注册不到这个函数，切记切记
  rpc Lookup(ArithLookupScoreRequest) returns (ArithLookupScoreResponse);
}

message ArithLookupScoreRequest {
  string student_name = 1;
  string student_key  = 2;
}

message ArithLookupScoreResponse {
  string scores = 1;
}
然后使用
PS D:\code\zihurpc> cd .\myservice\
PS D:\code\zihurpc\myservice> protoc --go_out=. *.proto
PS D:\code\zihurpc> go env -w GOPROXY=https://goproxy.io,direct
PS D:\code\zihurpc> go env -w GO111MODULE="on"
PS D:\code\zihurpc> go mod tidy
代码就自动生成好啦

//proto_myservice_lookupscore.go

type LookUpScoreService struct{}

func (t *LookUpScoreService) Lookup(args *ArithLookupScoreRequest, reply *ArithLookupScoreResponse) error {
	if args.StudentKey != "2011zuhurpc" {
		return errors.New("password incorrect! I wish you'd use your head.")
	}
	if args.StudentName == "小明" {
		reply.Scores = "100"
	} else if args.StudentName == "小刚" {
		reply.Scores = "95"
	} else {
		reply.Scores = "91"
	}
	return nil
}

//zihurpc_test.go
func init() {
	server := NewServer()
	err := server.Register(new(srv.Arith))
	if err != nil {
		log.Fatal(err)
	}
	err = server.Register(new(srv.LookUpScoreService))
	if err != nil {
		log.Fatal(err)
	}
	go server.Serve()
}

func TestClient_Call(t *testing.T) {
	client := NewClient()
	defer client.Close()

	args := &srv.Args{A: 1, B: 2}
	reply := &srv.Reply{}
	client.Call("Arith.Add", args, reply)
	assert.Equal(t, reply.C, 3, nil)

	args1 := &srv.ArithLookupScoreRequest{StudentName: "小明", StudentKey: "2011zuhurpc"}
	reply1 := &srv.ArithLookupScoreResponse{}
	client.Call("LookUpScoreService.Lookup", args1, reply1)
	assert.Equal(t, reply1.Scores, "100", nil)

}

type ServerCodec interface {
	ReadRequestHeader(*Request) error
	ReadRequestBody(interface{}) error
	WriteResponse(*Response, interface{}) error
	Close() error
}
type ClientCodec interface {
	WriteRequest(*Request, interface{}) error
	ReadResponseHeader(*Response) error
	ReadResponseBody(interface{}) error
	Close() error
}

type PktHead struct {
	ServiceMethod string // format: "Service.Method" or "200ok"
	Seq           uint64 // sequence number 
	BodyLen       uint64 // rsp or req
}

type ServerCodec struct {
	rwc    io.ReadWriteCloser 
	req    PktHead
	closed bool //标识codec是否关闭
}

type ClientCodec struct {
	rwc    io.ReadWriteCloser 
	rsq    PktHead
	closed bool
}

idx, size := 0, 0
r.ServiceMethod, size = readString(headBody)
idx += size

r.Seq, size = binary.Uvarint(headBody[idx:])
idx += size

s.req.BodyLen, size = binary.Uvarint(headBody[idx:])
idx += size

var body proto.Message
var ok bool
if body, ok = reply.(proto.Message); !ok {
	return errors.New("param does not implement proto.Message")
}

var respBody []byte
var err error
if reply != nil {
    respBody, err = proto.Marshal(body)
    if err != nil {
	return err
    }
}

rspHead := make([]byte, 40)
idx := 0
idx += writeString(rspHead[idx:], r.Error)
idx += binary.PutUvarint(rspHead[idx:], r.Seq)
binary.PutUvarint(rspHead[idx:], uint64(len(respBody)))

rspHeadLen := make([]byte, 4)
binary.PutUvarint(rspHeadLen, uint64(len(rspHead)))
//头的长度发出去
_, err = s.rwc.Write(rspHeadLen)
if err != nil {
	return err
}
//头也发出去
_, err = s.rwc.Write(rspHead)
if err != nil {
	return err
}
//将序列化的body发送出去
_, err = s.rwc.Write(respBody)