go-micro

一，课程介绍

1，主讲老师: 大地

2，合作网站: www.itying.com

3，我的专栏: https://www.itying.com/category_Z9-b0.html

4,必备基础：学习本教程要有golang和go web基础

5，大地老师Golang入门实战系列教程地址:

Golang教程_IT营

二，微服务架构(micro services)

2.1 微服务架构和微服务

微服务架构：微服务架构是一种具体的设计实现或者设计方案，是将复杂的系统使用组件化的方式进行撤分，并使用轻量级通讯方式进行整合的一种设计方法。

微服务：微服务是微服务架构具体的实现方案，是通过微服务架构设计方法撤分出来的一个独立的组件化的小应用。

微服务架构定义的精髓，可以用一句话来描述，那就是"分而治之，合而用之"。将复杂的系统进行撤分的方法，就是"分而治之"。分而治之，可以让复杂的事情变的简单，这很符合我们平时处理问题的方法，使用轻量级通讯等方式进行整合的设计，就是"合而用之"的方法，合而用之可以让微小的力量变动强大。

2.2 什么是微服务架构

微服务架构是将一个单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，服务间通信采用的轻量级通信机制(通常用HTTP资源API),这些服务围绕业务能力构建并且可通过全自动部署机制独立部署。这些服务公用一个最小型的集中式的管理，服务可用不同的语言进行开发，使用不同的数据存储技术。

在了解微服务之前首先看看单体架构。

单体架构在中小企业内部用的是非常多的，当业务部复杂，团对规模不大的时候，单体架构比微服务架构具有更高的生产率。我们给大家讲的《golang仿小米商城项目》以及2017年前的淘宝都是单体架构。

注意 ：下面示例中的服务器和数据库也可以使用docker容器实现

2.2.1 单体架构的程序部署在单台服务器 每天五万下访问量

这样的架构能轻松的应对每天五万以下的访问量

这种架构是目前中小企业用的最多的架构。其中web服务(nginx),网站程序，静态资源(图片)，数据库(Mysql,Redis)都在一台服务器上面。如果每天网站的访问ip在5w以下这种架构完全可以应付(服务器配置也有关系)

2.2.2 单体架构的程序部署在多台服务器(负载均衡) 每天几十万的访问量

这样的架构能轻松的应对每天几十万的访问量

把我们的程序部署到多台服务器上面，然后通过nginx配置负载均衡，当客户访问我们的项目的时候随机的分配给不同的服务器处理响应，这样可以防止宕机，提升系统运行稳定性。

2.2.3 单体架构的程序部署在多台服务器(负载均衡+主从数据库)

这样的架构能轻松的应对每天几百万，上千万的访问量

当每天有上亿访问量，或者更高并发量的时候，什么的方法就有点力不从心了，这个时候我们就可以使用微服务架构。

2.2.4 , 微服务架构

微服务架构：通俗的讲就是把单体架构项目抽离成多个项目(服务)，部署到多台服务器。

如果用"茶壶煮饺子"来打比方发话，原来我们是在一个茶壶煮很多个饺子，现在(微服务化之后)则基本上是在一个茶壶煮一个饺子，而这些饺子就是服务的功能，茶壶则是将这些服务功能打包交付的服务单元。

2.3 微服务这个概念的由来

据说，早在2011年5月，在威尼斯附近的软件架构师讨论会上，就有人提出了微服务架构设计的概念，用它来描述与会者所见的一种通用的架构设计风格。时隔一年之后，在同一个讨论会上，大家决定将这种架构设计风格用微服务架构来表示。

起初，对微服务的概念，没有一个明确的定义，大家只能从各自的角度说出了微服务的理解和看法。

在2014年3月，詹姆斯.刘易斯(James Lewis)与马丁福勒(Martin Fowler)所发表的一篇博客中，总结了微服务架构设计的一些共同特点，这应该是一个对微服务比较全面的描述。

原文链接：https://martinfowler.com/articlers/microservices.html

2.4 微服务架构和单体式架构区别

2.4.1 单体架构服务

单体架构的优点：

1，部署简单： 由于是完整的结构体，可以直接部署在一个服务器上即可

2，技术单一：项目不需要复杂的技术栈，往往一套熟悉的技术栈就可以完成开发

3，用人成本低：单个程序员可以完成接口到数据库的整个流程

4，项目管理相对较易

5，测试相对简单直观

6，应用开发相对简单

7，横向扩展容易

单体架构的缺点：

1，系统启动慢，一个进程包含了所有的业务逻辑，涉及到启动模块过多，导致系统的启动，重启周期变长

2，系统错误隔离性差，可用性差，任何一个模块的错误可能导致整个系统的宕机

3，可伸缩性差，系统的扩容只能对整个应用扩容，不能做到对整个功能点进行扩容

4，线上问题修复时间长，任何一个线上问题修复需要对整个应用系统进行全面升级

5，交付周期长(需求-->设计-->开发-->测试-->现场实施部署，就传统性质的企业而言)

2.4.2 微服务

微服务的优点：

1，易于开发和维护：一个服务只关注一个特定的业务功能，所以他业务清晰，代码量少，开发和维护单个微服务相当简单。而整个应用是若干个微服务构建而成的，所以整个应用在被维持在一个可控的状态；

2，单个服务启动快：单个服务代码量少，所以启动快；

3，局部修改易部署：单个应用只要有修改，就得重新部署整个应用，微服务解决了这个问题，一般来说，对某个微服务进行修改，只需要重新部署这个服务即可；

4，技术栈不受限：在微服务架构中，可以结合业务和团队的特点，合理选用技术栈。例如有些服务可以使用关系型数据库Mysql,有的服务可以使用非关系型数据库redis,甚至可根据需求，部分服务使用JAVA开发，部分微服务使用Node.js开发。

5，按需收缩：可根据需求，实现细粒度的扩展。例如，系统中某个微服务遇到了瓶颈，可以结合微服务的特点，增加内存，升级CPU或增加节点。

微服务的缺点：

1，运维成本高

2，分布式复杂度高

3，

2.5 为什么要学微服务

1，会单体架构学习微服务非常简单

2，微服务是非常热门的话题，企业招聘中越来越多的要求有委屈开发，架构能力的人才

3，提升技术实力，增加职业转型的可能性

4，微服务解决工作中软件研发难题，比如高并发

5，微服务技术栈不受限，可以发布的和其他语言实现通信

6，如果你是架构师或者项目管理人员微服务是必备技能

三，RPC架构

简单了解微服务定义和优缺点之后，在我们正式学习微服务框架之前，需要首先了解一下RPC架构，通过RPC我们可以形象了解微服务的工作流程。

3.1 RPC的概念

RPC(Remote Procedure Call Protocoll),是远程过程调用的缩写，通俗的说就是调用远处的一个函数。与之相对应的是本地函数调用，我们先来看一下本地函数调用。当我们写下如下代码的时候：

规则

result := Add(1,2)

我们知道，我们传入了1,2两个参数，调用了本地代码中的一个Add函数，得到result这个返回值。这个时参数，返回值，代码段都在一个进程空间内，这是本地函数调用。

那有没有办法，我们能够调用一个跨进程(所以叫"远程"，典型的实例，这个进程部署在另一台服务器上)的函数呢？

微服务的目的：就是让我们在本地可以调用远程服务端里面的函数或者方法，所以首先要定义一个远程调用的方法。 比如Add()这个方法。

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

3.2 RPC入门

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

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

2，每个服务都被封装成进程。彼此"独立"。

3，使用微服务可以跨进程通信

下图表示：

go语言内置了RPC，通过RPC我们可以实现跨语言的调用，比如说我们在go语言里面写的微服务，接下来，我们可以在java或者C++调用我们go语言写的微服务，同理，java写的微服务，我们也可以在go语言里面或者C++语言里面来调用java写的微服务。

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服务调用。

3.3 net/rpc库 使用 http 作为 RPC 的载体实现远程调用(了解)

下面的例子演示一下如何使用 golang 官方的 net/rpc 库实现 RPC 方法，使用 http 作为 RPC 的载体，通过 net/http 包监听客户端连接请求。

http基于tcp,多一层封包和几次握手校验，性能自然比直接用tcp实现网络传输要差一些，所以 RPC 微服务中一般使用的都是tcp

3.3.1 创建RPC微服务端

新建 rpc_demo_http/server/main.go

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

3.4.1 创建RPC微服务端

新建 rpc_demo_tcp/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:8080")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)}
}

HelloWorld 方法必须满足Go语言的RPC规则：

1，方法只能有两个可序列化的参数，其中第二个参数是指针类型

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

golang 中的类型比如：channel(通道)，complex(复数类型)，func(函数)均不能进行 序列化

3.4.2 创建RPC客户端

新建 rpc_demo_tcp/client/main.go

package mainimport ("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 // 接受返回值---传出参数/*1,第一个参数 hello.SayHello hello表示服务名称 SayHello方法名称2,第二个参数 给服务端的req传递数据3,第三个参数 需要传入地址 获取微服务端返回的数据*/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方法的两个参数。

 以下是一个实现简单RPC服务实践

​
​
1,服务端 server/hello/main.go
package mainimport ("fmt""net""net/rpc"
)// 定义一个远程调用的方法 服务器端程序
// 1,定义一个结构体
type Hello struct {
}/*定义一个方法 方法只能有两个序列化的参数 其中第二个参数必须是指针类型第一个参数是客户端传过来的数据，第二个参数是服务器端返回给客户端的数据该方法必须有一个error类型的返回值，用来表示是否调用成功request:表示获取客户端传过来的数据response:表示服务器端返回给客户端的数据req 和 res 中的类型比如：channel(通道)，complex(复数类型)，func(函数)均不能进行 序列化操作，所以不能作为rpc方法的参数类型*/func (Hello) SayHello(request string, response *string) error {fmt.Println("服务端收到客户端的数据：", request)*response = "Hello,我是服务端," + requestreturn nil
}func main() {// 1, 注册RPC服务err1 := rpc.RegisterName("Hello", new(Hello))if err1 != nil {fmt.Println("注册服务失败")}// 2,监听端口，等待客户端的连接Listener, err2 := net.Listen("tcp", "127.0.0.1:8080")if err2 != nil {fmt.Println("监听端口失败")}// 3,应用退出前关闭监听端口defer Listener.Close()// 4,建立链接 循环等待客户端的连接请求for { // 死循环等待客户端的连接请求 for循环等待客户端的连接请求fmt.Println("开始建立连接")// 4,建立一次链接conn, err3 := Listener.Accept()if err3 != nil {fmt.Println("接受客户端失败")}// 5,绑定服务 为当前链接提供服务rpc.ServeConn(conn)fmt.Println("服务端退出")}
}2,客户端 client/hello/main.go
package mainimport ("fmt""net/rpc"
)func main() {// 1,用 rpc.Dial和rpc 微服务端建立连接，然后调用 rpc 微服务端的方法。conn, err1 := rpc.Dial("tcp", "127.0.0.1:8080") // 这里的参数要和服务器端的一致if err1 != nil {fmt.Println(err1)}// 2, 当连接建立后，需要关闭它。否则会造成资源泄露。所以这里使用了 defer 关键字来延迟执行 Close 方法。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)
}​​

以下是一个goods实现简单RPC服务实践

​
​
1, 服务端 server\goods\main.go
package mainimport ("fmt""net""net/rpc"
)// 创建远程调用的函数，函数一般是放在结构体里面的
type Goods struct{}// AddGoods 参数对应的结构体
// 定义一个结构体，用于接收客户端传递过来的参数
type AddGoodsReq struct {Id      intTitle   stringPrice   float64Content string
}// 定义一个结构体，用于返回客户端的结果
type AddGoodsRes struct {Success boolMessage string
}// GetGoods 参数对应的结构体
// 定义一个结构体，用于接收客户端传递过来的参数
type GetGoodsReq struct {Id int
}// 定义一个结构体，用于返回客户端的结果
type GetGoodsRes struct {Id      intTitle   stringPrice   float64Content string
}// 定义一个方法，该方法可以被远程调用
func (Goods) AddGoods(req AddGoodsReq, res *AddGoodsRes) error {// 1, 执行增加 模拟 商品的操作，这里就直接打印出来看看参数是什么样子的fmt.Printf("%#v\n", req)// 2, 返回增加的结果，这里直接返回nil表示成功*res = AddGoodsRes{Success: true,Message: "增加商品成功",}return nil
}// 定义一个获取数据的方法，该方法可以被远程调用
func (Goods) GetGoods(req GetGoodsReq, res *GetGoodsRes) error {// 1, 执行增加 模拟 商品的操作，这里就直接打印出来看看参数是什么样子的fmt.Printf("%#v\n", req)// 2, 返回增加的结果，这里直接返回nil表示成功*res = GetGoodsRes{Id:      11,Title:   "小米手机",Price:   2888.0,Content: "小米手机真好用号漂亮的",}return nil
}
func main() {// 1, 注册 RPC 服务err1 := rpc.RegisterName("goods", new(Goods))if err1 != nil {fmt.Println("注册服务失败")}// 2, 监听端口Listener, err2 := net.Listen("tcp", "127.0.0.1:8020")if err2 != nil {fmt.Println("监听端口失败")}// 3, 关闭监听端口defer Listener.Close()for {// 4, 监听客户端连接，等待客户端的连接请求fmt.Println("准备接受客户端的连接请求...")conn, err3 := Listener.Accept()if err3 != nil {fmt.Println("接受客户端连接失败")}// 5, 处理客户端的连接请求rpc.ServeConn(conn) // 处理客户端的连接请求，阻塞等待下一个连接请求}
}2，客户端 client\goods\main.go
package mainimport ("fmt""net/rpc"
)// AddGoods 参数对应的结构体
// 定义一个结构体，用于接收客户端传递过来的参数
type AddGoodsReq struct {Id      intTitle   stringPrice   float64Content string
}// 定义一个结构体，用于返回客户端的结果
type AddGoodsRes struct {Success boolMessage string
}// GetGoods 参数对应的结构体
// 定义一个结构体，用于接收客户端传递过来的参数
type GetGoodsReq struct {Id int
}// 定义一个结构体，用于返回客户端的结果
type GetGoodsRes struct {Id      intTitle   stringPrice   float64Content string
}func main() {// 1,用 rpc.Dial和rpc 微服务端建立连接，然后调用 rpc 微服务端的方法。conn, err1 := rpc.Dial("tcp", "127.0.0.1:8020") // 这里的参数要和服务器端的一致if err1 != nil {fmt.Println(err1)}// 2, 当连接建立后，需要关闭它。否则会造成资源泄露。所以这里使用了 defer 关键字来延迟执行 Close 方法。defer conn.Close()// 注意：这里的 goods.AddGoods 指的是微服务端的方法名，要和微服务端的注册方法一致。// 3, 调用远程函数AddGoodsResvar reply AddGoodsRes/*1,第一个参数 hello.SayHello hello表示服务名称 SayHello方法名称2,第二个参数 给服务端的req传递数据3,第三个参数 需要传入地址 获取微服务端返回的数据*/err2 := conn.Call("goods.AddGoods", AddGoodsReq{Id:      1,Title:   "小米手机",Price:   2999.0,Content: "小米手机真好用",}, &reply)if err2 != nil {fmt.Println(err2)}// 4, 获取微服务返回的数据 查看返回结果fmt.Printf("%#v\n", reply)// 5, 调用远程函数GetGoodsResvar goodsData GetGoodsReserr3 := conn.Call("goods.GetGoods", GetGoodsReq{Id: 11,}, &goodsData)if err3 != nil {fmt.Println(err3)}// 6, 获取微服务返回的数据 查看返回结果fmt.Printf("%#v\n", goodsData)
}​​

四，ProtoBuf认识与使用

4.1 protobuf简介

Protobuf是Protocol Buffers的简称，它是Google公司开发的一种数据描述语言，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或RPC数据交换格式。可用于通讯协议，数据存储等领域的语言无关，平台无关，可扩展的序列化结构数据格式，他是一种灵活，高效，自动化的机制，用于序列化结构化数据，对比于XML和JSON,他更小，更快，更简单。总之他是微服务中需要使用的东西。

Protobuf刚开源时的定位类似于XML,JSON等数据描述语言，通过附带工具生成代码并实现将结构化数据序列化的功能。这里我们更关注的是Protobuf作为接口规范的描述语言，可以作为设计安全的跨语言RPC接口的基础工具。

需要了解两点

1，protobuf是类似与json一样的数据描述语言(数据格式)

2，protobuf非常适合于RPC数据交互格式

接着我们来看一下protobuf的优势和劣势：

优势：

1：序列化后体积相比json和XML很小，适合网络传输