RPC介绍及跨语言应用（go-php）

一、RPC介绍及原理

RPC（Remote Procedure Call）翻译过来是远程过程调度，一般应用在微服务中，用于多个服务间进行通信，也是一种网络通信协议

rpc的方言（协议）：tcp（常用）、http2（grpc框架使用这种）、http、udp ...

rpc的语义（序列化）：json、xml、protobuf ...

rpc通讯流程：

相互建立连接协议(自定义，常用tcp)，连接可以是短连接也可以长连接
server-A 通过Rpc框架根据 ip,port,method等信息通过 rpcClient将请求封装后，传递给server-B【信息会序列化】
Server-B 收到请求后对信息反序列化，恢复成请求的表达式，找到对应的方法进行调用，然后得到返回值
server-B 把返回值发送回 server-A ，也需要经过序列化的方式发送，server-A 反序列化给应用

使用rpc需注意的问题：

根据服务的情况知道它的压力上限，做好限流
调用服务异常时，要考虑降级、慎重考虑重试等措施
核心的服务不能强依赖于非核心的服务，否则一旦非核心的服务崩了，会导致核心服务出现异常

go底层实现 rpc 原理：包在 net\rpc 下

二、rpc和http的区别

调用方式不同

http通过url进行调用，rpc通过函数/方法进行调用
参数传递不同

http通过在url或者body中传参，rpc通过函数/方法的参数进行传参
性能方面

rpc通常比http更快，http基于tcp，rpc可使用tcp或者http。虽然核心都是tcp通信，但是比http少了很多臃肿的封装；而且rpc会有一些优化的技术，如：连接池、批量请求等等
应用场景

http一般应用在浏览器或其他客户端与应用程序（服务端）之间的通信，提供如 RESTful 风格的API服务

rpc一般应用在分布式微服务系统中，对部署在不同机器上的服务进行通信

三、go实现rpc通信

1. rpc

客户端

package main

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

type User struct {
    Id   int
    Name string
    Pass string
}
type UserReq struct {
    Name string
    Pass string
}
type UserResp struct {
    Code int
    Msg  string
    Data *User
}

func main() {
    conn, err := rpc.DialHTTP("tcp", ":8000")
    if err != nil {
        log.Fatal(err)
    }
    var resp UserResp
    
    // 测试：发送一个正确的信息
    err = conn.Call("User.Login", UserReq{
        Name: "0000",
        Pass: "0000",
    }, &resp)
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(resp, resp.Data) // {200 查询成功 0xc000180a20} &{0 0000 0000}
    
    // 测试：发送一个错误的信息
    err = conn.Call("User.Login", UserReq1{
        Name: "1234",
        Pass: "1111",
    }, &resp)
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(resp, resp.Data) // {404 数据不存在 0xc000180a20} &{0 0000 0000}
}

服务端

package main

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

type User struct {
    Id   int
    Name string
    Pass string
}

type UserReq struct {
    Name string
    Pass string
}
type UserResp struct {
    Code int
    Msg  string
    Data *User
}

// 定义数据源，实际会去数据库查询
var users = map[string]*User{
    "0000": {0, "0000", "0000"},
    "1111": {1, "1111", "1111"},
}

func main() {
    // 创建服务
    server := new(User)
    // 注册服务
    err := rpc.Register(server)
    if err != nil {
        log.Panicln("服务注册失败")
    }
    // 绑定服务
    rpc.HandleHTTP()
    // 启动服务
    if err = http.ListenAndServe(":8000", nil); err != nil {
        log.Panicln("服务启动失败")
    }

    log.Panicln("服务启动成功")
}

func (u *User) Login(req UserReq, resp *UserResp) error {
    user, ok := users[req.Name]
    if !ok {
        // 这里注意，不能写成 resp = &UserResp{}
        *resp = &UserResp{
            Code: 404,
            Msg:  "数据不存在",
            Data: nil,
        }
        return nil
    }
    if user.Pass != req.Pass {
        *resp = UserResp{
            Code: 500,
            Msg:  "密码不正确",
            Data: nil,
        }
        return nil
    }

    *resp = UserResp{
        Code: 200,
        Msg:  "查询成功",
        Data: user,
    }

    return nil
}

2. json-rpc

因为go底层是使用GOB编程的，用的 encoding/gob ，有些语言是不支持的，所以如果要跨语言通信，建议rpc的语义使用万金油：json

PS：go自带 net/rpc/jsonrpc 包，但是是1.0的版本，不能与2.0的版本通信

客户端：

package main

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

type User struct {
    Id   int
    Name string
    Pass string
}
type UserReq struct {
    Name string
    Pass string
}
type UserResp struct {
    Code int
    Msg  string
    Data *User
}

func main() {
    conn, err := jsonrpc.Dial("tcp", "127.0.0.1:9503")
    if err != nil {
        log.Fatal(err)
    }
    var resp UserResp
    err = conn.Call("User.Login", UserReq{
        Name: "0000",
        Pass: "0000",
    }, &resp)
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(resp, resp.Data) // {200 查询成功 0xc000090810} &{0 0000 0000}

}

服务端

package main

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

type User struct {
    Id   int
    Name string
    Pass string
}

type UserReq struct {
    Name string
    Pass string
}
type UserResp struct {
    Code int
    Msg  string
    Data *User
}

var users = map[string]*User{
    "0000": {0, "0000", "0000"},
    "1111": {1, "1111", "1111"},
}

func main() {
    // 创建服务
    server := new(User)
    // 注册服务
    if err := rpc.Register(server); err != nil {
        log.Panicln("服务注册失败")
    }

    listen, err := net.Listen("tcp", ":8000")
    if err != nil {
        log.Panicln(err)
    }

    for {
        conn, err := listen.Accept()
        if err != nil {
            continue
        }
        go func() {
            // 使用json方式通信并处理
            jsonrpc.ServeConn(conn)
        }()
    }
}

func (u *User) Login(req UserReq, resp *UserResp) error {
    user, ok := users[req.Name]
    if !ok {
        *resp = UserResp{
            Code: 404,
            Msg:  "数据不存在",
            Data: nil,
        }
        return nil
    }
    if user.Pass != req.Pass {
        *resp = UserResp{
            Code: 500,
            Msg:  "密码不正确",
            Data: nil,
        }
        return nil
    }

    *resp = UserResp{
        Code: 200,
        Msg:  "查询成功",
        Data: user,
    }

    return nil
}

四、跨语言通信：go - hyperf（PHP协程框架）

前言

因为go自带的jsonrpc包是1.0版本，hyperf的 json-rpc 组件包是2.0的版本，所以需要给go先安装一个jsonrpc2.0的版本

我这里使用到了第三方库，也可以使用别的，直接去github上搜就可以
```
go get -u github.com/iloveswift/go-jsonrpc
```
hyperf 需要安装 json-rpc 组件包及进行一些配置，直接参考官方文档即可：https://hyperf.wiki/3.0/#/zh-cn/json-rpc

下边案例只放了核心业务代码

案例一. go 客户端；hyperf 服务端

package main

import (
    "fmt"
    jrpc "github.com/iloveswift/go-jsonrpc"
)

type Mem struct {
    Id   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

type MemReq struct {
    UserId []int `json:"user_id"` // 请求单条数据可以直接定义为 int
}

type MemResp struct {
    Code int
    Msg  string
    Data []Mem
}

func main() {
    c, _ := jrpc.NewClient("http", "127.0.0.1", "9503")
    // 单个请求
    res := new(MemResp)
    err := c.Call("member/info", MemReq{[]int{1, 2}}, res, true) // 请求单个值可以直接写 MemReq{1}
    fmt.Println(err)
    fmt.Println(*res) // {200 ok [{1 111 26} {2 222 28}]}

    // 这里虽然提供了批量请求方式，但是经过测试，始终报错 Method not found. 未找到原因...
    //res1 := new(MemResp)
    //c.BatchAppend("member/info", MemReq{[]int{1, 2}}, res, true)
    //err := c.BatchCall()
    //fmt.Println(err)
    //fmt.Println(*res1)
}

hyperf

<?php

namespace App\JsonRpc;

use Hyperf\RpcServer\Annotation\RpcService;

#[RpcService(name: "MemberService", protocol: "jsonrpc-http", server: "jsonrpc-http")]
class MemberService
{
    public function info(mixed $user_id): array
    {
        var_dump($user_id);
        // 模拟数据库用户数据
        $users = [
            1 => ['id' => 1, 'name' => '111', 'age' => 26],
            2 => ['id' => 2, 'name' => '222', 'age' => 28],
            3 => ['id' => 3, 'name' => '333', 'age' => 32],
        ];
        $data = [];
        if (is_array($user_id)) {
            foreach ($user_id as $id) {
                $data[] = $users[$id];
            }
        } elseif (is_numeric($user_id)) {
            $data = $users[$user_id];
        } else {
            return [
                'code' => 500,
                'msg' => '参数错误',
                'data' => []
            ];
        }

        return [
            'code' => 200,
            'msg' => 'ok',
            'data' => $data
        ];
    }
}

案例二. go 服务端；hyperf 客户端

package main

import (
    "fmt"
    jrpc "github.com/iloveswift/go-jsonrpc"
)

type ClientLog struct{}

type LogReq struct {
    JobId int
    Sn    string
}

type Result struct {
    Id     int
    Status int
    Name   string
}

type LogResp struct {
    Code    int
    Message string
    Data    Result
}

func main() {
    s, _ := jrpc.NewServer("http", "127.0.0.1", "8000")
    s.Register(new(ClientLog))
    s.Start()
}

func (*ClientLog) GetLog(req *LogReq, res *LogResp) error {
    // 模拟用户数据
    data := map[string]Result{
        "1-qwe": Result{1, 0, "job-1"},
        "2-asd": Result{2, 1, "job-2"},
    }

    val, _ := data[fmt.Sprintf("%d-%s", req.JobId, req.Sn)]

    *res = LogResp{
        Code:    200,
        Message: "ok",
        Data:    val,
    }
    //*res = interface{}(val).(Result)

    return nil
}

hyperf：消费者类

<?php

namespace App\JsonRpc;

use Hyperf\RpcClient\AbstractServiceClient;

class LogServiceConsumer extends AbstractServiceClient
{
    /**
     * 定义对应服务提供者的服务名称
     */
    protected $serviceName = 'ClientLog';

    /**
     * 定义对应服务提供者的服务协议
     */
    protected $protocol = 'jsonrpc-http';

    public function GetLog(int $jobid, string $sn): array
    {
        return $this->__request(__FUNCTION__, compact('jobid', 'sn'));
    }
}

hyperf：测试

<?php

declare(strict_types=1);

namespace App\Controller;

use App\JsonRpc\LogServiceConsumer;
use Hyperf\Di\Annotation\Inject;

class IndexController extends AbstractController
{
    #[Inject]
    protected LogServiceConsumer $consumer;

    public function index()
    {
        $params = $this->request->all();
        $res = $this->consumer->GetLog((int)$params['jobid'], $params['sn']);
        var_dump($res);
        /**
        array(3) {
          ["Code"]=>
          int(200)
          ["Message"]=>
          string(2) "ok"
          ["Data"]=>
          array(3) {
            ["Id"]=>
            int(1)
            ["Status"]=>
            int(0)
            ["Name"]=>
            string(5) "job-1"
          }
        }
        */
    }
}