一.简介

在上一节简单了解了微服务定义和优缺点之后，在使用微服务框架之前，需要首先了解一下RPC架构,通过RPC可以更形象了解微服务的工作流程

RPC的概念

RPC(Remote Procedure Call Protocol)，是远程过程调用的缩写，通俗的说就是调用远处的一个函数,与之相对应的是本地函数调用，先来看一下本地函数调用:当写下如下代码的时候：
result := Add(1,2)
传入了1，2两个参数，调用了本地代码中的一个Add函数，得到result这个返回值,这时参数，返回值，代码段都在一个进程空间内，这是本地函数调用。那有没有办法，能够调用一个跨进程（所以叫"远程"，典型的事例，这个进程部署在另一台服务器上）的函数呢?

这就是 RPC主要实现的功能，也是微服务的主要功能

RPC入门

使用微服务化的一个好处就是：

(1).不限定服务的提供方使用什么技术选型，能够实现公司跨团队的技术解耦

(2).每个服务都被封装成进程,彼此"独立"

(3).使用微服务可以跨进程通信

RPC协议可以实现不同语言的直接相互调用,在互联网时代， RPC已经和 IPC(进程间通信)一样成为一个不可或缺的基础构件

IPC：进程间通信

RPC：远程进通信 —— 应用层协议（http协议同层）,底层使用 TCP 实现

在golang中实现RPC非常简单，有封装好的官方库和一些第三方库提供支持,Go RPC可以利用tcp或http来传递数据，可以对要传递的数据使用多种类型的编解码方式。golang官方的net/rpc库使用encoding/gob进行编解码，支持tcp或http数据传输方式，由于其他语言不支持gob编解码方式，所以使用net/rpc库实现的RPC方法没办法进行跨语言调用。

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

除了golang官方提供的rpc库，还有许多第三方库为在golang中实现RPC提供支持，大部分第三方rpc库的实现都是使用protobuf进行数据编解码，根据protobuf声明文件自动生成rpc方法定义与服务注册代码，在golang中可以很方便的进行rpc服务调用

二.net/rpc库实现远程调用

使用http作为RPC的载体实现远程调用（了解）

演示如何使用golang官方的 net/rpc 库实现RPC方法，使用 http 作为RPC的载体，通过 net/http 包监听客户端连接请求。http基于tcp，多一层封包和几次握手校验，性能自然比直接用tcp实现网络传输要差一些，所以RPC微服务中一般使用的都是tcp

(1).创建RPC微服务端

新建server/main.go

package main
import (
    "fmt"
    "log"
    "net"
    "net/http"
    "net/rpc"
    "os"
)
// 定义类对象
type World struct {
}
// 绑定类方法
func (this *World) HelloWorld(req string, res *string) error {
    *res = req + " 你好!"
    return nil
    //return errors.New("未知的错误!")
}

// 绑定类方法
func (this *World) Print(req string, res *string) error {
    *res = req + " this is Print!"
    return nil
    //return errors.New("未知的错误!")
}

func main() {
    // 1. 注册RPC服务
    rpc.Register(new(World)) // 注册rpc服务
    rpc.HandleHTTP() // 采用http协议作为rpc载体
    // 2. 设置监听
    lis, err := net.Listen("tcp", "127.0.0.1:8800")
    if err != nil {
        log.Fatalln("fatal error: ", err)
    }
    fmt.Fprintf(os.Stdout, "%s", "start connection")
    // 3. 建立链接
    http.Serve(lis, nil)
}

注意:以上World结构体的方法方法必须满足Go语言的RPC规则：

方法只能有两个可序列化的参数，其中第二个参数是指针类型,参数的类型不能是channel（通道）、complex（复数类型）、func（函数）,因为它们不能进行序列化

方法要返回一个error类型，同时必须是公开的方法

(2). 创建RPC客户端

客户端可以是 go web 也可以是一个 go应用,新建client/main.go

package main
import (
    "fmt"
    "net/rpc"
)

func main() {
    // 1. 用 rpc 链接服务器 --Dial()
    conn, err := rpc.DialHTTP("tcp", "127.0.0.1:8800")
    if err != nil {
        fmt.Println("Dial err:", err)
        return
    }

    defer conn.Close()

    // 2. 调用远程函数
    var reply1 string // 接受返回值 --- 传出参数
    err1 := conn.Call("World.HelloWorld", "张三", &reply1)
    if err1 != nil {
        fmt.Println("Call:", err1)
        return
    }

    fmt.Println(reply1)

    var reply2 string // 接受返回值 --- 传出参数
    err2 := conn.Call("World.Print", "李四", &reply2)
    if err2 != nil {
        fmt.Println("Call:", err2)
        return
    }
    fmt.Println(reply2)
}

使用tcp作为RPC的载体实现远程调用

(1).创建RPC微服务端

新建server/main.go

package main

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

// 定义类对象
type World struct {}

// 绑定类方法
func (this *World) HelloWorld(req string, res *string) error {
    *res = req + " 你好!"
    return nil
}

func main() {
    // 1. 注册RPC服务
    err := rpc.RegisterName("hello", new(World))
    if err != nil {
        fmt.Println("注册 rpc 服务失败!", err)
        return
    }
    // 2. 设置监听
    listener, err := net.Listen("tcp", "127.0.0.1:8800")
    if err != nil {
        fmt.Println("net.Listen err:", err)
        return
    }

    defer listener.Close()
    fmt.Println("开始监听 ...")

    // 3. 建立链接
    for {
        //接收连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Accept() err:", err)
            return
        }
        // 4. 绑定服务
        go rpc.ServeConn(conn)
    }
}

注意:以上World结构体的方法方法必须满足Go语言的RPC规则：

方法只能有两个可序列化的参数，其中第二个参数是指针类型,参数的类型不能是channel（通道）、complex（复数类型）、func（函数）,因为它们不能进行序列化

方法要返回一个error类型，同时必须是公开的方法

(2). 创建RPC客户端

新建client/main.go

package main

import (
    "fmt"
    "net/rpc"
)

func main() {
    // 1. 用 rpc 链接服务器 --Dial()
    conn, err := rpc.Dial("tcp", "127.0.0.1:8800")
    if err != nil {
        fmt.Println("Dial err:", err)
        return
    }

    defer conn.Close()

    // 2. 调用远程函数
    var reply string // 接受返回值 --- 传出参数
    err = conn.Call("hello.HelloWorld", "张三", &reply)
    if err != nil {
        fmt.Println("Call:", err)
        return
    }
    fmt.Println(reply)
}

说明：
首选是通过rpc.Dial拨号RPC服务，然后通过client.Call调用具体的RPC方法,在调用client.Call时，第一个参数是用点号链接的RPC服务名字和方法名字，第二和第三个参数分别定义RPC方法的两个参数

三.使用tcp作为RPC的载体实现远程调用具体案例

案例1.简单使用

1.创建一个hello微服务端,编写微服务端RPC代码,完成后启动该微服务端
2.创建一个hello客户端,编写客户端RPC代码,完成后启动该客户端,访问微服务端RPC功能,并返回相关数据

(1).创建hello微服务端

创建mirco/server/hello/main.go文件,并编写代码,代码下所示:

package main

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

//rpc服务端

//定义一个远程调用的结构体,并创建一个远程调用的函数,函数一般是放在结构体中的
type  Hello struct  {

}

/*
说明:
    1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
        req 表示获取客户端传过来的数据
        res 表示给客户端返回数据
    2、方法要返回一个error类型，同时必须是公开的方法
    3、req和res的类型不能是：channel（通道）、func（函数）,因为以上类型均不能进行 序列化
*/
func (this Hello) SayHello(req string, res *string) error {
    fmt.Println("请求的参数:", req)
    //设置返回的数据
    *res = "你好" + req
    return nil
}

func main()  {
    //1、 注册RPC服务
    //hello: rpc服务名称
    err1 := rpc.RegisterName("hello", new(Hello))
    if err1 != nil {
        fmt.Println(err1)
    }

    //2、监听端口
    listen, err2 := net.Listen("tcp", "127.0.0.1:8080")
    if err2 != nil {
        fmt.Println(err2)
    }

    //3、应用退出的时候关闭监听端口
    defer listen.Close()

    for {  // for 循环, 一直进行连接,每个客户端都可以连接
        fmt.Println("开始创建连接")
        //4、建立连接
        conn, err3 := listen.Accept()
        if err3 != nil {
            fmt.Println(err3)
        }
        //5、绑定服务
        rpc.ServeConn(conn)
    }
}

(2).创建hello客户端

创建mirco/client/hello/main.go文件,并编写代码,代码下所示:

package main

import (
    "fmt"
    "net/rpc"
)

//rpc服务端

func main()  {
    //1、用 rpc.Dial和rpc微服务端建立连接
    conn, err1 := rpc.Dial("tcp", "127.0.0.1:8080")
    if err1 != nil {
        fmt.Println(err1)
    }
    //2、当客户端退出的时候关闭连接
    defer conn.Close()

    //3、调用远程函数
    //微服务端返回的数据
    var reply string
    /*
        1、第一个参数: hello.SayHello,hello 表示服务名称  SayHello 方法名称
        2、第二个参数: 给服务端的req传递数据
        3、第三个参数: 需要传入地址,获取微服务端返回的数据
    */
    err2 := conn.Call("hello.SayHello", "我是客户端", &reply)
    if err2 != nil {
        fmt.Println(err2)
    }
    //4、获取微服务返回的数据
    fmt.Println(reply)
}

(3).启动微服务端,以及客户端访问

启动微服务端

启动客户端

案例2.模拟实现一个goods的微服务,增加商品获取商品功能

1.创建一个goods微服务端,编写微服务端RPC代码,增加函数: 增加商品函数，获取商品函数，完成后启动该微服务端
2.创建一个goods客户端,编写客户端RPC代码,完成后启动该客户端,访问微服务端RPC功能,并返回相关数据

(1).创建goods微服务端

创建mirco/server/goods/main.go文件,并编写代码,代码下所示:

package main

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

// goods微服务:服务端,传入struct,增加商品,获取商品

//创建远程调用的函数，函数一般是放在结构体里面
type Goods struct{}

//AddGoods参数对应的结构体
//增加商品请求参数结构体
type AddGoodsReq struct {
    Id      int
    Title   string
    Price   float32
    Content string
}
//增加商品返回结构体
type AddGoodsRes struct {
    Success bool
    Message string
}

//GetGoods参数对应的结构体
//获取商品请求结构体
type GetGoodsReq struct {
    Id int
}
//获取商品返回结构体
type GetGoodsRes struct {
    Id      int
    Title   string
    Price   float32
    Content string
}

/*
说明:
    1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
        req 表示获取客户端传过来的数据
        res 表示给客户端返回数据
    2、方法要返回一个error类型，同时必须是公开的方法
    3、req和res的类型不能是：channel（通道）、func（函数）,因为以上类型均不能进行 序列化
*/

//增加商品函数
func (this Goods) AddGoods(req AddGoodsReq, res *AddGoodsRes)  error {
    //1、执行增加 模拟
    fmt.Printf("%#v\n", req)
    *res = AddGoodsRes{
        Success: true, //根据增加结果,返回状态
        Message: "增加商品成功",
    }
    return nil
}

//获取商品函数
func (this Goods) GetGoods(req GetGoodsReq, res *GetGoodsRes) error {
    //1、执行获取商品 模拟
    fmt.Printf("%#v\n", req)

    //2、返回获取的结果
    *res = GetGoodsRes{
        Id:      12,  //商品id
        Title:   "服务器获取的数据",
        Price:   24.5,
        Content: "我是服务器数据库获取的内容",
    }
    return nil
}

func main()  {
    //1、 注册RPC服务
    //goods: rpc服务名称
    err1 := rpc.RegisterName("goods", new(Goods))
    if err1 != nil {
        fmt.Println(err1)
    }

    //2、监听端口
    listen, err2 := net.Listen("tcp", "127.0.0.1:8080")
    if err2 != nil {
        fmt.Println(err2)
    }
    //3、应用退出的时候关闭监听端口
    defer listen.Close()

    for {  // for 循环, 一直进行连接,每个客户端都可以连接
        fmt.Println("准备建立连接")
        //4、建立连接
        conn, err3 := listen.Accept()
        if err3 != nil {
            fmt.Println(err3)
        }
        //5、绑定服务
        rpc.ServeConn(conn)
    }
}

(2).创建goods客户端

创建mirco/client/goods/main.go文件,并编写代码,代码下所示:

package main

import (
    "fmt"
    "net/rpc"
)

//AddGoods参数对应的结构体
//增加商品请求参数结构体
type AddGoodsReq struct {
    Id      int
    Title   string
    Price   float32
    Content string
}
//增加商品返回结构体
type AddGoodsRes struct {
    Success bool
    Message string
}

//GetGoods参数对应的结构体
//获取商品请求结构体
type GetGoodsReq struct {
    Id int
}
//获取商品返回结构体
type GetGoodsRes struct {
    Id      int
    Title   string
    Price   float32
    Content string
}

func main() {
    //1、用 rpc.Dial和rpc微服务端建立连接
    conn, err1 := rpc.Dial("tcp", "127.0.0.1:8080")
    if err1 != nil {
        fmt.Println(err1)
    }
    //2、当客户端退出的时候关闭连接
    defer conn.Close()

    //3、调用远程函数
    //微服务端返回的数据
    var reply AddGoodsRes
    /*
        1、第一个参数: goods.AddGoods,goods 表示服务名称  AddGoods 方法名称
        2、第二个参数: 给服务端的req传递数据
        3、第三个参数: 需要传入地址,获取微服务端返回的数据
    */
    err2 := conn.Call("goods.AddGoods", AddGoodsReq{
        Id:      10,
        Title:   "商品标题",
        Price:   23.5,
        Content: "商品详情",
    }, &reply)

    if err2 != nil {
        fmt.Println(err1)
    }
    //4、获取微服务返回的数据
    fmt.Println("%#v\n", reply)

    // 5、 调用远程GetGoods函数
    var goodsData GetGoodsRes
    err3 := conn.Call("goods.GetGoods", GetGoodsReq{
        Id: 12,
    }, &goodsData)
    if err3 != nil {
        fmt.Println(err3)
    }
    //6、获取微服务返回的数据
    fmt.Printf("%#v", goodsData)
}

(3).启动微服务端,以及客户端访问

启动微服务端

启动客户端

四.net/rpc/jsonrpc库以及RPC跨语言

标准库的RPC默认采用Go语言特有的 gob编码，没法实现跨语言调用,golang官方还提供了 net/rpc/jsonrpc库实现RPC方法，JSON RPC采用JSON进行数据编解码，因而支持跨语言调用, 但目前的jsonrpc库是基于tcp协议实现的，暂时不支持使用http进行数据传输

Linux命令之nc创建tcp服务测试数据传输

nc是 netcat的简写，是一个功能强大的网络工具，有着网络界的瑞士军刀美誉,nc命令的主要作用如下：

实现任意TCP/UDP端口的侦听，nc可以作为server以TCP或UDP方式侦听指定端口

端口的扫描，nc可以作为client发起TCP或UDP连接

机器之间传输文件

机器之间网络测速

centos中如果找不到nc命令可以使用 yum install -y nc 安装

使用nc作为微服务server端接收客户端数据

nc -l 192.XXX.XXX.XXX 8080

nc作为微服务server端开启:

客户端请求和上面案例一致,也可以参考下面案例

上面讲解了使用 net/rpc 实现RPC的过程，但是没办法在其他语言中调用上面例子实现的RPC方法。所以接下来使用 net/rpc/jsonrpc 库实现RPC方法，此方式实现的 RPC方法支持跨语言调用

创建RPC微服务端

使用 net/rpc/jsonrpc 库实现RPC方法:
和rpc微服务端区别: 在 5. 绑定服务步骤中使用 rpc.ServeCodec(jsonrpc.NewServerCodec(conn))

package main

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

//rpc服务端

//定义一个远程调用的结构体,并创建一个远程调用的函数,函数一般是放在结构体中的
type  Hello struct  {

}

/*
说明:
    1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
        req 表示获取客户端传过来的数据
        res 表示给客户端返回数据
    2、方法要返回一个error类型，同时必须是公开的方法
    3、req和res的类型不能是：channel（通道）、func（函数）,因为以上类型均不能进行 序列化
*/
func (this Hello) SayHello(req string, res *string) error {
    fmt.Println("请求的参数:", req)
    //设置返回的数据
    *res = "你好" + req
    return nil
}

func main()  {
    //1、 注册RPC服务
    //hello: rpc服务名称
    err1 := rpc.RegisterName("hello", new(Hello))
    if err1 != nil {
        fmt.Println(err1)
    }

    //2、监听端口
    listen, err2 := net.Listen("tcp", "127.0.0.1:8080")
    if err2 != nil {
        fmt.Println(err2)
    }

    //3、应用退出的时候关闭监听端口
    defer listen.Close()

    for {  // for 循环, 一直进行连接,每个客户端都可以连接
        fmt.Println("开始创建连接")
        //4、建立连接
        conn, err3 := listen.Accept()
        if err3 != nil {
            fmt.Println(err3)
        }
        //5、绑定服务
        //rpc.ServeConn(conn)

        // 5. 绑定服务
        /*
           jsonrpc和默认rpc的区别：
                   以前rpc.ServeConn(conn)绑定服务
                   jsonrpc中通过rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
        */
        rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
    }
}

代码中最大的变化是用 rpc.ServeCodec函数替代了 rpc.ServeConn函数，传入的参数是针对服务端的json编解码器

创建RPC客户端

package main

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

//rpc服务端

/*
把默认的rpc 改为jsonrpc
    1、rpc.Dial需要调换成net.Dial
    2、增加建立基于json编解码的rpc服务  client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
    3、conn.Call 需要改为client.Call
*/

func main()  {
    //1、用 net.Dial和rpc微服务端建立连接
    conn, err1 := net.Dial("tcp", "127.0.0.1:8080")
    if err1 != nil {
        fmt.Println(err1)
    }
    //2、当客户端退出的时候关闭连接
    defer conn.Close()

    //建立基于json编解码的rpc服务
    client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))


    //3、调用远程函数
    //微服务端返回的数据
    var reply string
    /*
        1、第一个参数: hello.SayHello,hello 表示服务名称  SayHello 方法名称
        2、第二个参数: 给服务端的req传递数据
        3、第三个参数: 需要传入地址,获取微服务端返回的数据
    */
    err2 := client.Call("hello.SayHello", "张三", &reply)
    if err2 != nil {
        fmt.Println(err2)
    }
    //4、获取微服务返回的数据
    fmt.Println(reply)
}

先手工调用 net.Dial函数建立TCP链接，然后基于该链接建立针对客户端的json编解码器

启动微服务端,以及客户端访问

启动微服务端

启动客户端

RPC跨语言

以PHP跨语言调用RPC微服务为案例

PHP代码

<?php
class JsonRPC {
    private $conn;

    function __construct($host, $port) {
        $this->conn = fsockopen($host, $port, $errno, $errstr, 3);
        if (!$this->conn) {
            return false;
        }
    }

    public function Call($method, $params) {
        if (!$this->conn) {
            return false;
        }
        $err = fwrite($this->conn, json_encode(array(
                'method' => $method,
                'params' => array($params),
                'id' => 0,
            ))."\n");
        if ($err === false) {
            return false;
        }
        stream_set_timeout($this->conn, 0, 3000);
        $line = fgets($this->conn);
        if ($line === false) {
            return NULL;
        }
        return json_decode($line,true);
        }
    }
    $client = new JsonRPC("127.0.0.1", 8080);
    $args = "this is php aaa";
    $r = $client->Call("Hello.SayHello", $args);
    print_r($r);
?>

服务端启动和上面微服务端启动一致,php端访问,结果如下:

RPC协议封装

后期使用微服务框架 GRPC 和 Go-Micro的时候，都是使用框架封装好的服务和客户端，接下来通过一个简单的示例演示一下如何封装，以此来理解封装的原理,上面的代码服务名都是写死的，不够灵活（容易写错），这里对RPC的服务端和客户端再次进行一次封装，来屏蔽掉服务名，具体代码如下:

服务端封装

新建server/models/tools

package models

import "net/rpc"

var serverName = "HelloService"

type RPCInterface interface {
    HelloWorld(string, *string) error
}

// 调用该方法时, 需要给 i 传参, 参数应该是 实现了 HelloWorld 方法的类对象!
func RegisterService(i RPCInterface) {
    rpc.RegisterName(serverName, i)
}

封装之后的服务端实现如下:

package main

import (
    "fmt"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
    "server/models"
)
// 定义类对象
type World struct {}

// 绑定类方法
func (this *World) HelloWorld(req string, res *string) error {
    fmt.Println(req)
    *res = req + " 你好!"
    return nil
    //return errors.New("未知的错误!")
}

func main() {
    //注册rpc服务 维护一个hash表，key值是服务名称，value值是服务的地址
    // rpc.RegisterName("HelloService", new(World))
    models.RegisterService(new(World))
    //设置监听
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        panic(err)
    }
    for {
        //接收连接
        conn, err := listener.Accept()
        if err != nil {
            panic(err)
        }
        //给当前连接提供针对json格式的rpc服务
        go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
    }
}

客户端封装

新建client/models/tools

package models

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

var serverName = "HelloService"

type RPCClient struct {
    Client *rpc.Client
    Conn net.Conn
}

func NewRpcClient(addr string) RPCClient {
    conn, err := net.Dial("tcp", addr)
    if err != nil {
        fmt.Println("链接服务器失败")
        return RPCClient{}
    }
    //套接字和rpc服务绑定
    client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
    return RPCClient{Client: client, Conn: conn}
}

func (this *RPCClient) CallFunc(req string, resp *string) error {
    return this.Client.Call(serverName+".HelloWorld", req, resp)
}

封装之后客户端实现

package main

import (
    "client/models"
    "fmt"
)

func main() {
    //建立tcp连接
    client := models.NewRpcClient("127.0.0.1:8080")
    //关闭连接
    defer client.Conn.Close()

    var reply string // 接受返回值 --- 传出参数
    err := client.CallFunc("this is client", &reply)

    if err != nil {
        fmt.Println("Call:", err)
        return
    }
    fmt.Println(reply)
}

[上一节][golang 微服务] 1.单体式架构以及微服务架构介绍

[下一节][golang 微服务] 3. ProtoBuf认识与使用

[golang 微服务] 2. RPC架构介绍以及通过RPC实现微服务

一.简介

RPC的概念

RPC入门

二.net/rpc库实现远程调用

使用http作为RPC的载体实现远程调用（了解）

(1).创建RPC微服务端

(2). 创建RPC客户端

使用tcp作为RPC的载体实现远程调用

(1).创建RPC微服务端

(2). 创建RPC客户端

三.使用tcp作为RPC的载体实现远程调用具体案例

案例1.简单使用

(1).创建hello微服务端

(2).创建hello客户端

(3).启动微服务端,以及客户端访问

启动微服务端

启动客户端

案例2.模拟实现一个goods的微服务,增加商品获取商品功能

(1).创建goods微服务端

(2).创建goods客户端

(3).启动微服务端,以及客户端访问

启动微服务端

启动客户端

四.net/rpc/jsonrpc库以及RPC跨语言

Linux命令之nc创建tcp服务测试数据传输

创建RPC微服务端

创建RPC客户端

启动微服务端,以及客户端访问

启动微服务端

启动客户端

RPC跨语言

RPC协议封装

服务端封装

客户端封装

猜你喜欢

[golang 微服务] 2. RPC架构介绍以及通过RPC实现微服务

一.简介

RPC的概念

RPC入门

二.net/rpc库实现远程调用

使用http作为RPC的载体实现远程调用（了解）

(1).创建RPC微服务端

(2). 创建RPC客户端

使用tcp作为RPC的载体实现远程调用

(1).创建RPC微服务端

(2). 创建RPC客户端

三.使用tcp作为RPC的载体实现远程调用具体案例

案例1.简单使用

(1).创建hello微服务端

(2).创建hello客户端

(3).启动微服务端,以及客户端访问

启动微服务端

启动客户端

案例2.模拟实现一个goods的微服务,增加商品 获取商品功能

(1).创建goods微服务端

(2).创建goods客户端

(3).启动微服务端,以及客户端访问

启动微服务端

启动客户端

四.net/rpc/jsonrpc库以及RPC跨语言

Linux命令之nc创建tcp服务测试数据传输

创建RPC微服务端

创建RPC客户端

启动微服务端,以及客户端访问

启动微服务端

启动客户端

RPC跨语言

RPC协议封装

服务端封装

客户端封装

猜你喜欢

案例2.模拟实现一个goods的微服务,增加商品获取商品功能