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

一.简介

<blockquote class="kdocs-blockquote" style="">  在上一节简单相识了微服务界说和优缺点之后，在使用微服务框架之前，须要起宰衡识一下RPC架构,通过RPC可以更形象相识微服务的工作流程  

• RPC的概念
  

<blockquote class="kdocs-blockquote" style="">  RPC(Remote Procedure Call Protocol)，是  长途过程调用的缩写，普通的说就是  调用远处的一个函数,与之相对应的是  本地函数调用，先来看一下本地函数调用:当写下如下代码的时间：  
  result := Add(1,2)  
传入了1，2两个参数，调用了本地代码中的一个Add函数，得到result这个返回值,这时  参数，  返回值，  代码段都在一个进程空间内，这是  本地函数调用。  那有没有办法，可以大概调用一个  跨进程  （以是叫"长途"，范例的事例，这个进程摆设在  另一台服务器  上）的函数呢?           

       <blockquote class="kdocs-blockquote" style="">  这就是  RPC重要实现的功能，也是  微服务的重要功能  

• RPC入门
  

使用微服务化的一个利益就是：
(1).不限定服务的提供方使用什么技能选型，可以大概实现公司跨团队的技能解耦
(2).每个服务都被封装成进程,相互"独立"
(3).使用微服务可以跨进程通讯
         

       <blockquote class="kdocs-blockquote" style="">  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的载体实现长途调用（相识）
  

<blockquote class="kdocs-blockquote" style="">  演示怎样使用golang官方的 net/rpc 库实现RPC方法，使用   http 作为RPC的载体，通过 net/http 包监听客户端毗连哀求。http基于tcp，  多一层封包和反复握手校验，  性能自然比直接用tcp实现网络传输要  差一些，以是RPC微服务中一样寻常使用的都是tcp  (1).创建RPC微服务端

<blockquote class="kdocs-blockquote" style="">  新建server/main.go

1. package main
2. import (
3.     "fmt"
4.     "log"
5.     "net"
6.     "net/http"
7.     "net/rpc"
8.     "os"
9. )
10. // 定义类对象
11. type World struct {
12. }
13. // 绑定类方法
14. func (this *World) HelloWorld(req string, res *string) error {
15.     *res = req + " 你好!"
16.     return nil
17.     //return errors.New("未知的错误!")
18. }
20. // 绑定类方法
21. func (this *World) Print(req string, res *string) error {
22.     *res = req + " this is Print!"
23.     return nil
24.     //return errors.New("未知的错误!")
25. }
27. func main() {
28.     // 1. 注册RPC服务
29.     rpc.Register(new(World)) // 注册rpc服务
30.     rpc.HandleHTTP() // 采用http协议作为rpc载体
31.     // 2. 设置监听
32.     lis, err := net.Listen("tcp", "127.0.0.1:8800")
33.     if err != nil {
34.         log.Fatalln("fatal error: ", err)
35.     }
36.     fmt.Fprintf(os.Stdout, "%s", "start connection")
37.     // 3. 建立链接
38.     http.Serve(lis, nil)
39. }

复制代码

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

• 方法只能有两个可序列化的参数，此中第二个参数是指针范例,参数的范例不能是channel（通道）、complex（复数范例）、func（函数）,由于它们不能举行 序列化
  

• 方法要返回一个error范例，同时必须是公开的方法
  

(2). 创建RPC客户端

<blockquote class="kdocs-blockquote" style="">  客户端可以是  go web 也可以是一个  go应用,新建client/main.go

1. package main
2. import (
3.     "fmt"
4.     "net/rpc"
5. )
7. func main() {
8.     // 1. 用 rpc 链接服务器 --Dial()
9.     conn, err := rpc.DialHTTP("tcp", "127.0.0.1:8800")
10.     if err != nil {
11.         fmt.Println("Dial err:", err)
12.         return
13.     }
15.     defer conn.Close()
17.     // 2. 调用远程函数
18.     var reply1 string // 接受返回值 --- 传出参数
19.     err1 := conn.Call("World.HelloWorld", "张三", &reply1)
20.     if err1 != nil {
21.         fmt.Println("Call:", err1)
22.         return
23.     }
25.     fmt.Println(reply1)
27.     var reply2 string // 接受返回值 --- 传出参数
28.     err2 := conn.Call("World.Print", "李四", &reply2)
29.     if err2 != nil {
30.         fmt.Println("Call:", err2)
31.         return
32.     }
33.     fmt.Println(reply2)
34. }

复制代码

• 使用tcp作为RPC的载体实现长途调用
  

(1).创建RPC微服务端

<blockquote class="kdocs-blockquote" style="">  新建server/main.go

1. package main
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7. )
9. // 定义类对象
10. type World struct {}
12. // 绑定类方法
13. func (this *World) HelloWorld(req string, res *string) error {
14.     *res = req + " 你好!"
15.     return nil
16. }
18. func main() {
19.     // 1. 注册RPC服务
20.     err := rpc.RegisterName("hello", new(World))
21.     if err != nil {
22.         fmt.Println("注册 rpc 服务失败!", err)
23.         return
24.     }
25.     // 2. 设置监听
26.     listener, err := net.Listen("tcp", "127.0.0.1:8800")
27.     if err != nil {
28.         fmt.Println("net.Listen err:", err)
29.         return
30.     }
32.     defer listener.Close()
33.     fmt.Println("开始监听 ...")
35.     // 3. 建立链接
36.     for {
37.         //接收连接
38.         conn, err := listener.Accept()
39.         if err != nil {
40.             fmt.Println("Accept() err:", err)
41.             return
42.         }
43.         // 4. 绑定服务
44.         go rpc.ServeConn(conn)
45.     }
46. }

复制代码

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

• 方法只能有两个可序列化的参数，此中第二个参数是指针范例,参数的范例不能是channel（通道）、complex（复数范例）、func（函数）,由于它们不能举行 序列化
  

• 方法要返回一个error范例，同时必须是公开的方法
  

(2). 创建RPC客户端

<blockquote class="kdocs-blockquote" style="">  新建client/main.go

1. package main
3. import (
4.     "fmt"
5.     "net/rpc"
6. )
8. func main() {
9.     // 1. 用 rpc 链接服务器 --Dial()
10.     conn, err := rpc.Dial("tcp", "127.0.0.1:8800")
11.     if err != nil {
12.         fmt.Println("Dial err:", err)
13.         return
14.     }
16.     defer conn.Close()
18.     // 2. 调用远程函数
19.     var reply string // 接受返回值 --- 传出参数
20.     err = conn.Call("hello.HelloWorld", "张三", &reply)
21.     if err != nil {
22.         fmt.Println("Call:", err)
23.         return
24.     }
25.     fmt.Println(reply)
26. }

复制代码

<blockquote class="kdocs-blockquote" style="">  阐明：   
   首选是通过rpc.Dial拨号RPC服务，然后通过client.Call调用详细的RPC方法,在调用client.Call时，第一个参数是用点号链接的RPC服务名字和方法名字，第二和第三个参数分别界说RPC方法的两个参数  三.使用tcp作为RPC的载体实现长途调用详细案例

案例1.简单使用

<blockquote class="kdocs-blockquote" style="">  1.创建一个hello微服务端,编写微服务端RPC代码,完成后启动该微服务端  
2.创建一个hello客户端,编写客户端RPC代码,完成后启动该客户端,访问微服务端RPC功能,并返回相干数据  (1).创建hello微服务端

<blockquote class="kdocs-blockquote" style="">  创建mirco/server/hello/main.go文件,并编写代码,代码下所示:

1. package main
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7. )
9. //rpc服务端
11. //定义一个远程调用的结构体,并创建一个远程调用的函数,函数一般是放在结构体中的
12. type  Hello struct  {
14. }
16. /*
17. 说明:
18.     1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
19.         req 表示获取客户端传过来的数据
20.         res 表示给客户端返回数据
21.     2、方法要返回一个error类型，同时必须是公开的方法
22.     3、req和res的类型不能是：channel（通道）、func（函数）,因为以上类型均不能进行 序列化
23. */
24. func (this Hello) SayHello(req string, res *string) error {
25.     fmt.Println("请求的参数:", req)
26.     //设置返回的数据
27.     *res = "你好" + req
28.     return nil
29. }
31. func main()  {
32.     //1、 注册RPC服务
33.     //hello: rpc服务名称
34.     err1 := rpc.RegisterName("hello", new(Hello))
35.     if err1 != nil {
36.         fmt.Println(err1)
37.     }
39.     //2、监听端口
40.     listen, err2 := net.Listen("tcp", "127.0.0.1:8080")
41.     if err2 != nil {
42.         fmt.Println(err2)
43.     }
45.     //3、应用退出的时候关闭监听端口
46.     defer listen.Close()
48.     for {  // for 循环, 一直进行连接,每个客户端都可以连接
49.         fmt.Println("开始创建连接")
50.         //4、建立连接
51.         conn, err3 := listen.Accept()
52.         if err3 != nil {
53.             fmt.Println(err3)
54.         }
55.         //5、绑定服务
56.         rpc.ServeConn(conn)
57.     }
58. }

复制代码

(2).创建hello客户端

<blockquote class="kdocs-blockquote" style="">  创建mirco/client/hello/main.go文件,并编写代码,代码下所示:

1. package main
3. import (
4.     "fmt"
5.     "net/rpc"
6. )
8. //rpc服务端
10. func main()  {
11.     //1、用 rpc.Dial和rpc微服务端建立连接
12.     conn, err1 := rpc.Dial("tcp", "127.0.0.1:8080")
13.     if err1 != nil {
14.         fmt.Println(err1)
15.     }
16.     //2、当客户端退出的时候关闭连接
17.     defer conn.Close()
19.     //3、调用远程函数
20.     //微服务端返回的数据
21.     var reply string
22.     /*
23.         1、第一个参数: hello.SayHello,hello 表示服务名称  SayHello 方法名称
24.         2、第二个参数: 给服务端的req传递数据
25.         3、第三个参数: 需要传入地址,获取微服务端返回的数据
26.     */
27.     err2 := conn.Call("hello.SayHello", "我是客户端", &reply)
28.     if err2 != nil {
29.         fmt.Println(err2)
30.     }
31.     //4、获取微服务返回的数据
32.     fmt.Println(reply)
33. }

复制代码

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

启动微服务端

         

       启动客户端

         

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

<blockquote class="kdocs-blockquote" style="text-align:left;">  1.创建一个goods微服务端,编写微服务端RPC代码,增长函数:  增长商品函数，获取商品函数，完成后启动该微服务端  
2.创建一个goods客户端,编写客户端RPC代码,完成后启动该客户端,访问微服务端RPC功能,并返回相干数据  (1).创建goods微服务端

<blockquote class="kdocs-blockquote" style="text-align:left;">  创建mirco/server/goods/main.go文件,并编写代码,代码下所示:

1. package main
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7. )
9. // goods微服务:服务端,传入struct,增加商品,获取商品
11. //创建远程调用的函数，函数一般是放在结构体里面
12. type Goods struct{}
14. //AddGoods参数对应的结构体
15. //增加商品请求参数结构体
16. type AddGoodsReq struct {
17.     Id      int
18.     Title   string
19.     Price   float32
20.     Content string
21. }
22. //增加商品返回结构体
23. type AddGoodsRes struct {
24.     Success bool
25.     Message string
26. }
28. //GetGoods参数对应的结构体
29. //获取商品请求结构体
30. type GetGoodsReq struct {
31.     Id int
32. }
33. //获取商品返回结构体
34. type GetGoodsRes struct {
35.     Id      int
36.     Title   string
37.     Price   float32
38.     Content string
39. }
41. /*
42. 说明:
43.     1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
44.         req 表示获取客户端传过来的数据
45.         res 表示给客户端返回数据
46.     2、方法要返回一个error类型，同时必须是公开的方法
47.     3、req和res的类型不能是：channel（通道）、func（函数）,因为以上类型均不能进行 序列化
48. */
50. //增加商品函数
51. func (this Goods) AddGoods(req AddGoodsReq, res *AddGoodsRes)  error {
52.     //1、执行增加 模拟
53.     fmt.Printf("%#v\n", req)
54.     *res = AddGoodsRes{
55.         Success: true, //根据增加结果,返回状态
56.         Message: "增加商品成功",
57.     }
58.     return nil
59. }
61. //获取商品函数
62. func (this Goods) GetGoods(req GetGoodsReq, res *GetGoodsRes) error {
63.     //1、执行获取商品 模拟
64.     fmt.Printf("%#v\n", req)
66.     //2、返回获取的结果
67.     *res = GetGoodsRes{
68.         Id:      12,  //商品id
69.         Title:   "服务器获取的数据",
70.         Price:   24.5,
71.         Content: "我是服务器数据库获取的内容",
72.     }
73.     return nil
74. }
76. func main()  {
77.     //1、 注册RPC服务
78.     //goods: rpc服务名称
79.     err1 := rpc.RegisterName("goods", new(Goods))
80.     if err1 != nil {
81.         fmt.Println(err1)
82.     }
84.     //2、监听端口
85.     listen, err2 := net.Listen("tcp", "127.0.0.1:8080")
86.     if err2 != nil {
87.         fmt.Println(err2)
88.     }
89.     //3、应用退出的时候关闭监听端口
90.     defer listen.Close()
92.     for {  // for 循环, 一直进行连接,每个客户端都可以连接
93.         fmt.Println("准备建立连接")
94.         //4、建立连接
95.         conn, err3 := listen.Accept()
96.         if err3 != nil {
97.             fmt.Println(err3)
98.         }
99.         //5、绑定服务
100.         rpc.ServeConn(conn)
101.     }
102. }

复制代码

(2).创建goods客户端

<blockquote class="kdocs-blockquote" style="text-align:left;">  创建mirco/client/goods/main.go文件,并编写代码,代码下所示:

1. package main
3. import (
4.     "fmt"
5.     "net/rpc"
6. )
8. //AddGoods参数对应的结构体
9. //增加商品请求参数结构体
10. type AddGoodsReq struct {
11.     Id      int
12.     Title   string
13.     Price   float32
14.     Content string
15. }
16. //增加商品返回结构体
17. type AddGoodsRes struct {
18.     Success bool
19.     Message string
20. }
22. //GetGoods参数对应的结构体
23. //获取商品请求结构体
24. type GetGoodsReq struct {
25.     Id int
26. }
27. //获取商品返回结构体
28. type GetGoodsRes struct {
29.     Id      int
30.     Title   string
31.     Price   float32
32.     Content string
33. }
35. func main() {
36.     //1、用 rpc.Dial和rpc微服务端建立连接
37.     conn, err1 := rpc.Dial("tcp", "127.0.0.1:8080")
38.     if err1 != nil {
39.         fmt.Println(err1)
40.     }
41.     //2、当客户端退出的时候关闭连接
42.     defer conn.Close()
44.     //3、调用远程函数
45.     //微服务端返回的数据
46.     var reply AddGoodsRes
47.     /*
48.         1、第一个参数: goods.AddGoods,goods 表示服务名称  AddGoods 方法名称
49.         2、第二个参数: 给服务端的req传递数据
50.         3、第三个参数: 需要传入地址,获取微服务端返回的数据
51.     */
52.     err2 := conn.Call("goods.AddGoods", AddGoodsReq{
53.         Id:      10,
54.         Title:   "商品标题",
55.         Price:   23.5,
56.         Content: "商品详情",
57.     }, &reply)
59.     if err2 != nil {
60.         fmt.Println(err1)
61.     }
62.     //4、获取微服务返回的数据
63.     fmt.Println("%#v\n", reply)
65.     // 5、 调用远程GetGoods函数
66.     var goodsData GetGoodsRes
67.     err3 := conn.Call("goods.GetGoods", GetGoodsReq{
68.         Id: 12,
69.     }, &goodsData)
70.     if err3 != nil {
71.         fmt.Println(err3)
72.     }
73.     //6、获取微服务返回的数据
74.     fmt.Printf("%#v", goodsData)
75. }

复制代码

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

启动微服务端

         

       启动客户端

         

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

<blockquote class="kdocs-blockquote" style="">  标准库的RPC默认采取Go语言特有的  gob编码，  没法实现跨语言调用,golang官方还提供了  net/rpc/jsonrpc库实现RPC方法，JSON RPC采  用JSON举行数据编解码，因而  支持跨语言调用,  但现在的jsonrpc库是  基于tcp协议  实现的，临时不支持使用http举行数据传输  

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

<blockquote class="kdocs-blockquote" style="">  nc是  netcat的简写，是一个功能强大的网络工具，有着网络界的瑞士军刀美誉,nc下令的  重要作用如下：  

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

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

• 呆板之间传输文件
  

• 呆板之间网络测速
  

<blockquote class="kdocs-blockquote" style="">  centos中如果找不到nc下令可以使用 yum install -y nc 安装  使用nc作为微服务server端吸收客户端数据

1. nc -l 192.XXX.XXX.XXX 8080

复制代码

nc作为微服务server端开启:
         

       客户端哀求和上面案例划一,也可以参考下面案例
<blockquote class="kdocs-blockquote" style="">  上面解说了使用 net/rpc 实现RPC的过程，但是没办法在其他语言中调用上面例子实现的RPC方法。以是接下来使用   net/rpc/jsonrpc 库实现RPC方法，此方式实现的  RPC方法支持跨语言调用  

• 创建RPC微服务端
  

<blockquote class="kdocs-blockquote" style="">  使用   net/rpc/jsonrpc 库实现RPC方法:  
和rpc微服务端区别: 在 5. 绑定服务步调中使用  rpc.ServeCodec(jsonrpc.NewServerCodec(conn))

1. package main
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7.     "net/rpc/jsonrpc"
8. )
10. //rpc服务端
12. //定义一个远程调用的结构体,并创建一个远程调用的函数,函数一般是放在结构体中的
13. type  Hello struct  {
15. }
17. /*
18. 说明:
19.     1、方法只能有两个可序列化的参数，其中第二个参数是指针类型
20.         req 表示获取客户端传过来的数据
21.         res 表示给客户端返回数据
22.     2、方法要返回一个error类型，同时必须是公开的方法
23.     3、req和res的类型不能是：channel（通道）、func（函数）,因为以上类型均不能进行 序列化
24. */
25. func (this Hello) SayHello(req string, res *string) error {
26.     fmt.Println("请求的参数:", req)
27.     //设置返回的数据
28.     *res = "你好" + req
29.     return nil
30. }
32. func main()  {
33.     //1、 注册RPC服务
34.     //hello: rpc服务名称
35.     err1 := rpc.RegisterName("hello", new(Hello))
36.     if err1 != nil {
37.         fmt.Println(err1)
38.     }
40.     //2、监听端口
41.     listen, err2 := net.Listen("tcp", "127.0.0.1:8080")
42.     if err2 != nil {
43.         fmt.Println(err2)
44.     }
46.     //3、应用退出的时候关闭监听端口
47.     defer listen.Close()
49.     for {  // for 循环, 一直进行连接,每个客户端都可以连接
50.         fmt.Println("开始创建连接")
51.         //4、建立连接
52.         conn, err3 := listen.Accept()
53.         if err3 != nil {
54.             fmt.Println(err3)
55.         }
56.         //5、绑定服务
57.         //rpc.ServeConn(conn)
59.         // 5. 绑定服务
60.         /*
61.            jsonrpc和默认rpc的区别：
62.                    以前rpc.ServeConn(conn)绑定服务
63.                    jsonrpc中通过rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
64.         */
65.         rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
66.     }
67. }

复制代码

<blockquote class="kdocs-blockquote" style="">  代码中最大的厘革是用  rpc.ServeCodec函数更换了  rpc.ServeConn函数，传入的参数是针对服务端的json编解码器  

• 创建RPC客户端
  

1. package main
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7.     "net/rpc/jsonrpc"
8. )
10. //rpc服务端
12. /*
13. 把默认的rpc 改为jsonrpc
14.     1、rpc.Dial需要调换成net.Dial
15.     2、增加建立基于json编解码的rpc服务  client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
16.     3、conn.Call 需要改为client.Call
17. */
19. func main()  {
20.     //1、用 net.Dial和rpc微服务端建立连接
21.     conn, err1 := net.Dial("tcp", "127.0.0.1:8080")
22.     if err1 != nil {
23.         fmt.Println(err1)
24.     }
25.     //2、当客户端退出的时候关闭连接
26.     defer conn.Close()
28.     //建立基于json编解码的rpc服务
29.     client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
32.     //3、调用远程函数
33.     //微服务端返回的数据
34.     var reply string
35.     /*
36.         1、第一个参数: hello.SayHello,hello 表示服务名称  SayHello 方法名称
37.         2、第二个参数: 给服务端的req传递数据
38.         3、第三个参数: 需要传入地址,获取微服务端返回的数据
39.     */
40.     err2 := client.Call("hello.SayHello", "张三", &reply)
41.     if err2 != nil {
42.         fmt.Println(err2)
43.     }
44.     //4、获取微服务返回的数据
45.     fmt.Println(reply)
46. }

复制代码

<blockquote class="kdocs-blockquote" style="">  先手工调用  net.Dial函数创建TCP链接，然后基于该链接创建针对客户端的json编解码器  

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

启动微服务端

         

       启动客户端

         

      

• RPC跨语言
  

<blockquote class="kdocs-blockquote" style="">  以PHP跨语言调用RPC微服务为案例  PHP代码

1. <?php
2. class JsonRPC {
3.     private $conn;
5.     function __construct($host, $port) {
6.         $this->conn = fsockopen($host, $port, $errno, $errstr, 3);
7.         if (!$this->conn) {
8.             return false;
9.         }
10.     }
12.     public function Call($method, $params) {
13.         if (!$this->conn) {
14.             return false;
15.         }
16.         $err = fwrite($this->conn, json_encode(array(
17.                 'method' => $method,
18.                 'params' => array($params),
19.                 'id' => 0,
20.             ))."\n");
21.         if ($err === false) {
22.             return false;
23.         }
24.         stream_set_timeout($this->conn, 0, 3000);
25.         $line = fgets($this->conn);
26.         if ($line === false) {
27.             return NULL;
28.         }
29.         return json_decode($line,true);
30.         }
31.     }
32.     $client = new JsonRPC("127.0.0.1", 8080);
33.     $args = "this is php aaa";
34.     $r = $client->Call("Hello.SayHello", $args);
35.     print_r($r);
36. ?>

复制代码

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

      

• RPC协议封装
  

<blockquote class="kdocs-blockquote" style="">  后期使用微服务框架  GRPC 和   Go-Micro的时间，都是使用  框架封装好的服务和客户端，接下来通过一个简单的示例演示一下  怎样封装，以此来明确  封装的原理,上面的代码服务名都是写死的，不敷机动（轻易写错），这里对RPC的服务端和客户端再次举行一次封装，来  屏蔽掉服务名，详细代码如下:  服务端封装

<blockquote class="kdocs-blockquote" style="">  新建server/models/tools

1. package models
3. import "net/rpc"
5. var serverName = "HelloService"
7. type RPCInterface interface {
8.     HelloWorld(string, *string) error
9. }
11. // 调用该方法时, 需要给 i 传参, 参数应该是 实现了 HelloWorld 方法的类对象!
12. func RegisterService(i RPCInterface) {
13.     rpc.RegisterName(serverName, i)
14. }

复制代码

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

1. package main
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7.     "net/rpc/jsonrpc"
8.     "server/models"
9. )
10. // 定义类对象
11. type World struct {}
13. // 绑定类方法
14. func (this *World) HelloWorld(req string, res *string) error {
15.     fmt.Println(req)
16.     *res = req + " 你好!"
17.     return nil
18.     //return errors.New("未知的错误!")
19. }
21. func main() {
22.     //注册rpc服务 维护一个hash表，key值是服务名称，value值是服务的地址
23.     // rpc.RegisterName("HelloService", new(World))
24.     models.RegisterService(new(World))
25.     //设置监听
26.     listener, err := net.Listen("tcp", ":8080")
27.     if err != nil {
28.         panic(err)
29.     }
30.     for {
31.         //接收连接
32.         conn, err := listener.Accept()
33.         if err != nil {
34.             panic(err)
35.         }
36.         //给当前连接提供针对json格式的rpc服务
37.         go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
38.     }
39. }

复制代码

客户端封装

<blockquote class="kdocs-blockquote" style="">  新建client/models/tools

1. package models
3. import (
4.     "fmt"
5.     "net"
6.     "net/rpc"
7.     "net/rpc/jsonrpc"
8. )
10. var serverName = "HelloService"
12. type RPCClient struct {
13.     Client *rpc.Client
14.     Conn net.Conn
15. }
17. func NewRpcClient(addr string) RPCClient {
18.     conn, err := net.Dial("tcp", addr)
19.     if err != nil {
20.         fmt.Println("链接服务器失败")
21.         return RPCClient{}
22.     }
23.     //套接字和rpc服务绑定
24.     client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
25.     return RPCClient{Client: client, Conn: conn}
26. }
28. func (this *RPCClient) CallFunc(req string, resp *string) error {
29.     return this.Client.Call(serverName+".HelloWorld", req, resp)
30. }

复制代码

封装之后客户端实现

1. package main
3. import (
4.     "client/models"
5.     "fmt"
6. )
8. func main() {
9.     //建立tcp连接
10.     client := models.NewRpcClient("127.0.0.1:8080")
11.     //关闭连接
12.     defer client.Conn.Close()
14.     var reply string // 接受返回值 --- 传出参数
15.     err := client.CallFunc("this is client", &reply)
17.     if err != nil {
18.         fmt.Println("Call:", err)
19.         return
20.     }
21.     fmt.Println(reply)
22. }

复制代码

[上一节][golang 微服务] 1.单体式架构以及微服务架构先容
[下一节][golang 微服务] 3. ProtoBuf熟悉与使用

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金