golang中实现RPC非常简单，官方提供了封装好的库，还有一些第三方的库

golang官方的net/rpc库使用encoding/gob进行编解码，支持tcp和http数据传输方式，由于其他语言不支持gob编解码方式，所以golang的RPC只支持golang开发的服务器与客户端之间的交互

官方还提供了net/rpc/jsonrpc库实现RPC方法，jsonrpc采用JSON进行数据编解码，因而支持跨语言调用，目前jsonrpc库是基于tcp协议实现的，同时也支持http传输方式

go快速体验rpc开发

服务端

package main

import (

	"net"

	"net/rpc"

)

type HelloService struct {}

func (s *HelloService) Hello(request string, reply *string) error {

	// 返回值是通过修改reply的值

	*reply = "hello " + request

	return nil

}

func main() {

	// 1. 实例化一个server

	listener, _ := net.Listen("tcp", ":1234")

	// 2. 注册处理逻辑handler

	_ = rpc.RegisterName("HelloService", &HelloService{})

	// 3. 启动server

	conn, _ := listener.Accept()  // 当一个新的连接进来的时候

	rpc.ServeConn(conn)

}

客户端

package main

import (

	"fmt"

	"net/rpc"

)

func main() {

	// 1. 建立连接

	client, err := rpc.Dial("tcp", "192.168.0.101:1234")

	if err != nil {

		panic("连接失败")

	}

	//var ret *string  nil 内存地址没有 只声明不初始化没有办法赋值，所以需要使用new方法声明并初始化

	// 方法一

	//var reply = new(string)

	// 方法二：

	var reply string  // 空字符串，已经有内存地址了

	if err = client.Call("HelloService.Hello", "马亚南", &reply); err != nil {

		panic(err)

	}

	fmt.Println(reply)

}

net/rpc完成的 1. call id的映射 2. 序列化和反序列化（编码和解码）
net完成的网络通信:tcp

替换rpc的序列化协议为json

go语言的rpc序列化协议是什么：Gob编码
能够替换成常见的序列化

go服务端

package main

import (

	"net"

	"net/rpc"

	"net/rpc/jsonrpc"

)

type HelloRPC struct {}

func (h *HelloRPC) Hello(request string, reply *string) error {

	*reply = "hello " + request

	return nil

}

func main() {

	listener, _ := net.Listen("tcp", ":1285")

	rpc.RegisterName("HelloRPC", &HelloRPC{})

	for {

		conn, _ := listener.Accept()

		// 不使用go默认的Gob序列化方式，而是改成json编码方式

		go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))

	}

}

go客户端

package main

import (

	"fmt"

	"net"

	"net/rpc"

	"net/rpc/jsonrpc"

)

func main() {

	// rpc.Dial拨号会走Gob序列化协议，所以需要改成net.Dial

	// rpc.Dial返回的是client,而net.Dial返回的是conn

	conn, _ := net.Dial("tcp", "127.0.0.1:1285")

	var reply = new(string)

	client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))

	_ = client.Call("HelloRPC.Hello", "马馨彤", reply)

	fmt.Println(*reply)

}

python客户端请求上面的go服务端，完成多语言rpc通信

import socket

import json

send_data = {

    "id": 0,

    "params": ["abc", "马馨彤22"],

    "method": "HelloRPC.Hello",

}

# tcp_client_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

# tcp_client_socket.connect(("127.0.0.1", 1285))

# 上面两句可以用下面一句代替

tcp_client_socket = socket.create_connection(("localhost", 1285))

tcp_client_socket.send(json.dumps(send_data).encode())

# 获取服务器返回的数据

rsp = tcp_client_socket.recv(1024)

rsp = json.loads(rsp.decode())

print(rsp)  # {'id': 0, 'result': 'hello abc', 'error': None}

tcp_client_socket.close()

针对上面的升级版本

go服务端接收的request是一个json，python客户端传递的params列表中是一个json数据

go服务端

点击查看代码

package main

import (

	"encoding/json"

	"fmt"

	"net"

	"net/rpc"

	"net/rpc/jsonrpc"

	"strconv"

)

type HelloRPC struct {}

func (h *HelloRPC) Hello(request string, reply *string) error {

	fmt.Println(request)

	var m1 map[string]interface{}

	json.Unmarshal([]byte(request), &m1)

	i, _ := strconv.Atoi(fmt.Sprintf("%1.0f", m1["age"]))

	m1["age"] = float64(i + 1)

	rsp, _ := json.Marshal(&m1)

	*reply = "hello " + string(rsp)

	return nil

}

func main() {

	listener, _ := net.Listen("tcp", ":1285")

	rpc.RegisterName("HelloRPC", &HelloRPC{})

	for {

		conn, _ := listener.Accept()

		// 不使用go默认的Gob序列化方式，而是改成json编码方式

		go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))

	}

}

2. python客户端

点击查看代码

import socket

import json

send_data = {

    "id": 0,

    "params": ['{"name": "Lisi","age": 18}'],

    "method": "HelloRPC.Hello",

}

# tcp_client_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

# tcp_client_socket.connect(("127.0.0.1", 1285))

# 上面两句可以用下面一句代替

tcp_client_socket = socket.create_connection(("localhost", 1285))

tcp_client_socket.send(json.dumps(send_data).encode())

# 获取服务器返回的数据

rsp = tcp_client_socket.recv(1024)

rsp = json.loads(rsp.decode())

print(rsp)  # {'id': 0, 'result': 'hello abc', 'error': None}

tcp_client_socket.close()

替换rpc的传输协议为http

同时使用json编码解码

go服务端

package main

import (

	"io"

	"net/http"

	"net/rpc"

	"net/rpc/jsonrpc"

)

type HelloRPC struct {}

func (h *HelloRPC) Hello(request string, reply *string) error {

	*reply = "hello " + request

	return nil

}

func main() {

	_ = rpc.RegisterName("HelloRPC", &HelloRPC{})

	http.HandleFunc("/jsonrpc", func(writer http.ResponseWriter, request *http.Request) {

		var conn io.ReadWriteCloser = struct {

			io.Writer

			io.ReadCloser

		}{

			ReadCloser: request.Body,

			Writer: writer,

		}

		_ = rpc.ServeRequest(jsonrpc.NewServerCodec(conn))

	})

	_ = http.ListenAndServe(":1234", nil)

}

python客户端

import requests

request = {

    "id": 0,

    "params": ["马艳娜"],

    "method": "HelloRPC.Hello"

}

rsp = requests.post("http://127.0.0.1:1234/jsonrpc", json=request)

print(rsp.text)

进一步改造rpc调用的代码（封装达到grpc的使用效果）

目录结构图
server.go

package main

import (

	"goRPC/new_helloworld/handler"

	"goRPC/new_helloworld/server_proxy"

	"net"

	"net/rpc"

)

func main() {

	// 1. 实例化一个server

	listener, _ := net.Listen("tcp", ":1234")

	// 2. 注册处理逻辑handler

	_ = server_proxy.RegisterHelloService(&handler.HelloService{})

	// 3. 启动server

	for {

		conn, _ := listener.Accept()  // 当一个新的连接进来的时候

		go rpc.ServeConn(conn)

	}

}

handler.go

package handler

const HelloServiceName = "handler/HelloService"

// 我们关心的是HelloService的名字呢，还是结构体中的Hello方法呢？

type HelloService struct {}

func (s *HelloService) Hello(request string, reply *string) error {

	// 返回值是通过修改reply的值

	*reply = "hello " + request

	return nil

}

server_proxy.go

package server_proxy

import (

	"goRPC/new_helloworld/handler"

	"net/rpc"

)

type HelloServer interface {

	Hello(request string, reply *string) error

}

// 如何做到与handler中的结构体名称解耦? 我们关心的是函数: 鸭子类型

func RegisterHelloService(srv HelloServer) error {

	return rpc.RegisterName(handler.HelloServiceName, srv)

}

client.go

package main

import (

	"fmt"

	"goRPC/new_helloworld/client_proxy"

)

func main() {

	// 建立链接

	client := client_proxy.NewHelloServiceClient("tcp", "127.0.0.1:1234")

	// 指向写业务逻辑，不想关注每个函数的名称

	var reply = new(string)

	err := client.Hello("马亚南121", reply)

	if err != nil {

		panic(err)

	}

	fmt.Println(*reply)

}

client_proxy.go

package client_proxy

import (

	"goRPC/new_helloworld/handler"

	"net/rpc"

)

type HelloServiceStub struct {

	*rpc.Client

}

// 在go语言中没有类、对象，就意味着没有初始化方法

func NewHelloServiceClient(protocol, address string) *HelloServiceStub {

	client, _ := rpc.Dial(protocol, address)

	return &HelloServiceStub{Client: client}

}

func (c *HelloServiceStub) Hello(request string, reply *string) error {

	return c.Call(handler.HelloServiceName + ".Hello", request, reply)

}

上面这些概念在grpc中都有相关对应
发自灵魂的拷问：server_proxy和client_proxy能否自动生成啊？为多种语言生成？
答：上面两个问题都能解决: protobuf + grpc

巴特西

golang中的rpc开发