单体式和微服务

单体式架构服务

—— 过往大家熟悉的服务器。

特性：

  1. 复杂性随着开发越来越高， 遇到问题解决困难。
  2. 技术债务逐渐上升。
  3. 耦合度高，维护成本大！
    1. 出现bug， 不容易排查
    2. 解决旧bug， 会出新bug
  1. 持续交付时间较长。
  2. 技术选型成本高，风险大。
  3. 扩展性较差
    1. 垂直扩展：通过增加单个系统程的负荷来实现扩展。
    2. 水平扩展：通过增加更多的系统成员来实现扩展。

微服务

  • 优点：
    1. 职责单一
    2. 轻量级通信
    3. 独立性
    4. 迭代开发。
  • 缺点：
    1. 运维成本高
    2. 分部式复杂度
    3. 接口成本高
    4. 重复性劳动
    5. 业务分离困难。

单体式服务和微服务对比

新功能开发 需要时间 容易开发和实现
传统单体架构 分布式微服务化架构
部署 不经常而且容易部署 经常发布，部署复杂
隔离性 故障影响范围大 故障影响范围小
架构设计 初期技术选型难度大 设计逻辑难度大
系统性能 相对时间快，吞吐量小 相对时间慢，吞吐量大
系统运维 运维难度简单 运维难度复杂
新人上手 学习曲线大（应用逻辑） 学习曲线大（架构逻辑）
技术 技术单一而且封闭 技术多样而且容易开发
测试和差错 简单 复杂（每个服务都要进行单独测试，还需要集群测试）
系统扩展性 扩展性差 扩展性好
系统管理 重点在于开发成本 重点在于服务治理和调度

RPC 协议

什么是RPC

Remote Procedure Call Protocol —— 远程过程调用协议！

IPC： 进程间通信

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

回顾：

OSI 7 层模型架构：物、数、网、传、会、表、应

TCP/IP 4 层架构：链路层、网络层、传输层、应用层

  • 理解RPC：
    • 像调用本地函数一样，去调用远程函数。
      • 通过rpc协议，传递：函数名、函数参数。达到在本地，调用远端函数，得返回值到本地的目标。
  • 为什么微服务使用 RPC：
    1. 每个服务都被封装成 进程。彼此”独立“。
    2. 进程和进程之间，可以使用不同的语言实现。

RPC 入门使用

远程 —— 网络！！

回顾：Go语言 一般性 网络socket通信

server端：

  1.     net.Listen()  —— listener      创建监听器
  3.     listener.Accept()  —— conn   启动监听，建立连接
  5.     conn.read()
  7.     conn.write()
  9.     defer conn.Close() / listener.Close()

client端：

  1.     net.Dial()  —— conn
  3.     conn.Write()
  5.     conn.Read()
  7.     defer conn.Close()

RPC 使用的步骤

—— 服务端：

  1. 注册 rpc 服务对象。给对象绑定方法（ 1. 定义类， 2. 绑定类方法 ） 

    1. rpc.RegisterName("服务名"，回调对象)

  2. 创建监听器 

    1. listener, err := net.Listen()

  3. 建立连接 

    1. conn, err := listener.Accept()

  4. 将连接 绑定 rpc 服务。 

    1. rpc.ServeConn(conn)

—— 客户端：

  1. 用 rpc 连接服务器。 

    1. conn, err := rpc.Dial()

  2. 调用远程函数。 

    1. conn.Call("服务名.方法名", 传入参数, 传出参数)

RPC 相关函数

  1. 注册 rpc 服务
    ```go func (server *Server) RegisterName(name string, rcvr interface{}) error 参1：服务名。字符串类型。 参2：对应 rpc 对象。 该对象绑定方法要满足如下条件：
    1. 1）方法必须是导出的 —— 包外可见。 首字母大写。
    2. 2）方法必须有两个参数， 都是导出类型、內建类型。
    3. 3）方法的第二个参数必须是 “指针” （传出参数）
    4. 4）方法只有一个 error 接口类型的 返回值。
    举例：

type World stuct { }
func (this World) HelloWorld (name string, resp string) error { } rpc.RegisterName(“服务名”， new(World))

  2. 2.  绑定 rpc 服务  
  3. ```go
  4. func (server *Server) ServeConn(conn io.ReadWriteCloser)
  5.     conn: 成功建立好连接的 socket —— conn
  1. 调用远程函数： 
    1. func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error
    2. serviceMethod: “服务名.方法名”
    3. args：传入参数。 方法需要的数据。
    4. reply：传出参数。定义 var 变量，&变量名  完成传参。

编码实现

server端

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

client端

  1. package main
  3. import (
  4.     "net/rpc"
  5.     "fmt"
  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.     }
  15.     defer conn.Close()
  17.     // 2. 调用远程函数
  18.     var reply string         // 接受返回值 --- 传出参数
  20.     err = conn.Call("hello.HelloWorld", "李白", &reply)
  21.     if err != nil {
  22.         fmt.Println("Call:", err)
  23.         return
  24.     }
  26.     fmt.Println(reply)
  27. }

json 版 rpc

  • 使用 nc -l 127.0.0.1 880 充当服务器。
  • 02-client.go 充当 客户端。 发起通信。 —— 乱码。
    • 因为：RPC 使用了go语言特有的数据序列化 gob。 其他编程语言不能解析。
  • 使用 通用的 序列化、反序列化。 —— json、protobuf

修改客户端

修改客户端，使用jsonrpc：

  1. conn, err := jsonrpc.Dial("tcp", "127.0.0.1:8800")

使用 nc -l 127.0.0.1 8800 充当服务器。

执行go run 02-client.go, 看到结果：

  1.     {"method":"hello.HelloWorld","params":["李白"],"id":0}

修改服务器端

修改服务器端，使用 jsonrpc：

  1. jsonrpc.ServeConn(conn)

使用 nc 127.0.0.1 8800 充当客户端。

看到结果：

  1.         echo -e '{"method":"hello.HelloWorld","params":["李白"],"id":0}' | nc 127.0.0.1 8800

如果，绑定方法返回值的 error 不为空？ 无论传出参数是否有值，服务端都不会返回数据。

rpc 封装

服务端封装

    1. // 定义接口
    2. type xxx interface {
    3. 方法名(传入参数，传出参数) error
    4. }
    5. 例：
    6. type MyInterface interface {
    7. HelloWorld(string, *string) error
    8. }
    1. // 封装注册服务方法
    2. func RegisterService (i MyInterface) {
    3. rpc.RegisterName("hello", i)
    4. }

客户端封装

    1. // 定义类
    2. type MyClient struct {
    3. c *rpc.Client
    4. }
    1. // 绑定类方法
    2. func （this *MyClient）HelloWorld(a string, b *string) error {
    3. return  this.c.Call("hello.HelloWorld", a, b)
    4. }
    1. // 初始客户端
    2. func InitClient(addr string) MyClient {
    3. conn, _ := jsonrpc.Dial("tcp", adddr)
    4. return MyClient{c:conn}
    5. }

protobuf

—- Google

编写的注意事项

  1. message 成员编号， 可以不从1开始, 但是不能重复. — 不能使用 19000 - 19999
  2. 可以使用 message 嵌套。
  3. 定义数组、切片 使用 repeated 关键字
  4. 可以使用枚举 enum
  5. 可以使用联合体。 oneof 关键字。成员编号，不能重复。
  1. // 默认是 proto2
  2. syntax = "proto3";
  4. // 指定所在包包名
  5. package pb;
  7. // 加上这一句才能够成功编译
  8. option go_package = "./";
  10. // 定义枚举类型
  11. enum Week {
  12.     Monday = 0;   // 枚举值,必须从 0 开始.
  13.     Turesday = 1;
  14. }
  16. // 定义消息体
  17. message Student {
  18.     int32 age = 1;  // 可以不从1开始, 但是不能重复. -- 不能使用 19000 - 19999
  19.     string name = 2;
  20.     People p = 3;
  21.     repeated int32 score = 4;  // 数组
  22.     // 枚举
  23.     Week w = 5;
  24.     // 联合体
  25.     oneof data {
  26.         string teacher = 6;
  27.         string class = 7;
  28.     }
  29. }
  31. // 消息体可以嵌套
  32. message People {
  33.     int32 weight = 1;
  34. }

编译 protobuf

回顾：C++ 编译 命令：

protoc —cpp_out=./ *.proto —-> xxx.pb.cc 和 xxx.pb.h 文件

  • go 语言中 编译命令：

protoc --go_out=./ *proto —-> xxx.pb.go 文件。

添加 rpc 服务

  • 语法： 

    1. service 服务名 {
    2.  rpc 函数名(参数：message) returns (返回值：message)
    3. }
    4. message People {
    5.  string name = 1;
    6. }
    7. message Student {
    8.  int32 age = 2;
    9. }
    10. 例：
    11. service hello {
    12.  rpc HelloWorld(People) returns (Student);
    13. }

  • 知识点：

    • 默认，protobuf，编译期间，不编译服务。 要想使之编译。 需要使用 gRPC。
    • 使用的编译指令为：
      • protoc --go_out=plugins=grpc:./ *.proto
  • 生成的 xxx.pb.go 文件 与 我们自己封装的 rpc 对比： 
  1. 客户端：
  3. type bj38Client struct {} ----- type MyClient struct {} 类
  5. func NewBj38Client()  ----- InitCient() 函数
  7. func (c *bj38Client) Say() ---- HelloWorld() 方法
  9. 服务端：
  11. type Bj38Server interface {}  ---- type MyInterface interface{} 接口。
  13. func RegisterBj38Server() ---- func RegisterService() 函数。

作业：grpc 远程调用。

  • 服务端 grpc
    1. 初始一个 grpc 对象
    2. 注册服务
    3. 设置监听， 指定 IP、port
    4. 启动服务。—— serve()
  • 客户端 grpc
    1. 连接 grpc 服务，
      1. 需要给函数传参grpc.WithInsecure()，否则编译容易出问题
    2. 初始化 grpc 客户端
    3. 调用远程服务。
      1. grpcClient.SayHello()传参context.TODO()，表示空对象，占位�