Kitex 框架入门系列（二）：开源社区的 Middleware 是什么？

后端

2024-01-07 23:13:24

在第一期文章中，我们了解了 Kitex 的一些基本背景以及上手用法。作为开发者，我们更在意的是 Kitex 提供了哪些功能和便利，在哪些场景下我们可以用 Kitex 来帮助我们解决问题。

事实上，作为开发者我们更在意的并不是 Kitex本身，而是Kitex提供的生态工具，特别是Kitex 中的 Middleware。

什么是 Middleware

Middleware，即中间件，是一种位于应用程序和基础设施之间的软件层。它通常用于增强应用程序的功能，如安全性、日志记录、监控等。Middleware 可以作为独立的进程或线程运行，也可以嵌入到应用程序中。

在分布式系统中，Middleware 通常用于实现服务间的通信和交互。例如，在 RPC（远程过程调用）系统中，Middleware 可以负责将服务请求路由到相应的服务端，并处理服务端的响应。

Kitex 中的 Middleware

Kitex 中的 Middleware 是一个抽象层，用于在服务端和客户端处理请求和响应。Middleware 可以用于实现各种功能，如安全性、日志记录、监控、限流等。

Kitex 的 Middleware 是可插拔的，这意味着用户可以根据自己的需求选择使用哪些 Middleware。Middleware 的使用非常简单，只需要在服务端或客户端注册即可。

Kitex Middleware 的使用

Kitex Middleware 的使用非常简单，只需要在服务端或客户端注册即可。

服务端

在服务端，可以通过在服务注册时指定 Middleware 来使用 Middleware。例如：

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/cloudwego/kitex/client"
	"github.com/cloudwego/kitex/server"
)

func main() {
	// 创建一个服务端
	srv := server.NewServer()

	// 注册 Middleware
	srv.Use(new(myMiddleware))

	// 注册服务
	srv.RegisterService(new(Arith))

	// 监听端口
	err := srv.Run()
	if err != nil {
		log.Fatal(err)
	}
}

type Arith struct{}

// 实现 Arithmetic 接口
func (a *Arith) Mul(ctx context.Context, req *ArithRequest) (*ArithResponse, error) {
	return &ArithResponse{Ret: req.GetA() * req.GetB()}, nil
}

type myMiddleware struct{}

// Middleware 接口实现
func (m *myMiddleware) Handle(ctx context.Context, req interface{}) (interface{}, error) {
	// 处理请求
	fmt.Println("Middleware: Handle request")
	return m.Next(ctx, req)
}

func (m *myMiddleware) Next(ctx context.Context, req interface{}) (interface{}, error) {
	// 调用下一个 Middleware 或服务处理逻辑
	fmt.Println("Middleware: Next")
	return m.Invoke(ctx, req)
}

func (m *myMiddleware) Invoke(ctx context.Context, req interface{}) (interface{}, error) {
	// 调用服务处理逻辑
	fmt.Println("Middleware: Invoke")
	return nil, nil
}

客户端

在客户端，可以通过在创建客户端时指定 Middleware 来使用 Middleware。例如：

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/cloudwego/kitex/client"
	"github.com/cloudwego/kitex/server"
)

func main() {
	// 创建一个客户端
	client, err := client.NewClient(client.WithMiddleware(new(myMiddleware)))
	if err != nil {
		log.Fatal(err)
	}

	// 使用客户端
	arithClient := NewArithClient(client)
	req := &ArithRequest{A: 1, B: 2}
	resp, err := arithClient.Mul(context.Background(), req)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(resp.GetRet())
}

type Arith struct{}

// 实现 Arithmetic 接口
func (a *Arith) Mul(ctx context.Context, req *ArithRequest) (*ArithResponse, error) {
	return &ArithResponse{Ret: req.GetA() * req.GetB()}, nil
}

type myMiddleware struct{}

// Middleware 接口实现
func (m *myMiddleware) Handle(ctx context.Context, req interface{}) (interface{}, error) {
	// 处理请求
	fmt.Println("Middleware: Handle request")
	return m.Next(ctx, req)
}

func (m *myMiddleware) Next(ctx context.Context, req interface{}) (interface{}, error) {
	// 调用下一个 Middleware 或服务处理逻辑
	fmt.Println("Middleware: Next")
	return m.Invoke(ctx, req)
}

func (m *myMiddleware) Invoke(ctx context.Context, req interface{}) (interface{}, error) {
	// 调用服务处理逻辑
	fmt.Println("Middleware: Invoke")
	return nil, nil
}