1.RPC的基本知识介绍：
RPC叫做远程调用框架（Remote Procedure Call），远程调用原理如下所示：
比如 A (client) 调用 B (server) 提供的remoteAdd方法：
首先，A与B之间建立一个TCP连接；
然后，A把需要调用的方法名（这里是remoteAdd）以及方法参数（10， 20）序列化成字节流发送出去；
接着，B接受A发送过来的字节流，然后反序列化得到目标方法名，方法参数，接着执行相应的方法调用（可能是localAdd）并把结果30返回；
最后，A接受远程调用结果,输出30。
RPC框架就是把我刚才说的这几点些细节给封装起来，给用户暴露简单友好的API使用。
RPC与Socket的区别：
RPC（远程过程调用）采用客户机/服务器模式实现两个进程之间相互通信。socket是RPC经常采用的通信手段之一，RPC是在Socket的基础上实现的，它比socket需要更多的网络和系统资源。除了Socket，RPC还有其他的通信方法，比如：http、操作系统自带的管道等技术来实现对于远程程序的调用。
RPC与REST的区别：
REST API 和 RPC 都是在 Server端 把一个个函数封装成接口暴露出去，以供 Client端 调用，不过 REST API 是基于 HTTP协议的，REST致力于通过http协议中的POST/GET/PUT/DELETE等方法和一个可读性强的URL来提供一个http请求。而 RPC 则可以不基于 HTTP协议。
因此，如果是后端两种语言互相调用，用 RPC 可以获得更好的性能（省去了 HTTP 报头等一系列东西），应该也更容易配置。
REST API的介绍，可以参考：Go 语言之restful 基础
2. Go Rpc 的实现例子介绍
对于Go语言来说RPC的实现主要有三种类型，Http Rpc, Tcp Rpc和Json Rpc三种架构。
1) Tcp RPC与Http RPC的比较：
上面这个代码和http的服务器相比，不同在于:在此处我们采用了TCP协议，然后需要自己控制连接，当有客户端连接上来后，我们需要把这个连接交给rpc来处理。
2) Json RPC与Tcp RPC比较：
JSON RPC是数据编码采用了JSON，而不是gob编码，其他和上面介绍的RPC概念一模一样，json-rpc是基于TCP协议实现的，目前它还不支持HTTP方式。
2.1 Http Rpc
基于Http协议实现的Rpc架构，主要涉及到的API为， rpc.HandleHTTP() 、http.ListenAndServe(":1234", nil)、rpc.DialHTTP("tcp", "127.0.0.1"+":1234")，client.Call("HttpRpcServer.Print", &a, &outStr)
服务端代码：
package main
import (
"fmt"
"strconv"
"net/http"
"net/rpc"
)
type HttpRpcServer struct {
a int
}
// 入参的数量和返回值这些格式是固定的
func (s *HttpRpcServer) Print( a *int, o *string) error {
fmt.Println("HttpRpcServer.Print:",*a)
*o = strconv.Itoa(*a)
return nil
}
func main() {
fmt.Println("Main start...")
server := new(HttpRpcServer)
rpc.Register(server)
rpc.HandleHTTP()
err := http.ListenAndServe(":1234", nil) // httprpc对于服务器的连接的控制管理，已经封装好了
if err != nil {
fmt.Println(err.Error())
}
}
客户端：
package main
import (
"fmt"
"log"
"net/rpc"
)
func main() {
client, err := rpc.DialHTTP("tcp", "127.0.0.1"+":1234")// 与服务器建立连接
if err != nil {
log.Fatal("dialing:", err)
}
var a int = 10
var outStr string
fmt.Println("Client:send:",a)
// 通过字符串的命名格式来调用对应的API，这里是调用了HttpRpcServer这个数据结构中的Print函数，a和outStr作为入参来处理，err作为Print函数的返回值。
err = client.Call("HttpRpcServer.Print", &a, &outStr)
if err != nil {
log.Fatal("arith error:", err)
}
fmt.Println("CLient revieve:",a,outStr)
}
运行结果：
服务端：
Main start...
HttpRpcServer.Print: 10
客户端：
Client:send: 10
CLient revieve: 10 10
2.2 Tcp Rpc
Tcp Rpc主要涉及到的API接口
net.ResolveTCPAddr("tcp", ":1234")，net.ListenTCP("tcp", tcpAddr)，
listener.Accept()，rpc.ServeConn(conn)，rpc.Dial("tcp", "127.0.0.1"
+":1234")，client.Call("HttpRpcServer.Print", &a, &outStr)
服务端：
package main
import (
"fmt"
"strconv"
"net"
"net/rpc"
)
type HttpRpcServer struct {
a int
}
func (s *HttpRpcServer) Print( a *int, o *string) error {
fmt.Println("HttpRpcServer.Print:",*a)
*o = strconv.Itoa(*a)
return nil
}
func main() {
fmt.Println("Main start...")
server := new(HttpRpcServer)
rpc.Register(server)
tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234") // 这里指定协议为tcp
if err != nil {
fmt.Println(err.Error())
}
listener, err := net.ListenTCP("tcp", tcpAddr) // 服务端分开监听对应的连接
if err != nil {
fmt.Println(err.Error())
}
for {
// AcceptTCP接收下一个呼叫，并返回一个新的*TCPConn。
conn, err := listener.Accept()
if err != nil {
continue
}
rpc.ServeConn(conn) // 这里是阻塞的，同时支持多个的话，需要用到go
}
}
客户端：
package main
import (
"fmt"
"log"
"net/rpc"
)
func main() {
client, err := rpc.Dial("tcp", "127.0.0.1"+":1234") // tcp的协议来处理
if err != nil {
log.Fatal("dialing:", err)
}
var a int = 10
var outStr string
fmt.Println("Client:send:",a)
err = client.Call("HttpRpcServer.Print", &a, &outStr)
if err != nil {
log.Fatal("arith error:", err)
}
fmt.Println("CLient revieve:",a,outStr)
}
运行结果：
服务端：
Main start...
HttpRpcServer.Print: 10
客户端：
Client:send: 10
CLient revieve: 10 10
2.3 Json Rpc
Json Rpc主要涉及到的API接口：
net.ResolveTCPAddr("tcp", ":1234")，net.ListenTCP("tcp", tcpAddr)，
listener.Accept(),jsonrpc.ServeConn(conn)，client.Call("HttpRpcServer.Print", &a, &outStr)
服务端：
package main
import (
"fmt"
"strconv"
"net"
"net/rpc"
"net/rpc/jsonrpc"
)
type HttpRpcServer struct {
a int
}
func (s *HttpRpcServer) Print( a *int, o *string) error {
fmt.Println("HttpRpcServer.Print:",*a)
*o = strconv.Itoa(*a)
return nil
}
func main() {
fmt.Println("Main start...")
server := new(HttpRpcServer)
rpc.Register(server)
tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234") // 这里指定协议为tcp
if err != nil {
fmt.Println(err.Error())
}
listener, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
fmt.Println(err.Error())
}
for {
// AcceptTCP接收下一个呼叫，并返回一个新的*TCPConn。
conn, err := listener.Accept()
if err != nil {
continue
}
jsonrpc.ServeConn(conn) // 这里是阻塞的，同时支持多个的话，需要用到go
}
}
客户端：
package main
import (
"fmt"
"log"
"net/rpc/jsonrpc"
)
func main() {
client, err := jsonrpc.Dial("tcp", "127.0.0.1"+":1234")
if err != nil {
log.Fatal("dialing:", err)
}
var a int = 10
var outStr string
fmt.Println("Client:send:",a)
err = client.Call("HttpRpcServer.Print", &a, &outStr)
if err != nil {
log.Fatal("arith error:", err)
}
fmt.Println("CLient revieve:",a,outStr)
}
运行结果：
服务端：
Main start...
HttpRpcServer.Print: 10
客户端：
Client:send: 10
CLient revieve: 10 10
参考文档：
http://www.kancloud.cn:8080/uvohp5na133/golang/934246
https://golang.org/pkg/net/rpc/
灰子学技术：
有疑问加站长微信联系（非本文作者））
