微服务09——中间件

什么是 “中间件”：

• 中间件，对以后的路由全部生效。

  • 设置好中间件以后，所有的路由都会使用这个中间件。

  • 设置以前的路由，不生效。

• 用于 两个模块之间的 功能 软件(模块)
• 中间件：—— 承上启下。 前后台开发： 路由 ——> 中间件 (起过滤作用) ——> 控制器
• 特性：对 “中间件”指定位置 ， 以下的路由起作用！以上的，作用不到。

中间件类型

• gin 框架规定：中间件类型为：gin.HandlerFunc 类型。

• gin.HandlerFunc 类型。就是 ：

  func (c *gin.Context) { 
      
  }
  // 示例：
  func Logger() gin.HandlerFunc {
      return func (c *gin.Context) {   
      }
  }
  r.Use(Logger())     // 传 “中间件” 做参数。

中间件测试

正常顺序

// 创建第一种中间件

func CreateMid1(ctx *gin.Context) { //Test1 的类型就是Test2的返回类型
	fmt.Println("创建第一种中间件")
	fmt.Println("再创建第一种中间件")
}

// 创建第二种中间件/另一种格式的中间件

func CreateMid2() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("创建第二种中间件")
		fmt.Println("再创建第二种中间件")
	}
}



func Test() {
	router := gin.Default()

	// 使用中间件
	router.Use(CreateMid1) //注意两种调用方式
	router.Use(CreateMid2())

	router.GET("/test", func(context *gin.Context) {
		fmt.Println("使用中间件")
		context.Writer.WriteString("hello world!")
	})

	router.Run(":9999")
}

Next()

• 表示，跳过当前中间件剩余内容， 去执行下一个中间件。 当所有操作执行完之后，以出栈的执行顺序返回，执行剩余代码。

// 测试next()

func CreateMid1_next(ctx *gin.Context) { //Test1 的类型就是Test2的返回类型
	fmt.Println("创建第一种中间件")
	ctx.Next() //跳过当前中间件剩余内容， 去执行下一个中间件。 当所有操作执行完之后，以出栈的执行顺序返回，执行剩余代码。
	fmt.Println("再创建第一种中间件")
}

func CreateMid2_next() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("创建第二种中间件")
		context.Next()
		fmt.Println("再创建第二种中间件")
	}
}

func TestNext() {
	router := gin.Default()

	// 使用中间件
	router.Use(CreateMid1_next) //注意两种调用方式
	router.Use(CreateMid2_next())

	router.GET("/test", func(context *gin.Context) {
		fmt.Println("使用中间件")
		context.Writer.WriteString("hello world!")
	})

	router.Run(":9999")
}

 Return

终止执行当前中间件剩余内容，执行下一个中间件。 当所有的函数执行结束后，以出栈的顺序执行返回，但，不执行return后的代码！

func CreateMid1_next(ctx *gin.Context) { //Test1 的类型就是Test2的返回类型
	fmt.Println("创建第一种中间件")
	ctx.Next() //跳过当前中间件剩余内容， 去执行下一个中间件。 当所有操作执行完之后，以出栈的执行顺序返回，执行剩余代码。
	fmt.Println("再创建第一种中间件")
}

// 测试return

func CreateMid2_return() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("创建第二种中间件")
		return // return   // 终止执行当前中间件的剩余内容，执行下一个中间件的内容
		context.Next()
		fmt.Println("再创建第二种中间件")
	}
}

func TestReturn() {
	router := gin.Default()

	// 使用中间件
	router.Use(CreateMid1_next) //注意两种调用方式
	router.Use(CreateMid2_return())

	router.GET("/test", func(context *gin.Context) {
		fmt.Println("使用中间件")
		context.Writer.WriteString("hello world!")
	})

	router.Run(":9999")
}

Abort

只执行当前中间件， 操作完成后，以出栈的顺序，依次返回上一级中间件。

func CreateMid1_next(ctx *gin.Context) { //Test1 的类型就是Test2的返回类型
	fmt.Println("创建第一种中间件")
	ctx.Next() //跳过当前中间件剩余内容， 去执行下一个中间件。 当所有操作执行完之后，以出栈的执行顺序返回，执行剩余代码。
	fmt.Println("再创建第一种中间件")
}

// 测试Abort

func CreateMid2_Abort() gin.HandlerFunc {
	return func(context *gin.Context) {
		fmt.Println("创建第二种中间件")
		context.Abort() // 只执行当前中间件，操作完成后，执行上一个中间件
		fmt.Println("再创建第二种中间件")
	}
}


func TestAbort() {
	router := gin.Default()

	// 使用中间件
	router.Use(CreateMid1_next) //注意两种调用方式
	router.Use(CreateMid2_Abort())

	router.GET("/test", func(context *gin.Context) {
		fmt.Println("使用中间件")
		context.Writer.WriteString("hello world!")
	})

	router.Run(":9999")
}

 中间件测试业务时间

// 测试业务时间

func TestTime() {
	router := gin.Default()

	// 使用中间件

	// 测试第一种     6.902µs
	router.Use(CreateMid1_Time) //注意两种调用方式
	router.Use(CreateMid2_next())

	router.GET("/test", func(context *gin.Context) {
		fmt.Println("使用中间件")
		context.Writer.WriteString("hello world!")
	})

	/*	// 测试第二种		1.708µs
		router.Use(CreateMid1_Time) //注意两种调用方式
		router.Use(CreateMid2_Abort())

		router.GET("/test", func(context *gin.Context) {
			fmt.Println("使用中间件")
			context.Writer.WriteString("hello world!")
		})*/

	router.Run(":9999")
}

 总结

• 2种 书写格式：（见 前面笔记）

• 3个 操作函数/关键字： Next()、return、Abort()

• 作用域：作用域 以下 的路由。（ 对以上的 路由 无效！）