go 微服务 demo go 微服务项目结构

转载

网络小墨 2024-07-03 01:01:09

文章标签 go 微服务 demo 微服务服务器网络 Go 文章分类 机器学习人工智能

1、架构
transport(传输层)：主要负责与HTTP、gRPC、thrift等相关逻辑，或使用NATS等发布订阅系统相
互通信，除此之外，还支持AMQP和thrift等多种网络通信模式；
endpoint(接口层)：是服务器和客户端的基本构建块。在go-kit中服务中的每个对外提供的接口方
法都会定一个端点(endpoint)，以便服务器和客户端之间进行网络通信。每个断电使用传输层通过
http或者grpc等通信模式对外提供服务。使用时定义request与response格式，并可以使用装饰器
包装函数，从而来实现各种中间件嵌套；
service(业务层)：实现具体的业务逻辑，不会包含具体的网络传输或者消息类型的编解码，只存放
业务类接口

context

上下文 context.Context Go 语言中用来设置截止日期、同步信号，传递请求相关值的结构体。上下文与 Goroutine 有比较密切的关系，是 Go 语言中独特的设计，在其他编程语言中我们很少见到类似的概念。

context.Context 是 Go 语言在 1.7 版本中引入标准库的接口1，该接口定义了四个需要实现的方法，其中包括：

Deadline — 返回 context.Context 被取消的时间，也就是完成工作的截止日期；
Done — 返回一个 Channel，这个 Channel 会在当前工作完成或者上下文被取消后关闭，多次调用 Done 方法会返回同一个 Channel；
Err — 返回 context.Context 结束的原因，它只会在 Done 方法对应的 Channel 关闭时返回非空的值；如果 context.Context 被取消，会返回 Canceled 错误；如果 context.Context 超时，会返回 DeadlineExceeded 错误；
Value — 从 context.Context 中获取键对应的值，对于同一个上下文来说，多次调用 Value 并传入相同的 Key 会返回相同的结果，该方法可以用来传递请求特定的数

type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} }

context 包中提供的 context.Background 、 context.TODO 、 context.WithDeadline 和context.WithValue 函数会返回实现该接口的私有结构体。

默认上下文

context 包中最常用的方法还是 context.Background 、 context.TODO ，这两个方法都会返回预先初始化好的私有变量 background 和 todo，它们会在同一个 Go 程序中被复用：

func Background() Context {
       return background
  }
  func TODO() Context {
       return todo
  }

从源代码来看， context.Background 和 context.TODO 也只是互为别名，没有太大的差别，只是在使用和语义上稍有不同：

context.Background 是上下文的默认值，所有其他的上下文都应该从它衍生出来；
context.TODO 应该仅在不确定应该使用哪种上下文时使用；

在多数情况下，如果当前函数没有上下文作为入参，我们都会使用 context.Background 作为起始的上下文向下传递。

接口

隐式接口

很多面向对象语言都有接口这一概念，例如 Java 和 C#。Java 的接口不仅可以定义方法签名，还可以定义变量，这些定义的变量可以直接在实现接口的类中使用，这里简单介绍一下 Java 中的接口：

public interface MyInterface {
         public String hello = "Hello";
         public void sayHello();
  }

上述代码定义了一个必须实现的方法 sayHello 和一个会注入到实现类的变量 hello。在下面的代码中，MyInterfaceImpl 实现了 MyInterface 接口：

public class MyInterfaceImpl implements MyInterface {
        public void sayHello() {
        System.out.println(MyInterface.hello);
  }
  }

Java 中的类必须通过上述方式显式地声明实现的接口，但是在 Go 语言中实现接口就不需要使用类似的方式。首先，我们简单了解一下在 Go 语言中如何定义接口。定义接口需要使用 interface 关键字，在接口中我们只能定义方法签名，不能包含成员变量，一个常见的 Go 语言接口是这样的：

type error interface {
     Error() string
  }

如果一个类型需要实现 error 接口，那么它只需要实现 Error() string 方法，下面的 RPCError 结构体就是error 接口的一个实现：

type RPCError struct {
  Code int64
  Message string
  }
  func (e *RPCError) Error() string {
  return fmt.Sprintf("%s, code=%d", e.Message, e.Code)
  }

上述代码根本就没有 error 接口的影子，这是为什么呢？Go 语言中接口的实现都是隐式的，我们只需要实现 Error() string 方法就实现了 error 接口。Go 语言实现接口的方式与 Java 完全不同：在 Java 中：实现接口需要显式地声明接口并实现所有方法；在 Go 中：实现接口的所有方法就隐式地实现了接口；我们使用上述 RPCError 结构体时并不关心它实现了哪些接口，Go 语言只会在传递参数、返回参数以及变量赋值时才会对某个类型是否实现接口进行检查，这里举几个例子来演示发生接口类型检查的时机：

func main() {
      var rpcErr error = NewRPCError(400, "unknown err") // typecheck1
      err := AsErr(rpcErr) // typecheck2
      println(err)
  }
  
  func NewRPCError(code int64, msg string) error {
       return &RPCError{ // typecheck3
       Code: code,
       Message: msg,
       }
  }
  
  func AsErr(err error) error {
       return err
  }

将 *RPCError 类型的变量赋值给 error 类型的变量 rpcErr；将 *RPCError 类型的变量 rpcErr 传递给签名中参数类型为 error 的 AsErr 函数；将 *RPCError 类型的变量从函数签名的返回值类型为 error 的 NewRPCError 函数中返回；

路由组件mux

mux代表“ HTTP请求多路复用器”。像standard一样 http.ServeMux ， mux.Router 将传入的请求与已注册的路由列表进行匹配，并为与URL或其他条件匹配的路由调用处理程序。主要特点是：

它实现了 http.Handler 接口，因此与标准兼容 http.ServeMux 。
可以基于URL主机，路径，路径前缀，方案，标头和查询值，HTTP方法或使用自定义匹配器来匹配请求。
URL主机，路径和查询值可以具有带有可选正则表达式的变量。
可以构建或“反转”已注册的URL，这有助于维护对资源的引用。
路由可用作子路由：仅在父路由匹配时才测试嵌套路由。这对于定义具有共同条件（例如主机，路径前缀或其他重复属性）的路由组很有用。另外，这可以优化请求匹配

使用

func ArticlesCategoryHandler(w http.ResponseWriter, r *http.Request) {
  // 解析路由变量
      vars := mux.Vars(r)
      w.WriteHeader(http.StatusOK)
      fmt.Fprintf(w, "Category: %v\n", vars["category"])
  
  }
  func main() {
      r := mux.NewRouter()
  // 绝对路径
      r.HandleFunc("/", HomeHandler)
      r.HandleFunc("/products", ProductsHandler)
      r.HandleFunc("/articles", ArticlesHandler)
  // 带参数
       r.HandleFunc("/products/{key}", ProductHandler)
       r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler)
       r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)
       http.Handle("/", r)
  }

mux: gorilla/mux 实现了一个请求路由和分发的 Go 框架

Transport

定义http handler

使用mux路由转发组件 mux.NewRouter()

func MakeHttpHandler(ctx context.Context, endpoints endpoint.ChannelEndpoints, logger log.Logger) http.Handler {
      r := mux.NewRouter()
      options := []kithttp.ServerOption{
          kithttp.ServerErrorHandler(transport.NewLogErrorHandler(logger)),
          kithttp.ServerErrorEncoder(encodeError),
      }

      r.Methods("GET").Path("/health").Handler(kithttp.NewServer(
          endpoints.HealthCheckEndpoint,
          decodeHealthCheckRequest,
          encodeJsonResponse,
          options...,
      ))
 
      return r
  }

encode & decode

func decodeHealthCheckRequest(ctx context.Context, r *http.Request) (interface{}, error) {
      return model.HealthRequest{}, nil
   }
   
   func encodeError(_ context.Context, err error, w http.ResponseWriter) {
      w.Header().Set("Content-Type", "application/json; charset=utf-8")
      switch err {
      default:
          w.WriteHeader(http.StatusInternalServerError)
      }
      json.NewEncoder(w).Encode(map[string]interface{}{
          "error": err.Error(),
      })
   }