go-micro 安装

安装步骤如下：

  1. #安装go-micro
  2. go get -u -v github.com/micro/go-micro
  3. #安装工具集
  4. go get -u -v github.com/micro/micro
  5. #安装protobuf插件
  6. go get -u github.com/golang/protobuf/{proto,protoc-gen-go}
  7. go get -u github.com/micro/protoc-gen-micro

或者通过docker镜像安装：
$ docker pull microhq/micro
安装之后输入micro命令，显示如下就证明安装成功
image.png

go-micro 的使用

首先我们先来创建一个go micro框架的项目，我们使用micro命令，可以创建微服务，web项目等，具体用法如下：

  1. micro new [command options][arguments...]
  2. new        #创建    通过指定相对于$GOPATH的目录路径，创建一个新的微服务。
  3. #指定服务的命名空间
  4. --namespace "go.micro"    Namespace for the service e.g com.example
  5. #服务类型，可以是微服务srv,或者web项目,或者api等                        
  6. --type "srv"            Type of service e.g api, fnc, srv, web
  7. #服务的正式完整定义                        
  8. --fqdn                     FQDN of service e.g com.example.srv.service (defaults to namespace.type.alias)
  9. #别名是在指定时作为组合名的一部分使用的短名称  别名                        
  10. --alias                 Alias is the short name used as part of combined name if specified

创建服务

  • ==micro new —type srv bj38 —— 创建一个微服务项目!==

上面一条指令会出现下图所示文件。
image.png

  • main.go : 项目的入口文件。
  • handler/: 处理 grpc 实现的接口。对应实现接口的子类，都放置在 handler 中。
  • proto/： 预生成的 protobuf 文件。
  • Dockerfile：部署微服务使用的 Dockerfile
  • Makefile：编译文件。—— 快速编译 protobuf 文件。 直接使用make proto不用之前那个很长的

    查看创建的项目

  1. makefile 编译 proto
  2. 查看 make proto生 成 的 文件：
    1. xxx.pb.go
    2. xxx.micro.go
      • RegisterBj38Handler()【168行】服务端用 ———— 对应 grpc RegisterXXXService()
      • NewBj38Service()【47行】客户端用 —— 对应 grpc NewXXXClient() —— 对应自己封装的 IintXXX

  3. 查看 main.go

    1. func main() {
    2.  // New Service   -- 初始化服务器对象.
    3.  service := micro.NewService(
    4.      micro.Name("go.micro.srv.bj38"),   // 服务器名
    5.      micro.Version("latest"),           // 版本
    6.  )
    7.  // Initialise service 与newService作用一致,但优先级高.后续代码运行期,初始化才有使用的必要.
    8.  //service.Init()
    10.  // Register Handler --- 注册服务
    11.  bj38.RegisterBj38Handler(service.Server(), new(handler.Bj38))
    13.  // Register Struct as Subscriber -- redis 发布订阅.
    14.  //micro.RegisterSubscriber("go.micro.srv.bj38", service.Server(), new(subscriber.Bj38))
    16.  // Register Function as Subscriber
    17.  //micro.RegisterSubscriber("go.micro.srv.bj38", service.Server(), subscriber.Handler)
    19.  // Run service  --- 运行服务
    20.  if err := service.Run(); err != nil {
    21.      log.Fatal(err)
    22.  }
    23. }

    创建 micro 服务

    命令：micro new —type srv test66
    框架默认自带服务发现：mdns。
    使用consul服务发现：
    1. 初始consul服务发现： consulReg := consul.NewRegistry()
    2. 在 NewService 中 添加 服务。 micro.Registry(consulReg )，

    使用 go-micro框架 创建 客户端

    命令：micro new —type web test77

    补充 http 相关知识：

  • 路由器：资源分发
  • 路由：请求分发。
    • service.HandleFunc(“/test77/call”, handler.Test77Call)
      • 将 /test77/call 这个请求，通过 回到函数 Test77Call() 处理。

  • URL：

    • 组成：https://ip+port/资源路径
      • https://ip+port/ 找到 pc机，找到 对应进程
      • 资源路径：在代码中，称之为路由。
    • “/ ” : 代表 主机上进程 对应的默认资源。
      • http协议，自动找当前目录下的 index.html 文件，做默认页面。

        go-micro 框架 测试使用 分析图

        image.png

        gin 框架

        go常见的web框架：gin、beego、echo、Iris 。。。

        实现简单的 web

        http 常用方法与 数据库访问 一一对应。

  • GET —— 查 —— 获取数据

  • Post —— 增 —— 增加数据
  • Put —— 改 —— 更新数据

  • Delete —— 删 —— 删除数据

    使用 gin 框架创建最简单的web

    1. func main()  {
    2.   // 1. 初始化路由 -- 官网:初始化 web 引擎
    3.   router := gin.Default()
    5.   // 2. 做路由匹配
    6.   router.GET("/", func(context *gin.Context) {
    7.       context.Writer.WriteString("hello world!")
    8.   })
    10.   // 3. 启动运行
    11.   router.Run(":8080")
    12. }

    gin 框架的客户端 与 微服务 对接

  1. 封装回调函数， 给 router.Get() 设置
  2. 拷贝 微服务的 “ 密码本” protobuf 到 web 中
  3. 修改 protobuf文件的 包名。 test66别名 “test66web/proto/test66”
  4. 实现 回调函数：
    1. 初始化客户端。 microClient := NewTeset66Sevice(服务名，client.DefaultClient)
    2. 调用远程服务。 resp, err := microClient.Call(context.TODO, &test66.Request{ })
    3. 将 返回的 数据， 显示到 浏览器。 context.Writer.WriteString(resp.Msg); ```go package main

import ( “github.com/gin-gonic/gin” “fmt” test66 “test66web/proto/test66” // test66 为包的别名. “github.com/micro/go-micro/client” “context” )

func CallRemote(ctx *gin.Context) { // 1. 初始化客户端 microClient := test66.NewTest66Service(“go.micro.srv.test66”, client.DefaultClient) fmt.Println()

  1. // 2. 调用远程服务
  2. resp, err := microClient.Call(context.TODO(), &test66.Request{
  3.     Name:"xiaowang",
  4. })
  5. if err != nil {
  6.     fmt.Println("call err:", err)
  7.     return
  8. }
  9. // 为了方便查看, 在打印之前将结果返回给浏览器
  10. ctx.Writer.WriteString(resp.Msg)
  12. fmt.Println(resp, err)

}

func main() { // 1. 初始化路由 — 官网:初始化 web 引擎 router := gin.Default()

  1. // 2. 做路由匹配
  2. router.GET("/", CallRemote)
  4. // 3. 启动运行
  5. router.Run(":8080")

} ``` image.png

指定 consul 服务发现到 go-micro 服务和 gin 框架客户端中

  • mdns服务发现: （组播）支持的服务，必须是本地服务， 局域网内的服务。

所以需要的是consul

修改 go-micro 微服务

  1. consulReg := consul.NewRegistry() 初始化 consul服务发现

  2. 添加 服务 service := micro.NewService(

    micro.Name(“go.micro.srv.test66”), micro.Registry(consulReg),
    micro.Version(“latest”), )

  3. 在命令行，执行 consul agent -dev

    修改 gin 框架 web服务 (客户端)

  4. consulReg := consul.NewRegistry() 初始化 consul服务发现

  5. microClinet := micro.NewService( micro.Registry(consulReg ) )
  6. test66.NewTest66Service(“服务名”，microClinet.Client() )

测试：浏览器键入： 192.168.6.108:8080 ——> hello xiaowang
image.png

REST

REST全称是Representational State Transfer： 表述性 状态 转义
本质：一种代码设计风格。 web开发中常用。——遵循风格！
使用：一般以 http 4 种请求方法， 来确定对某一资源（URI：标识符。名词）的 固定操作。

  • 获取数据：GET
  • 添加数据：POST
  • 修改数据：PUT

  • 删除数据：Delete

    1.   满足 REST 设计风格的， 称之为 “RESTful”<br />

    MVC

  • 是一种常见的 “代码组织架构”， 可以在开发中，对数据进行处理并解耦。

    • model：模型。 处理数据库相关的文件。
    • veiw：视图。处理显示相关的文件。 网站：html
    • controller：控制器。处理具体业务！ 联动 m 和 v
  • MVC 与语言无关！是常见的 代码组织架构。

image.png