Golang微服务基础技术
单体式和微服务
单体式架构服务
------过往大家熟悉的服务器
特性：
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语言插件
感谢大家观看，我们下次见