golang入门笔记——Hertz_代码007(未授权)

本文介绍: He rtz是字节跳动研发的企业级微服务HTTP框架，具有高易用性、易扩展、低时延等特点。是基于自研网络库Ne t p oll开发的内部框架Hertz。Her tz框架整体上满足：1.极致性能优化的问题性2.面对未来不可控需求的扩展能力，Her tz采用了4层分层设计（应用层、路由层、协议层、传输层），保证各个层级功能内聚，同时通过层级之间的接口达到灵活扩展的目标。

Her tz是字节跳动研发的企业级微服务HTTP框架，具有高易用性、易扩展、低时延等特点。是基于自研网络库Net p oll开发的内部框架Her tz。Her tz框架整体上满足：
1.极致性能优化的问题性
2.面对未来不可控需求的扩展能力，Hertz采用了4层分层设计（应用层、路由层、协议层、传输层），保证各个层级功能内聚，同时通过层级之间的接口达到灵活扩展的目标。整体框架如下图：

主要包括与用户直接交互的易用的API，主要包括Server、Client和一些其他通用抽象。Hertz框架最具特点的是处理函数（HandlerFunc）多了一个 context上下文，这是在大量的实践过程中发现的，业务方通常需要一个标准的上下文在RPC Client或者日志、Trac in g等组件间传递，但由于请求上下文（Reque stCon text）生命周期局限于一次HTTP请求之内而以上提到的场景往往存在异步的传递和处理，导致如果直接传递请求上下文，会导致出现一些数据不一致的问题。因此最终增加了一个标准的上下文入参，从根本上解决各种因为上下文生命周期不一致的异常问题，处理函数的格式为：
type HandlerFunc func(c context.Context,ctx *app.RequestContext)

Hertz在设计路由时，给了用户极高的自由度去注册路由，支持的路由有：支持静态路由、参数路由的注册；支持按优先级匹配，支持路由回溯，支持尾斜线重定向。例如：
1.优先级匹配，如/a/b和/:c/b，同时满足时，优先匹配/a/b
2.路由回溯，如注册/a/b和/:c/d，当匹配/a/d时仍然能够匹配上/:c/d
3.支持尾斜线重定向，如注册/a/b，当匹配/a/b/时重定向到/a/b上

协议层负责不同协议的实现和扩展。Hertz支持协议的扩展，用户只需要实现下面的接口便可以按照自己的需求在引擎上扩展协议，同时也支持通过ALPN协议协商的方式注册。Hertz首批只开源了 HTTP1 实现，未来会陆续开源 HTTP2、QUIC 等实现。协议层扩展提供的灵活性甚至可以超越 HTTP 协议的范畴，用户完全可以按需注册任意符合自身需求的协议层实现，并且加入到Hertz的引擎中来，同时，也能够无缝享受到传输层带来的极致性能。

go func(){
	for{
		conn,_:=listener.Accept()
		go func(){
			conn.Read(request)
			handle...
			conn.Write(response)
		}
	}
}

go func(){
	for{
		readableConns,_:=Monitor(conns) //监听器，有足够的数据之后再去唤醒
		for conn:=range readableConns{
			go func(){
				conn.Read(request)
				handle...
				conn.Write(response)
			}
	}
	}
}

type Conn interface{
	Read(b []byte)(n int,err error)
	Write(b []byte)(n int,err error)
	...
}

type Reader interface{
	Peek(n int)([]byte,error)
	Discard(n int)(discarded int,err error)
	Release()error
	Size()int
	Read(b []byte)(l int,err error)
	...
}
type Writer interface{
	Write(p []byte)
	Size()int
	Flush()error
	...
}

type Conn interface{
	net.Conn
	Reader
	Writer
}

type Reader interface{
	Peek(n int)([]byte,error)
	...
}
type Writer interface{
	Malloc(n int)(buf []byte,err error)
	Flush()error
	...
}

1.通过Header key首字母快速筛除掉完全不可能的key
2.解析对应value到独立字段
3.使用byte slice管理对应header存储，方便复用
优点：
1.核心字段快速解析
2.使用byte slice存储
3.额外存储到成员变量中
缺点：
1.普通header性能较低
2.没有map结构

优点：
超高的转换效率，比net.http提高40倍
缺点：
额外的内存开销，变更困难

优点：
	1.减少了内存分配
	2.提高了内存复用
	3.降低了GC压力
	4.性能提升
缺点：
	1.额外的Reset逻辑
	2.请求内有效
	3.问题定位难度增加

package main

import (
   "context"
   "github.com/cloudwego/hertz/pkg/app"
   "github.com/cloudwego/hertz/pkg/app/server"
   "github.com/cloudwego/hertz/pkg/common/utils"
   "net/http"
)

func main() {
   h := server.Default(server.WithHostPorts("127.0.0.1:8080"))
   h.GET("/ping", func(c context.Context, ctx *app.RequestContext) {
      ctx.JSON(http.StatusOK, utils.H{"ping": "pong"})
   })
   h.Spin()
}

v1 := h.Group("/v1")
{
   v1.GET("/login", func(c context.Context, ctx *app.RequestContext) {
   })

}
v2 := h.Group("/v2")
{
   v2.GET("/login", func(c context.Context, ctx *app.RequestContext) {

   })
}

h.GET("/herz/:version", func(c context.Context, ctx *app.RequestContext) {

})
h.GET("/herz/*action", func(c context.Context, ctx *app.RequestContext) {

})

type InfoRequest struct {
		Name         string   `vd:"($!='Alice'||(Age)$==18) &amp;&amp; regexp('w')"`
		Age          int      `vd:"$>0"`
		Email        string   `vd:"email($)"`
		Phone1       string   `vd:"phone($)"`
		OtherPhones  []string `vd:"range($, phone(#v,'CN'))"`
		*InfoRequest `vd:"?"`
		Info1        *InfoRequest `vd:"?"`
		Info2        *InfoRequest `vd:"-"`
	}

import "github.com/cloudwego/hertz/pkg/app/server/binding"

func init() {
    binding.MustRegValidateFunc("test", func(args ...interface{}) error {
       if len(args) != 1 {
          return fmt.Errorf("the args must be one")
       }
       s, _ := args[0].(string)
       if s == "123" {
          return fmt.Errorf("the args can not be 123")
       }
       return nil
    })
}

type Args struct {
   Query      string   `query:"query"vd:"$!='Hertz'"`
   QuerySlice []string `query:"queryslice"`
   Path       string   `path:"path"`
   Header     string   `header:"header"`
   Form       string   `form:"form"`
   Json       string   `json:"json"`
}

func main(){
h := server.Default(server.WithHostPorts("127.0.0.1:8080"))
h.POST("v:path/bind", func(c context.Context, ctx *app.RequestContext) {
   var arg Args
   err := ctx.BindAndValidate(&amp;arg)
   if err != nil {
      panic(err)
   }
})
}

func MyMiddleware() app.HandlerFunc {
   return func(c context.Context, ctx *app.RequestContext) {
      fmt.Println("pre-handle")
      ctx.Next(c)
      fmt.Println("post-handle")
   }
}
func main() {
   h := server.Default(server.WithHostPorts("127.0.0.1:8080"))
   h.Use(MyMiddleware())
}

package main

import (
   "context"
   "fmt"
   "github.com/cloudwego/hertz/pkg/app/client"
   "github.com/cloudwego/hertz/pkg/protocol"
)

func main() {
   c, err := client.NewClient()
   if err != nil {
      return
   }
   status, body, _ := c.Get(context.Background(), nil, "http://baidu.com")
   fmt.Printf("status:%v body:%v", status, string(body))
   var postArgs protocol.Args
   postArgs.Set("arg", "a")
   status, body, _ = c.Post(context.Background(), nil, "http://baidu.com", &amp;postArgs)
   fmt.Printf("status:%v body:%v", status, string(body))
}

go install github.com/cloudwego/hertz/cmd/hz@latest

#hz生成用例代码
hz new -module example

namespace go hello.example

struct HelloReq{
    1:string Name (api.query="name");
}

struct HelloResp{
    1:string RespBody;
}

service HelloService{
    HelloResp HelloMethod(1:HelloReq request)(api.get="/hello")
}

hz new -module mod_name -idl idl/hello.thrift

// Code generated by hertz generator.

package example

import (
   "context"

   "github.com/cloudwego/hertz/pkg/app"
   "github.com/cloudwego/hertz/pkg/protocol/consts"
   example "hertz-demo/biz/model/hello/example"
)

// HelloMethod .
// @router /hello [GET]
func HelloMethod(ctx context.Context, c *app.RequestContext) {
   var err error
   var req example.HelloReq
   err = c.BindAndValidate(&amp;req)
   if err != nil {
      c.String(consts.StatusBadRequest, err.Error())
      return
   }

   resp := new(example.HelloResp)

   c.JSON(consts.StatusOK, resp)
}

// Code generated by hertz generator. DO NOT EDIT.

package Example

import (
   "github.com/cloudwego/hertz/pkg/app/server"
   example "hertz-demo/biz/handler/hello/example"
)

/*
 This file will register all the routes of the services in the master idl.
 And it will update automatically when you use the "update" command for the idl.
 So don't modify the contents of the file, or your code will be deleted when it is updated.
*/

// Register register routes based on the IDL 'api.${HTTP Method}' annotation.
func Register(r *server.Hertz) {

   root := r.Group("/", rootMw()...)
   root.GET("/hello", append(_hellomethodMw(), example.HelloMethod)...)
}

func main() {
	h := server.Default()
	
	h.GET("/user/:name", func(c context.Context, ctx *app.RequestContext) {
		fpath := ctx.FullPath()
		println(fpath)
	})
	//请求 http://localhost:8888/user/zyj 会打印/user/:name

	h.NoRoute(func(c context.Context, ctx *app.RequestContext) {
		println(ctx.FullPath())
	})
	//任何不符合匹配规则的uri请求都会返回空

	h.GET("/user/:name", func(c context.Context, ctx *app.RequestContext) {
		name := ctx.Param("name")
		println(name)
	})
	//Param获取Param参数

	h.GET("/user", func(c context.Context, ctx *app.RequestContext) {
		name := ctx.Query("name")
		println(name)
	})
	//获取的是Query参数，即？后面的参数
	//DefaultQuery获取不到Query参数给一个默认值
	
	h.Use(cors.New(cors.Config{ //跨域中间件
		AllowAllOrigins:  true, //允许所有origin的请求
		AllowMethods:     []string{"GET", "PUT", "POST", "DELETE"}, //允许的方法
		AllowHeaders:     []string{"Origin"}, //允许的头部
		ExposeHeaders:    []string{"Content-Length"}, //暴漏的头部信息
		AllowCredentials: true,	//允许携带证书
		AllowWildcard:    true, //允许使用通配符匹配
		AllowOriginFunc: func(origin string) bool { //自定义处理源的函数
 			return origin == "https://github.com"
		},
		MaxAge: 12 * time.Hour,  //请求缓存的最长时间
	}))

	register(h)
	h.Spin()
}

	h.GET("/header", func(c context.Context, ctx *app.RequestContext) {
		ctx.Request.Header.Add("hertz1", "value1")
		ctx.Request.Header.SetContentTypeBytes([]byte("application/x-www-form-urlencoded")) //设置内容类型
		ctx.Request.Header.Add("Content-Type", "application/json;charset=utf-8")
		hertz := ctx.Request.Header.GetAll("hertz1")
		println(hertz)
		contentType2 := ctx.Request.Header.ContentType()
		fmt.Println(contentType2)
	})

	h.POST("/form_data", func(c context.Context, ctx *app.RequestContext) {
		data := ctx.PostForm("data")
		fmt.Println(data)
	})

	//多文件
	h.POST("/multifile", func(c context.Context, ctx *app.RequestContext) {
		form, err := ctx.MultipartForm()
		if err != nil {
			panic(err)
		}
		name := form.Value["name"][0]
		file := form.File["file"][0]
		fmt.Println(name)
		fmt.Println(file.Filename)
	})

	//单文件
	h.POST("/user", func(c context.Context, ctx *app.RequestContext) {
		file, err := ctx.FormFile("file")
		if err != nil {
			panic(err)
		}
		fmt.Println(file.Filename)
	})

	store := cookie.NewStore([]byte("secret"))
	h.Use(sessions.New("mysession", store))
	h.GET("/incr", func(c context.Context, ctx *app.RequestContext) {
		session := sessions.Default(ctx)
		var count int
		v := session.Get("count")
		if v != nil {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		_ = session.Save()
		ctx.JSON(200, utils.H{"count": count})

	})

	h.Use(gzip.Gzip(
		gzip.DefaultCompression,
		gzip.WithExcludedExtensions([]string{".pdf", ".mp4"}), //pdf和mp4不压缩
	))

显示所有内容

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

hertz 传输层路由

文章 目录

Her tz介绍

应用层

路由层

协议层

传输层

HZ脚手架

Hertz的使用

一个简单的案例：利用Hertz监听8080端口并编写/ping的get 处理函数

Hertz和gin一样，提供了分组路由的功能

Hertz路由的匹配 优先级：静态路由>命名路由>通配路由

参数 绑定：Bind、Vali date、BindAndVali date 用于 参数 绑定和校验

中间件

HTTP Client

Hertz代码生成 工具

Hertz的一些基本函数

发表回复取消回复

Hertz介绍

应用层

路由层

协议层

HZ脚手架

Hertz的使用

一个简单的案例：利用Hertz监听8080端口并编写/ping的get处理函数

Hertz和gin一样，提供了分组路由的功能

Hertz路由的匹配优先级：静态路由>命名路由>通配路由

参数绑定：Bind、Validate、BindAndValidate用于参数绑定和校验

HTTP Client

Hertz代码生成工具

Hertz的一些基本函数

相关文章

发表回复 取消回复

Her tz介绍

一个简单的案例：利用Hertz监听8080端口并编写/ping的get 处理函数

参数绑定：Bind、Vali date、BindAndVali date 用于参数绑定和校验

发表回复取消回复