单体式和微服务
单体式架构服务
------过往大家熟悉的服务器
特性：
1.复杂性随着开发越来越高，遇到问题解决困难。
2. 技术债务逐渐上升
3. 耦合度高，维护成本大
出现bug，不容易排查
解决旧bug，会出新bug
4. 持续交付时间较长
5. 技术选型成本高，风险大。
6. 扩展性较差
1.垂直扩展：通过增加单个系统程序的负荷来实现扩展。
2.水平扩展：通过增加更多的系统成员来实现扩展。
微服务
· 优点
1.职责单一
2.轻量级通信
3.独立性
4.迭代开发
· 缺点
- 运维成本高
- 分布式复杂度
- 接口成本高
- 重复性劳动
- 业务分离困难
单体式和微服务对比
RPC协议
什么是RPC
Remote Procedure Call Protocol – 远程过程调用协议！
IPC：进程间通信
RPC：远程进程通信 — 应用层协议（http协议同层），底层使用TCP实现。
回顾：
OSI7层模型架构：物理层，数据链路层，网络层，传输层，会话层，表示层，应用层
TCP/IP4层架构：链路层，网络层，传输层，应用层
理解RPC：
像调用本地函数一样，去调用远程函数。
通过rpc协议，传递：函数名，函数参数，达到在本地，调用远端函数，得返回值到本地的目标
为什么微服务使用RPC：
1.每个服务都被封装成进程，彼此“独立”。
2.进程和进程之间，可以使用不同的语言实现。
RPC入门使用
远程 — 网络！！
回顾：Go语言 一般性 网络socket通信
server端：
net.Listen() – listener 创建监听器
listener.Accpet() – conn 启动监听，建立连接
conn.read()
conn.write()
defer conn.Close() / listener.Close()
client端：
net.Dial() – conn
conn.Write()
conn.Read()
defer conn.Close()
RPC使用的步骤
-------服务端
1.注册RPC服务对象。给对象绑定方法（1.定义类，2.绑定类方法）
rpc.RegisterName("服务名",回调对象)
- 创建监听器
listener,err := net.Listen()
- 建立连接
conn,err := listener.Accept()
- 将连接 绑定rpc服务
rpc.ServeConn(conn)
------ 客户端：
1.用rpc连接服务器。
conn,err := rpc.Dial()
2.调用远程函数。
conn.Call("服务名.方法名",传入参数，传出参数)
RPC相关函数
1.注册rpc服务
func (server *Server) RegisterName(name string,rcvr interface{}) error 参1：服务名。字符串类型。 参2：对应rpc对象。该对象绑定方法要满足如下条件： 1.方法必须是导出的----包外可见，首字母大写。 2.方法必须有两个参数，都是导出类型，内建类型。 3.方法的第二个参数必须是“指针” （传出参数） 4.方法只有一个 error接口类型的返回值。 举例： type World stuct{ } func（this *World） HelloWorld(name string,resp *string) error{ } rpc.RegisterName("服务名",new(World))
2.绑定rpc服务
func (server *Server) ServerConn(conn io.ReadWriteCloser) conn:成功建立好连接的 socket -- conn
3.调用远程函数：
func （client *Client） Call（serviceMethod string，args interface{}，reply interface{}） error serviceMethod：“服务器.方法名” args：传入参数，方法需要的数据。 reply：传出参数。定义var变量，&变量名 完成传参。
编码实现
server端
package main import ( "net/rpc" "fmt" "net" ) // 定义类对象 type World struct { } // 绑定类方法 func (this *World) HelloWorld (name string,resp *string) error { *resp = name + "你好！" 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:8802") if err != nil{ fmt.Println("net.Listen err:",err) return } defer listener.Close() fmt.Println("开始监听...") // 3.建立连接 conn,err := listener.Accept() if err != nil{ fmt.Println("Accpet() err:",err) return } defer conn.Close() fmt.Println("连接成功....") // 4. 绑定服务 rpc.ServeConn(conn) }
client端
package main import ( "net/rpc" "fmt" ) func main(){ // 1.用rpc连接服务器 --Dial（） conn,err := rpc.Dial("tcp","127.0.0.1:8802") 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:",err) return } fmt.Println(reply) }
json版rpc
使用 nc -l 127.0.0.1 8800 充当服务器
2_client.go充当客户端，发起通信。 --乱码
因为，rpc使用了go语言特有的序列化gob，其他编程语言不能解析
使用通用的序列化反序列化。 --json，protobuf
修改客户端
修改客户端，使用jsonrpc：
conn,err := jsonrpc.Dial("tcp","127.0.0.1:8800")
修改服务器端
修改服务器端，使用jsonrpc：
jsonrpc.ServerConn(conn)
如果，绑定方法返回值的error不为空？无论传出参数是否有值，服务端都不会返回数据。
rpc封装
3_design.go
package main import ( "net/rpc/jsonrpc" "net/rpc" ) // 要求，服务端在注册rpc对象时，能让编译期检查出 注册对象是否合法 // 创建接口，在接口中定义方法原型 type MyInterface interface{ HelloWorld(string,*string) error } // 调用该方法，需要给 i 传参，参数应该是实现了 HelloWorld 方法的类对象 func RegisterService(i MyInterface) { rpc.RegisterName("hello",i) } //-------------------客户端调用 // 定义类 type Myclient struct { c *rpc.Client } // 由于使用了c调用Call，因此需要初始化c func InitClient(addr string) Myclient { conn,_ := jsonrpc.Dial("tcp",addr) return Myclient{c:conn} } // 实现函数，原型参照上面的Interface来实现 func (this *Myclient) HelloWorld (a string,b *string) error { // 参数1，参照上面的 Interface，RegisterName 而来，a：传入参数 b:传出参数 return this.c.Call("hello.HelloWorld",a,b) }
1_server.go
package main import ( // "net/rpc" "net/rpc/jsonrpc" "fmt" "net" ) // 定义类对象 type World struct { } // 绑定类方法 func (this *World) HelloWorld (name string,resp *string) error { *resp = name + "你好！" return nil } func main(){ // 1.注册RPC服务，绑定对象方法 RegisterService(new(World)) // err := rpc.RegisterName("hello",new(World)) // if err != nil{ // fmt.Println("注册 rpc 服务失败！",err) // return // } // 2.设置监听 listener,err := net.Listen("tcp","127.0.0.1:8803") // listener,err := InitClient("127.0.0.1:8803") if err != nil{ fmt.Println("net.Listen err:",err) return } defer listener.Close() fmt.Println("开始监听...") // 3.建立连接 conn,err := listener.Accept() if err != nil{ fmt.Println("Accpet() err:",err) return } defer conn.Close() fmt.Println("连接成功....") // 4. 绑定服务 // rpc.ServeConn(conn) jsonrpc.ServeConn(conn) }
2_client.go
package main import ( "net/rpc" "fmt" ) func main01(){ // 1.用rpc连接服务器 --Dial（） conn,err := rpc.Dial("tcp","127.0.0.1:8802") 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:",err) return } fmt.Println(reply) } // 结合 3_design.go 测试 func main(){ myClient := InitClient("127.0.0.1:8803") var resp string err := myClient.HelloWorld("杜甫",&resp) if err != nil{ fmt.Println("HelloWorld err:",err) return } fmt.Println(resp,err) }
ProtoBuf认识与使用
protobuf简介
Protobuf是Protocol Buffers的简称，它是Google公司开发的一种描述语言，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。他很适合做数据存储或者RPC数据交换格式。
可以用于通信协议，数据存储等领域的语言无关，平台无关，可扩展的序列化结构数据格式。目前提供了C++，Java，Python三种语言的API。
Protobuf刚开源是的定位类似于xml，json等数据描述语言，通过附带工具生成代码并实现将结构化数据序列化的功能，这里我们更关注的是Protobuf作为接口规范的描述语言，可以作为设计安全的跨语言RPC接口的基础工具。
需要了解两点
- protobuf是类似于json一样的数据描述语言（数据格式）
- protobuf非常适合于RPC数据交换格式
接着我们来看一下protobuf的优势和劣势：
优势：
1.序列化后面积比Json和Xml很小，适合网络传输
2.支持跨平台多语言
3.消息格式升级和兼容性还不错
4.序列化反序列化速度很快，快于json的处理速度
劣势：
- 应用不够广（相比xml和json）
- 二进制格式导致可读性差
- 缺乏自描述
protobuf的安装
1.下载protobuf
方法一：===》git clone https://github.com/protocolbuffers/protobuf.git 方法二：===》 或者将准备好的压缩包进行拖入 解压到 $GOPATH/src/github.com/protocolbuffers/下面 Unizip protobuf.zip
- 安装（Ubuntu）
3.测试protobuf编译工具
protoc -h
如果正常输出 相关指令 没有报任何error，为安装成功
4.安装protobuf的go语言插件
感谢大家观看，我们下次见
