【Gin-v1.9.0源码阅读】context.go

最新推荐文章于 2023-09-04 10:24:52 发布
深漂小码哥
最新推荐文章于 2023-09-04 10:24:52 发布
阅读量308
点赞数
分类专栏：后端PHP/Golang/.NET/JAVA 文章标签： golang 开发语言 gin 后端
本文链接：https://blog.csdn.net/qq2942713658/article/details/130997156
版权
后端PHP/Golang/.NET/JAVA 专栏收录该内容
992 篇文章
订阅专栏
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

package gin

import (
	"errors"
	"io"
	"log"
	"math"
	"mime/multipart"
	"net"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"github.com/gin-contrib/sse"
	"github.com/gin-gonic/gin/binding"
	"github.com/gin-gonic/gin/render"
)

// Content-Type MIME of the most common data formats.
// 最常见的数据格式的内容类型MIME。
const (
	MIMEJSON              = binding.MIMEJSON
	MIMEHTML              = binding.MIMEHTML
	MIMEXML               = binding.MIMEXML
	MIMEXML2              = binding.MIMEXML2
	MIMEPlain             = binding.MIMEPlain
	MIMEPOSTForm          = binding.MIMEPOSTForm
	MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
	MIMEYAML              = binding.MIMEYAML
	MIMETOML              = binding.MIMETOML
)

// BodyBytesKey indicates a default body bytes key.
// BodyBytesKey表示默认的正文字节键。
const BodyBytesKey = "_gin-gonic/gin/bodybyteskey"

// ContextKey is the key that a Context returns itself for.
// ContextKey是Context为其自身返回的键。
const ContextKey = "_gin-gonic/gin/contextkey"

// abortIndex represents a typical value used in abort functions.
// abortIndex表示中止函数中使用的一个典型值。
const abortIndex int8 = math.MaxInt8 >> 1

// Context is the most important part of gin. It allows us to pass variables between middleware,
// manage the flow, validate the JSON of a request and render a JSON response for example.
// 上下文是gin最重要的部分。例如，它允许我们在中间件之间传递变量、管理流、验证请求的JSON和呈现JSON响应。
type Context struct {
	writermem responseWriter
	Request   *http.Request
	Writer    ResponseWriter

	Params   Params
	handlers HandlersChain
	index    int8
	fullPath string

	engine       *Engine
	params       *Params
	skippedNodes *[]skippedNode

	// This mutex protects Keys map.
	// 这个互斥对象保护密钥映射。
	mu sync.RWMutex

	// Keys is a key/value pair exclusively for the context of each request.
	// Keys是专门用于每个请求上下文的键/值对。
	Keys map[string]any

	// Errors is a list of errors attached to all the handlers/middlewares who used this context.
	// Errors是附加到使用此上下文的所有处理程序/中间件的错误列表。
	Errors errorMsgs

	// Accepted defines a list of manually accepted formats for content negotiation.
	// Accepted为内容协商定义了一个手动接受的格式列表。
	Accepted []string

	// queryCache caches the query result from c.Request.URL.Query().
	// queryCache缓存来自c.Request.URL.query（）的查询结果。
	queryCache url.Values

	// formCache caches c.Request.PostForm, which contains the parsed form data from POST, PATCH,
	// or PUT body parameters.
	// formCache缓存c.Request.PostForm，其中包含来自POST、PATCH或PUT主体参数的解析表单数据。
	formCache url.Values

	// SameSite allows a server to define a cookie attribute making it impossible for
	// the browser to send this cookie along with cross-site requests.
	// SameSite允许服务器定义cookie属性，使浏览器无法将此cookie与跨站点请求一起发送。
	sameSite http.SameSite
}

/************************************/
/********** CONTEXT CREATION ********/
/************************************/

func (c *Context) reset() {
	c.Writer = &c.writermem
	c.Params = c.Params[:0]
	c.handlers = nil
	c.index = -1

	c.fullPath = ""
	c.Keys = nil
	c.Errors = c.Errors[:0]
	c.Accepted = nil
	c.queryCache = nil
	c.formCache = nil
	c.sameSite = 0
	*c.params = (*c.params)[:0]
	*c.skippedNodes = (*c.skippedNodes)[:0]
}

// Copy returns a copy of the current context that can be safely used outside the request's scope.
// This has to be used when the context has to be passed to a goroutine.
// Copy返回当前上下文的副本，该副本可以在请求的范围之外安全使用。当上下文必须传递给goroutine时，必须使用该副本。
func (c *Context) Copy() *Context {
	cp := Context{
		writermem: c.writermem,
		Request:   c.Request,
		Params:    c.Params,
		engine:    c.engine,
	}
	cp.writermem.ResponseWriter = nil
	cp.Writer = &cp.writermem
	cp.index = abortIndex
	cp.handlers = nil
	cp.Keys = map[string]any{}
	for k, v := range c.Keys {
		cp.Keys[k] = v
	}
	paramCopy := make([]Param, len(cp.Params))
	copy(paramCopy, cp.Params)
	cp.Params = paramCopy
	return &cp
}

// HandlerName returns the main handler's name. For example if the handler is "handleGetUsers()",
// this function will return "main.handleGetUsers".
// HandlerName返回主处理程序的名称。例如，如果处理程序是“handleGetUsers（）”，则此函数将返回“main.handleGetUsers”。
func (c *Context) HandlerName() string {
	return nameOfFunction(c.handlers.Last())
}

// HandlerNames returns a list of all registered handlers for this context in descending order,
// following the semantics of HandlerName()
// HandlerNames按照HandlerName（）的语义，按降序返回此上下文的所有注册处理程序的列表
func (c *Context) HandlerNames() []string {
	hn := make([]string, 0, len(c.handlers))
	for _, val := range c.handlers {
		hn = append(hn, nameOfFunction(val))
	}
	return hn
}

// Handler returns the main handler.
// Handler返回主处理程序。
func (c *Context) Handler() HandlerFunc {
	return c.handlers.Last()
}

// FullPath returns a matched route full path. For not found routes
// returns an empty string.
// FullPath返回匹配的路由完整路径。对于未找到的路由，返回一个空字符串。
//
//	router.GET("/user/:id", func(c *gin.Context) {
//	    c.FullPath() == "/user/:id" // true
//	})
func (c *Context) FullPath() string {
	return c.fullPath
}

/************************************/
/*********** FLOW CONTROL ***********/
/************************************/

// Next should be used only inside middleware.
// It executes the pending handlers in the chain inside the calling handler.
// See example in GitHub.
// Next只能在中间件内部使用。它在调用处理程序内部执行链中的挂起处理程序。请参阅GitHub中的示例。
func (c *Context) Next() {
	c.index++
	for c.index < int8(len(c.handlers)) {
		c.handlers[c.index](c)
		c.index++
	}
}

// IsAborted returns true if the current context was aborted.
// 如果当前上下文已中止，则IsAborted返回true。
func (c *Context) IsAborted() bool {
	return c.index >= abortIndex
}

// Abort prevents pending handlers from being called. Note that this will not stop the current handler.
// Let's say you have an authorization middleware that validates that the current request is authorized.
// If the authorization fails (ex: the password does not match), call Abort to ensure the remaining handlers
// for this request are not called.
// Abort可防止调用挂起的处理程序。请注意，这不会停止当前处理程序。假设您有一个授权中间件来验证当前请求是否已被授权。
// 如果授权失败（例如：密码不匹配），请调用Abort以确保不会调用此请求的其余处理程序。
func (c *Context) Abort() {
	c.index = abortIndex
}

// AbortWithStatus calls `Abort()` and writes the headers with the specified status code.
// For example, a failed attempt to authenticate a request could use: context.AbortWithStatus(401).
// AbortWithStatus调用“Abort（）”并使用指定的状态代码写入标头。例如，对请求进行身份验证的失败尝试可以使用：context.ArtrtWithStatus（401）。
func (c *Context) AbortWithStatus(code int) {
	c.Status(code)
	c.Writer.WriteHeaderNow()
	c.Abort()
}

// AbortWithStatusJSON calls `Abort()` and then `JSON` internally.
// This method stops the chain, writes the status code and return a JSON body.
// It also sets the Content-Type as "application/json".
// AbortWithStatusJSON在内部调用“Abort（）”，然后调用“JSON”。此方法停止链，编写状态代码并返回JSON主体。它还将内容类型设置为“application/JSON”。
func (c *Context) AbortWithStatusJSON(code int, jsonObj any) {
	c.Abort()
	c.JSON(code, jsonObj)
}

// AbortWithError calls `AbortWithStatus()` and `Error()` internally.
// This method stops the chain, writes the status code and pushes the specified error to `c.Errors`.
// See Context.Error() for more details.
// AbortWithError在内部调用“AbortWithStatus（）”和“Error（）”。此方法停止链，写入状态代码，并将指定的错误推送到“c.Errors”。有关详细信息，请参阅Context.Error（）。
func (c *Context) AbortWithError(code int, err error) *Error {
	c.AbortWithStatus(code)
	return c.Error(err)
}

/************************************/
/********* ERROR MANAGEMENT *********/
/************************************/

// Error attaches an error to the current context. The error is pushed to a list of errors.
// It's a good idea to call Error for each error that occurred during the resolution of a request.
// A middleware can be used to collect all the errors and push them to a database together,
// print a log, or append it in the HTTP response.
// Error将错误附加到当前上下文。错误被推送到错误列表中。最好为请求解析过程中发生的每个错误调用error。中间件可以用来收集所有错误，并将它们一起推送到数据库，打印日志，或将其附加到HTTP响应中。
// Error will panic if err is nil.
// 如果err为零，错误将panic。
func (c *Context) Error(err error) *Error {
	if err == nil {
		panic("err is nil")
	}

	var parsedError *Error
	ok := errors.As(err, &parsedError)
	if !ok {
		parsedError = &Error{
			Err:  err,
			Type: ErrorTypePrivate,
		}
	}

	c.Errors = append(c.Errors, parsedError)
	return parsedError
}

/************************************/
/******** METADATA MANAGEMENT********/
/************************************/

// Set is used to store a new key/value pair exclusively for this context.
// Set用于专门为此上下文存储新的键/值对。
// It also lazy initializes  c.Keys if it was not used previously.
// 如果以前没有使用过，它还会惰性地初始化c.键。
func (c *Context) Set(key string, value any) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.Keys == nil {
		c.Keys = make(map[string]any)
	}

	c.Keys[key] = value
}

// Get returns the value for the given key, ie: (value, true).
// Get返回给定键的值，即：（value，true）。
// If the value does not exist it returns (nil, false)
// 如果该值不存在，则返回（nil，false）
func (c *Context) Get(key string) (value any, exists bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	value, exists = c.Keys[key]
	return
}

// MustGet returns the value for the given key if it exists, otherwise it panics.
// MustGet返回给定键的值（如果存在），否则会死机。
func (c *Context) MustGet(key string) any {
	if value, exists := c.Get(key); exists {
		return value
	}
	panic("Key \"" + key + "\" does not exist")
}

// GetString returns the value associated with the key as a string.
// GetString以字符串的形式返回与键关联的值。
func (c *Context) GetString(key string) (s string) {
	if val, ok := c.Get(key); ok && val != nil {
		s, _ = val.(string)
	}
	return
}

// GetBool returns the value associated with the key as a boolean.
// GetBool以布尔值的形式返回与键关联的值。
func (c *Context) GetBool(key string) (b bool) {
	if val, ok := c.Get(key); ok && val != nil {
		b, _ = val.(bool)
	}
	return
}

// GetInt returns the value associated with the key as an integer.
// GetInt以整数形式返回与键关联的值。
func (c *Context) GetInt(key string) (i int) {
	if val, ok := c.Get(key); ok && val != nil {
		i, _ = val.(int)
	}
	return
}

// GetInt64 returns the value associated with the key as an integer.
// GetInt64以整数形式返回与键关联的值。
func (c *Context) GetInt64(key string) (i64 int64) {
	if val, ok := c.Get(key); ok && val != nil {
		i64, _ = val.(int64)
	}
	return
}

// GetUint returns the value associated with the key as an unsigned integer.
// GetUint以无符号整数的形式返回与键关联的值。
func (c *Context) GetUint(key string) (ui uint) {
	if val, ok := c.Get(key); ok && val != nil {
		ui, _ = val.(uint)
	}
	return
}

// GetUint64 returns the value associated with the key as an unsigned integer.
// GetUint64以无符号整数的形式返回与键关联的值。
func (c *Context) GetUint64(key string) (ui64 uint64) {
	if val, ok := c.Get(key); ok && val != nil {
		ui64, _ = val.(uint64)
	}
	return
}

// GetFloat64 returns the value associated with the key as a float64.
// GetFloat64将与键关联的值作为float64返回。
func (c *Context) GetFloat64(key string) (f64 float64) {
	if val, ok := c.Get(key); ok && val != nil {
		f64, _ = val.(float64)
	}
	return
}

// GetTime returns the value associated with the key as time.
// GetTime将与键关联的值作为时间返回。
func (c *Context) GetTime(key string) (t time.Time) {
	if val, ok := c.Get(key); ok && val != nil {
		t, _ = val.(time.Time)
	}
	return
}

// GetDuration returns the value associated with the key as a duration.
// GetDuration返回与键关联的值作为持续时间。
func (c *Context) GetDuration(key string) (d time.Duration) {
	if val, ok := c.Get(key); ok && val != nil {
		d, _ = val.(time.Duration)
	}
	return
}

// GetStringSlice returns the value associated with the key as a slice of strings.
// GetStringSlice以字符串片段的形式返回与键关联的值。
func (c *Context) GetStringSlice(key string) (ss []string) {
	if val, ok := c.Get(key); ok && val != nil {
		ss, _ = val.([]string)
	}
	return
}

// GetStringMap returns the value associated with the key as a map of interfaces.
// GetStringMap以接口映射的形式返回与键关联的值。
func (c *Context) GetStringMap(key string) (sm map[string]any) {
	if val, ok := c.Get(key); ok && val != nil {
		sm, _ = val.(map[string]any)
	}
	return
}

// GetStringMapString returns the value associated with the key as a map of strings.
// GetStringMapString以字符串映射的形式返回与键关联的值。
func (c *Context) GetStringMapString(key string) (sms map[string]string) {
	if val, ok := c.Get(key); ok && val != nil {
		sms, _ = val.(map[string]string)
	}
	return
}

// GetStringMapStringSlice returns the value associated with the key as a map to a slice of strings.
// GetStringMapStringSlice将与键关联的值作为字符串切片的映射返回。
func (c *Context) GetStringMapStringSlice(key string) (smss map[string][]string) {
	if val, ok := c.Get(key); ok && val != nil {
		smss, _ = val.(map[string][]string)
	}
	return
}

/************************************/
/************ INPUT DATA ************/
/************************************/

// Param returns the value of the URL param.
// Param返回URL参数的值。
// It is a shortcut for c.Params.ByName(key)
// 这是c.Params.ByName（键）的快捷方式
//
//	router.GET("/user/:id", func(c *gin.Context) {
//	    // a GET request to /user/john
//	    id := c.Param("id") // id == "/john"
//	    // a GET request to /user/john/
//	    id := c.Param("id") // id == "/john/"
//	})
func (c *Context) Param(key string) string {
	return c.Params.ByName(key)
}

// AddParam adds param to context and
// replaces path param key with given value for e2e testing purposes
// AddParam将param添加到上下文中，并将path param键替换为给定值，用于e2e测试
// Example Route: "/user/:id"
// AddParam("id", 1)
// Result: "/user/1"
func (c *Context) AddParam(key, value string) {
	c.Params = append(c.Params, Param{Key: key, Value: value})
}

// Query returns the keyed url query value if it exists,
// otherwise it returns an empty string `("")`.
// Query返回键控url查询值（如果存在），否则返回空字符串`（“”）`。
// It is shortcut for `c.Request.URL.Query().Get(key)`
// 它是c.Request.URL.Query（）.Get（键）的快捷方式
//
//	    GET /path?id=1234&name=Manu&value=
//		   c.Query("id") == "1234"
//		   c.Query("name") == "Manu"
//		   c.Query("value") == ""
//		   c.Query("wtf") == ""
func (c *Context) Query(key string) (value string) {
	value, _ = c.GetQuery(key)
	return
}

// DefaultQuery returns the keyed url query value if it exists,
// otherwise it returns the specified defaultValue string.
// DefaultQuery返回键控的url查询值（如果存在），否则返回指定的defaultValue字符串。
// See: Query() and GetQuery() for further information.
// 请参阅：Query（）和GetQuery（）以获取更多信息。
//
//	GET /?name=Manu&lastname=
//	c.DefaultQuery("name", "unknown") == "Manu"
//	c.DefaultQuery("id", "none") == "none"
//	c.DefaultQuery("lastname", "none") == ""
func (c *Context) DefaultQuery(key, defaultValue string) string {
	if value, ok := c.GetQuery(key); ok {
		return value
	}
	return defaultValue
}

// GetQuery is like Query(), it returns the keyed url query value
// if it exists `(value, true)` (even when the value is an empty string),
// otherwise it returns `("", false)`.
// GetQuery与Query（）类似，如果键控url查询值存在“（value，true）”（即使该值是空字符串），它也会返回该值，否则它会返回“（“”，false）”。
// It is shortcut for `c.Request.URL.Query().Get(key)`
// 它是`c.Request.URL.Query（）.Get（键）的快捷方式`
//
//	GET /?name=Manu&lastname=
//	("Manu", true) == c.GetQuery("name")
//	("", false) == c.GetQuery("id")
//	("", true) == c.GetQuery("lastname")
func (c *Context) GetQuery(key string) (string, bool) {
	if values, ok := c.GetQueryArray(key); ok {
		return values[0], ok
	}
	return "", false
}

// QueryArray returns a slice of strings for a given query key.
// QueryArray为给定的查询键返回一段字符串。
// The length of the slice depends on the number of params with the given key.
// 切片的长度取决于具有给定键的参数的数量。
func (c *Context) QueryArray(key string) (values []string) {
	values, _ = c.GetQueryArray(key)
	return
}

func (c *Context) initQueryCache() {
	if c.queryCache == nil {
		if c.Request != nil {
			c.queryCache = c.Request.URL.Query()
		} else {
			c.queryCache = url.Values{}
		}
	}
}

// GetQueryArray returns a slice of strings for a given query key, plus
// a boolean value whether at least one value exists for the given key.
// GetQueryArray为给定的查询键返回一段字符串，再加上一个布尔值（给定键是否至少存在一个值）。
func (c *Context) GetQueryArray(key string) (values []string, ok bool) {
	c.initQueryCache()
	values, ok = c.queryCache[key]
	return
}

// QueryMap returns a map for a given query key.
// QueryMap返回给定查询键的映射。
func (c *Context) QueryMap(key string) (dicts map[string]string) {
	dicts, _ = c.GetQueryMap(key)
	return
}

// GetQueryMap returns a map for a given query key, plus a boolean value
// whether at least one value exists for the given key.
// GetQueryMap返回给定查询键的映射，再加上布尔值（给定键是否至少存在一个值）。
func (c *Context) GetQueryMap(key string) (map[string]string, bool) {
	c.initQueryCache()
	return c.get(c.queryCache, key)
}

// PostForm returns the specified key from a POST urlencoded form or multipart form
// when it exists, otherwise it returns an empty string `("")`.
// PostForm从POST URL编码的表单或多部分表单返回指定的键（如果存在），否则返回空字符串`（“”）`。
func (c *Context) PostForm(key string) (value string) {
	value, _ = c.GetPostForm(key)
	return
}

// DefaultPostForm returns the specified key from a POST urlencoded form or multipart form
// when it exists, otherwise it returns the specified defaultValue string.
// DefaultPostForm从POST url编码的表单或多部分表单（如果存在）返回指定的键，否则返回指定的defaultValue字符串。
// See: PostForm() and GetPostForm() for further information.
// 有关更多信息，请参阅：PostForm()和GetPostForm()。
func (c *Context) DefaultPostForm(key, defaultValue string) string {
	if value, ok := c.GetPostForm(key); ok {
		return value
	}
	return defaultValue
}

// GetPostForm is like PostForm(key). It returns the specified key from a POST urlencoded
// form or multipart form when it exists `(value, true)` (even when the value is an empty string),
// otherwise it returns ("", false).
// GetPostForm类似于PostForm（键）。当指定的键存在“（value，true）”（即使该值是空字符串）时，它会从POST url编码的窗体或多部分窗体返回指定的键，否则它会返回（“”，false）。
// For example, during a PATCH request to update the user's email:
// 例如，在PATCH请求更新用户电子邮件期间：
//
//	    email=mail@example.com  -->  ("mail@example.com", true) := GetPostForm("email") // set email to "mail@example.com"
//		   email=                  -->  ("", true) := GetPostForm("email") // set email to ""
//	                            -->  ("", false) := GetPostForm("email") // do nothing with email
func (c *Context) GetPostForm(key string) (string, bool) {
	if values, ok := c.GetPostFormArray(key); ok {
		return values[0], ok
	}
	return "", false
}

// PostFormArray returns a slice of strings for a given form key.
// PostFormArray为给定的表单键返回一段字符串。
// The length of the slice depends on the number of params with the given key.
// 切片的长度取决于具有给定键的参数的数量。
func (c *Context) PostFormArray(key string) (values []string) {
	values, _ = c.GetPostFormArray(key)
	return
}

func (c *Context) initFormCache() {
	if c.formCache == nil {
		c.formCache = make(url.Values)
		req := c.Request
		if err := req.ParseMultipartForm(c.engine.MaxMultipartMemory); err != nil {
			if !errors.Is(err, http.ErrNotMultipart) {
				debugPrint("error on parse multipart form array: %v", err)
			}
		}
		c.formCache = req.PostForm
	}
}

// GetPostFormArray returns a slice of strings for a given form key, plus
// a boolean value whether at least one value exists for the given key.
// GetPostFormArray为给定的表单键返回一片字符串，再加上一个布尔值（给定键是否至少存在一个值）。
func (c *Context) GetPostFormArray(key string) (values []string, ok bool) {
	c.initFormCache()
	values, ok = c.formCache[key]
	return
}

// PostFormMap returns a map for a given form key.
// PostFormMap返回给定表单键的映射。
func (c *Context) PostFormMap(key string) (dicts map[string]string) {
	dicts, _ = c.GetPostFormMap(key)
	return
}

// GetPostFormMap returns a map for a given form key, plus a boolean value
// whether at least one value exists for the given key.
// GetPostFormMap返回给定表单键的映射，再加上布尔值（给定键是否至少存在一个值）。
func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
	c.initFormCache()
	return c.get(c.formCache, key)
}

// get is an internal method and returns a map which satisfies conditions.
// get是一个内部方法，它返回一个满足条件的映射。
func (c *Context) get(m map[string][]string, key string) (map[string]string, bool) {
	dicts := make(map[string]string)
	exist := false
	for k, v := range m {
		if i := strings.IndexByte(k, '['); i >= 1 && k[0:i] == key {
			if j := strings.IndexByte(k[i+1:], ']'); j >= 1 {
				exist = true
				dicts[k[i+1:][:j]] = v[0]
			}
		}
	}
	return dicts, exist
}

// FormFile returns the first file for the provided form key.
// FormFile返回所提供表单密钥的第一个文件。
func (c *Context) FormFile(name string) (*multipart.FileHeader, error) {
	if c.Request.MultipartForm == nil {
		if err := c.Request.ParseMultipartForm(c.engine.MaxMultipartMemory); err != nil {
			return nil, err
		}
	}
	f, fh, err := c.Request.FormFile(name)
	if err != nil {
		return nil, err
	}
	f.Close()
	return fh, err
}

// MultipartForm is the parsed multipart form, including file uploads.
// MultipartForm是经过解析的多部分表单，包括文件上传。
func (c *Context) MultipartForm() (*multipart.Form, error) {
	err := c.Request.ParseMultipartForm(c.engine.MaxMultipartMemory)
	return c.Request.MultipartForm, err
}

// SaveUploadedFile uploads the form file to specific dst.
// SaveUploadedFile将表单文件上载到特定的dst。
func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error {
	src, err := file.Open()
	if err != nil {
		return err
	}
	defer src.Close()

	if err = os.MkdirAll(filepath.Dir(dst), 0750); err != nil {
		return err
	}

	out, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, src)
	return err
}

// Bind checks the Method and Content-Type to select a binding engine automatically,
// Depending on the "Content-Type" header different bindings are used, for example:
// 绑定检查方法和内容类型以自动选择绑定引擎。根据“内容类型”标头，将使用不同的绑定，例如：
//
//	"application/json" --> JSON binding
//	"application/xml"  --> XML binding
//
// It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
// It decodes the json payload into the struct specified as a pointer.
// 如果Content-Type==“application/JSON”，则使用JSON或XML作为JSON输入，它将请求的正文解析为JSON。它将JSON有效载荷解码为指定为指针的结构。
// It writes a 400 error and sets Content-Type header "text/plain" in the response if input is not valid.
// 如果输入无效，它会写入一个400错误，并在响应中设置Content-Type标头“text/plain”。
func (c *Context) Bind(obj any) error {
	b := binding.Default(c.Request.Method, c.ContentType())
	return c.MustBindWith(obj, b)
}

// BindJSON is a shortcut for c.MustBindWith(obj, binding.JSON).
// BindJSON是c.MustBindWith（obj，binding.JSON）的快捷方式。
func (c *Context) BindJSON(obj any) error {
	return c.MustBindWith(obj, binding.JSON)
}

// BindXML is a shortcut for c.MustBindWith(obj, binding.BindXML).
// BindXML是c.MustBindWith（obj，binding.BindXML）的快捷方式。
func (c *Context) BindXML(obj any) error {
	return c.MustBindWith(obj, binding.XML)
}

// BindQuery is a shortcut for c.MustBindWith(obj, binding.Query).
// BindQuery是c.MustBindWith（obj，binding.Query）的快捷方式。
func (c *Context) BindQuery(obj any) error {
	return c.MustBindWith(obj, binding.Query)
}

// BindYAML is a shortcut for c.MustBindWith(obj, binding.YAML).
// BindYAML是c.MustBindWith（obj，binding.YAML）的快捷方式。
func (c *Context) BindYAML(obj any) error {
	return c.MustBindWith(obj, binding.YAML)
}

// BindTOML is a shortcut for c.MustBindWith(obj, binding.TOML).
// BindTOML是c.MustBindWith（obj，binding.TOML）的快捷方式。
func (c *Context) BindTOML(obj interface{}) error {
	return c.MustBindWith(obj, binding.TOML)
}

// BindHeader is a shortcut for c.MustBindWith(obj, binding.Header).
// BindHeader是c.MustBindWith（obj，binding.Header）的快捷方式。
func (c *Context) BindHeader(obj any) error {
	return c.MustBindWith(obj, binding.Header)
}

// BindUri binds the passed struct pointer using binding.Uri.
// BindUri使用binding.Uri绑定传递的结构指针。
// It will abort the request with HTTP 400 if any error occurs.
// 如果出现任何错误，它将使用HTTP 400中止请求。
func (c *Context) BindUri(obj any) error {
	if err := c.ShouldBindUri(obj); err != nil {
		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) //nolint: errcheck
		return err
	}
	return nil
}

// MustBindWith binds the passed struct pointer using the specified binding engine.
// MustBindWith使用指定的绑定引擎绑定传递的结构指针。
// It will abort the request with HTTP 400 if any error occurs.
// See the binding package.
// 如果出现任何错误，它将使用HTTP 400中止请求。请参阅绑定包。
func (c *Context) MustBindWith(obj any, b binding.Binding) error {
	if err := c.ShouldBindWith(obj, b); err != nil {
		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) //nolint: errcheck
		return err
	}
	return nil
}

// ShouldBind checks the Method and Content-Type to select a binding engine automatically,
// Depending on the "Content-Type" header different bindings are used, for example:
// ShouldBind检查方法和内容类型以自动选择绑定引擎。根据“内容类型”标头，将使用不同的绑定，例如：
//
//	"application/json" --> JSON binding
//	"application/xml"  --> XML binding
//
// It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
// 如果Content-Type==“application/JSON”使用JSON或XML作为JSON输入，它会将请求的正文解析为JSON。
// It decodes the json payload into the struct specified as a pointer.
// 它将json有效载荷解码为指定为指针的结构。
// Like c.Bind() but this method does not set the response status code to 400 or abort if input is not valid.
// 类似于c.Bind（），但此方法不会将响应状态代码设置为400，也不会在输入无效时中止。
func (c *Context) ShouldBind(obj any) error {
	b := binding.Default(c.Request.Method, c.ContentType())
	return c.ShouldBindWith(obj, b)
}

// ShouldBindJSON is a shortcut for c.ShouldBindWith(obj, binding.JSON).
// ShouldBindJSON是c.ShouldBindWith（obj，binding.JSON）的快捷方式。
func (c *Context) ShouldBindJSON(obj any) error {
	return c.ShouldBindWith(obj, binding.JSON)
}

// ShouldBindXML is a shortcut for c.ShouldBindWith(obj, binding.XML).
// ShouldBindXML是c.ShouldBindWith（obj，binding.XML）的快捷方式。
func (c *Context) ShouldBindXML(obj any) error {
	return c.ShouldBindWith(obj, binding.XML)
}

// ShouldBindQuery is a shortcut for c.ShouldBindWith(obj, binding.Query).
// ShouldBindQuery是c.ShouldBindWith（obj，binding.Query）的快捷方式。
func (c *Context) ShouldBindQuery(obj any) error {
	return c.ShouldBindWith(obj, binding.Query)
}

// ShouldBindYAML is a shortcut for c.ShouldBindWith(obj, binding.YAML).
// ShouldBindYAML是c.ShouldBindWith（obj，binding.YAML）的快捷方式。
func (c *Context) ShouldBindYAML(obj any) error {
	return c.ShouldBindWith(obj, binding.YAML)
}

// ShouldBindTOML is a shortcut for c.ShouldBindWith(obj, binding.TOML).
// ShouldBindTOML是c.ShouldBindWith（obj，binding.TOML）的快捷方式。
func (c *Context) ShouldBindTOML(obj interface{}) error {
	return c.ShouldBindWith(obj, binding.TOML)
}

// ShouldBindHeader is a shortcut for c.ShouldBindWith(obj, binding.Header).
// ShouldBindHeader是c.ShouldBindWith（obj，binding.Header）的快捷方式。
func (c *Context) ShouldBindHeader(obj any) error {
	return c.ShouldBindWith(obj, binding.Header)
}

// ShouldBindUri binds the passed struct pointer using the specified binding engine.
// ShouldBindUri使用指定的绑定引擎绑定传递的结构指针。
func (c *Context) ShouldBindUri(obj any) error {
	m := make(map[string][]string)
	for _, v := range c.Params {
		m[v.Key] = []string{v.Value}
	}
	return binding.Uri.BindUri(m, obj)
}

// ShouldBindWith binds the passed struct pointer using the specified binding engine.
// ShouldBindWith使用指定的绑定引擎绑定传递的结构指针。
// See the binding package. 请参阅绑定包。
func (c *Context) ShouldBindWith(obj any, b binding.Binding) error {
	return b.Bind(c.Request, obj)
}

// ShouldBindBodyWith is similar with ShouldBindWith, but it stores the request
// body into the context, and reuse when it is called again.
// ShouldBindBodyWith与ShouldBindWith类似，但它将请求正文存储到上下文中，并在再次调用时重用。
// NOTE: This method reads the body before binding. So you should use
// ShouldBindWith for better performance if you need to call only once.
// 注意：此方法在绑定之前读取正文。因此，如果只需要调用一次，则应该使用ShouldBindWith以获得更好的性能。
func (c *Context) ShouldBindBodyWith(obj any, bb binding.BindingBody) (err error) {
	var body []byte
	if cb, ok := c.Get(BodyBytesKey); ok {
		if cbb, ok := cb.([]byte); ok {
			body = cbb
		}
	}
	if body == nil {
		body, err = io.ReadAll(c.Request.Body)
		if err != nil {
			return err
		}
		c.Set(BodyBytesKey, body)
	}
	return bb.BindBody(body, obj)
}

// ClientIP implements one best effort algorithm to return the real client IP.
// ClientIP实现了一种尽力而为的算法来返回真实的客户端IP。
// It calls c.RemoteIP() under the hood, to check if the remote IP is a trusted proxy or not.
// 它在后台调用c.RemoteIP（），以检查远程IP是否是受信任的代理。
// If it is it will then try to parse the headers defined in Engine.RemoteIPHeaders (defaulting to [X-Forwarded-For, X-Real-Ip]).
// 如果是，它将尝试解析Engine.RemoteIPHeaders中定义的标头（默认为[X-Forwarded-For，X-Real-Ip]）。
// If the headers are not syntactically valid OR the remote IP does not correspond to a trusted proxy,
// the remote IP (coming from Request.RemoteAddr) is returned.
// 如果标头在语法上无效，或者远程IP不对应于受信任的代理，则返回远程IP（来自Request.RRemoteAddr）。
func (c *Context) ClientIP() string {
	// Check if we're running on a trusted platform, continue running backwards if error
	// 检查我们是否在受信任的平台上运行，如果出现错误，请继续向后运行
	if c.engine.TrustedPlatform != "" {
		// Developers can define their own header of Trusted Platform or use predefined constants
		// 开发人员可以定义自己的Trusted Platform标头或使用预定义的常量
		if addr := c.requestHeader(c.engine.TrustedPlatform); addr != "" {
			return addr
		}
	}

	// Legacy "AppEngine" flag
	if c.engine.AppEngine {
		log.Println(`The AppEngine flag is going to be deprecated. Please check issues #2723 and #2739 and use 'TrustedPlatform: gin.PlatformGoogleAppEngine' instead.`)
		if addr := c.requestHeader("X-Appengine-Remote-Addr"); addr != "" {
			return addr
		}
	}

	// It also checks if the remoteIP is a trusted proxy or not.
	// 它还检查remoteIP是否是受信任的代理。
	// In order to perform this validation, it will see if the IP is contained within at least one of the CIDR blocks
	// defined by Engine.SetTrustedProxies()
	// 为了执行此验证，它将查看IP是否包含在Engine.SetTrustedProxy（）定义的至少一个CIDR块中
	remoteIP := net.ParseIP(c.RemoteIP())
	if remoteIP == nil {
		return ""
	}
	trusted := c.engine.isTrustedProxy(remoteIP)

	if trusted && c.engine.ForwardedByClientIP && c.engine.RemoteIPHeaders != nil {
		for _, headerName := range c.engine.RemoteIPHeaders {
			ip, valid := c.engine.validateHeader(c.requestHeader(headerName))
			if valid {
				return ip
			}
		}
	}
	return remoteIP.String()
}

// RemoteIP parses the IP from Request.RemoteAddr, normalizes and returns the IP (without the port).
// RemoteIP从Request.RemoteAddr解析IP，规范化并返回IP（不带端口）。
func (c *Context) RemoteIP() string {
	ip, _, err := net.SplitHostPort(strings.TrimSpace(c.Request.RemoteAddr))
	if err != nil {
		return ""
	}
	return ip
}

// ContentType returns the Content-Type header of the request.
// ContentType返回请求的Content-Type标头。
func (c *Context) ContentType() string {
	return filterFlags(c.requestHeader("Content-Type"))
}

// IsWebsocket returns true if the request headers indicate that a websocket
// handshake is being initiated by the client.
// 如果请求标头指示客户端正在启动websocket握手，则IsWebsocket返回true。
func (c *Context) IsWebsocket() bool {
	if strings.Contains(strings.ToLower(c.requestHeader("Connection")), "upgrade") &&
		strings.EqualFold(c.requestHeader("Upgrade"), "websocket") {
		return true
	}
	return false
}

func (c *Context) requestHeader(key string) string {
	return c.Request.Header.Get(key)
}

/************************************/
/******** RESPONSE RENDERING ********/
/************************************/

// bodyAllowedForStatus is a copy of http.bodyAllowedForStatus non-exported function.
// bodyAllowedForStatus是http.bodyAllowedForStatus非导出函数的副本。
func bodyAllowedForStatus(status int) bool {
	switch {
	case status >= 100 && status <= 199:
		return false
	case status == http.StatusNoContent:
		return false
	case status == http.StatusNotModified:
		return false
	}
	return true
}

// Status sets the HTTP response code.
// 状态设置HTTP响应代码。
func (c *Context) Status(code int) {
	c.Writer.WriteHeader(code)
}

// Header is an intelligent shortcut for c.Writer.Header().Set(key, value).
// Header是c.Writer.Header（）.Set（键，值）的智能快捷方式。
// It writes a header in the response.
// 它在响应中写入一个标头。
// If value == "", this method removes the header `c.Writer.Header().Del(key)`
// 如果value=“”，此方法将删除标头`c.Writer.header（）.Del（键）
func (c *Context) Header(key, value string) {
	if value == "" {
		c.Writer.Header().Del(key)
		return
	}
	c.Writer.Header().Set(key, value)
}

// GetHeader returns value from request headers.
// GetHeader从请求标头返回值。
func (c *Context) GetHeader(key string) string {
	return c.requestHeader(key)
}

// GetRawData returns stream data.
// GetRawData返回流数据。
func (c *Context) GetRawData() ([]byte, error) {
	return io.ReadAll(c.Request.Body)
}

// SetSameSite with cookie
// 带有cookie的SetNameSite
func (c *Context) SetSameSite(samesite http.SameSite) {
	c.sameSite = samesite
}

// SetCookie adds a Set-Cookie header to the ResponseWriter's headers.
// SetCookie将SetCookie标头添加到ResponseWriter的标头中。
// The provided cookie must have a valid Name. Invalid cookies may be
// silently dropped.
// 提供的cookie必须具有有效的名称。无效的cookie可能会被静默删除。
func (c *Context) SetCookie(name, value string, maxAge int, path, domain string, secure, httpOnly bool) {
	if path == "" {
		path = "/"
	}
	http.SetCookie(c.Writer, &http.Cookie{
		Name:     name,
		Value:    url.QueryEscape(value),
		MaxAge:   maxAge,
		Path:     path,
		Domain:   domain,
		SameSite: c.sameSite,
		Secure:   secure,
		HttpOnly: httpOnly,
	})
}

// Cookie returns the named cookie provided in the request or
// ErrNoCookie if not found. And return the named cookie is unescaped.
// Cookie返回请求中提供的命名Cookie，如果未找到，则返回ErrNoCookie。并返回未跳过的命名cookie。
// If multiple cookies match the given name, only one cookie will
// be returned.
// 如果多个cookie与给定的名称匹配，则只返回一个cookie。
func (c *Context) Cookie(name string) (string, error) {
	cookie, err := c.Request.Cookie(name)
	if err != nil {
		return "", err
	}
	val, _ := url.QueryUnescape(cookie.Value)
	return val, nil
}

// Render writes the response headers and calls render.Render to render data.
// Render写入响应标头并调用Render。Render以渲染数据。
func (c *Context) Render(code int, r render.Render) {
	c.Status(code)

	if !bodyAllowedForStatus(code) {
		r.WriteContentType(c.Writer)
		c.Writer.WriteHeaderNow()
		return
	}

	if err := r.Render(c.Writer); err != nil {
		// Pushing error to c.Errors
		_ = c.Error(err)
		c.Abort()
	}
}

// HTML renders the HTTP template specified by its file name.
// HTML呈现由其文件名指定的HTTP模板。
// It also updates the HTTP code and sets the Content-Type as "text/html".
// 它还更新HTTP代码，并将内容类型设置为“text/html”。
// See http://golang.org/doc/articles/wiki/
func (c *Context) HTML(code int, name string, obj any) {
	instance := c.engine.HTMLRender.Instance(name, obj)
	c.Render(code, instance)
}

// IndentedJSON serializes the given struct as pretty JSON (indented + endlines) into the response body.
// 缩进JSON将给定的结构作为漂亮的JSON（缩进+换行）序列化到响应体中。
// It also sets the Content-Type as "application/json".
// 它还将内容类型设置为“application/json”。
// WARNING: we recommend using this only for development purposes since printing pretty JSON is
// more CPU and bandwidth consuming. Use Context.JSON() instead.
// 警告：我们建议仅将其用于开发目的，因为打印漂亮的JSON会消耗更多的CPU和带宽。请改用Context.JSON（）。
func (c *Context) IndentedJSON(code int, obj any) {
	c.Render(code, render.IndentedJSON{Data: obj})
}

// SecureJSON serializes the given struct as Secure JSON into the response body.
// SecureJSON将给定的结构作为安全JSON序列化到响应体中。
// Default prepends "while(1)," to response body if the given struct is array values.
// 如果给定的结构是数组值，则默认在响应体前面加上“while（1）”。
// It also sets the Content-Type as "application/json".
// 它还将内容类型设置为“application/json”。
func (c *Context) SecureJSON(code int, obj any) {
	c.Render(code, render.SecureJSON{Prefix: c.engine.secureJSONPrefix, Data: obj})
}

// JSONP serializes the given struct as JSON into the response body.
// JSONP将给定的结构作为JSON序列化到响应体中。
// It adds padding to response body to request data from a server residing in a different domain than the client.
// 它向响应主体添加填充，以便从驻留在与客户端不同的域中的服务器请求数据。
// It also sets the Content-Type as "application/javascript".
// 它还将内容类型设置为“application/javascript”。
func (c *Context) JSONP(code int, obj any) {
	callback := c.DefaultQuery("callback", "")
	if callback == "" {
		c.Render(code, render.JSON{Data: obj})
		return
	}
	c.Render(code, render.JsonpJSON{Callback: callback, Data: obj})
}

// JSON serializes the given struct as JSON into the response body.
// JSON将给定的结构作为JSON序列化到响应体中。
// It also sets the Content-Type as "application/json".
// 它还将内容类型设置为“application/json”。
func (c *Context) JSON(code int, obj any) {
	c.Render(code, render.JSON{Data: obj})
}

// AsciiJSON serializes the given struct as JSON into the response body with unicode to ASCII string.
// AsciJSON将给定的结构作为JSON序列化到具有unicode到ASCII字符串的响应体中。
// It also sets the Content-Type as "application/json".
// 它还将内容类型设置为“application/json”。
func (c *Context) AsciiJSON(code int, obj any) {
	c.Render(code, render.AsciiJSON{Data: obj})
}

// PureJSON serializes the given struct as JSON into the response body.
// PureJSON将给定的结构作为JSON序列化到响应体中。
// PureJSON, unlike JSON, does not replace special html characters with their unicode entities.
// 与JSON不同，PureJSON不会用其unicode实体替换特殊的html字符。
func (c *Context) PureJSON(code int, obj any) {
	c.Render(code, render.PureJSON{Data: obj})
}

// XML serializes the given struct as XML into the response body.
// XML将给定的结构作为XML序列化到响应体中。
// It also sets the Content-Type as "application/xml".
// 它还将内容类型设置为“application/xml”。
func (c *Context) XML(code int, obj any) {
	c.Render(code, render.XML{Data: obj})
}

// YAML serializes the given struct as YAML into the response body.
// YAML将给定的结构作为YAML序列化到响应体中。
func (c *Context) YAML(code int, obj any) {
	c.Render(code, render.YAML{Data: obj})
}

// TOML serializes the given struct as TOML into the response body.
// TOML将给定的结构作为TOML序列化到响应体中。
func (c *Context) TOML(code int, obj interface{}) {
	c.Render(code, render.TOML{Data: obj})
}

// ProtoBuf serializes the given struct as ProtoBuf into the response body.
// ProtoBuf将给定的结构序列化为响应体中的ProtoBuf。
func (c *Context) ProtoBuf(code int, obj any) {
	c.Render(code, render.ProtoBuf{Data: obj})
}

// String writes the given string into the response body.
// 字符串将给定的字符串写入响应正文。
func (c *Context) String(code int, format string, values ...any) {
	c.Render(code, render.String{Format: format, Data: values})
}

// Redirect returns an HTTP redirect to the specific location.
// Redirect返回到特定位置的HTTP重定向。
func (c *Context) Redirect(code int, location string) {
	c.Render(-1, render.Redirect{
		Code:     code,
		Location: location,
		Request:  c.Request,
	})
}

// Data writes some data into the body stream and updates the HTTP code.
// Data将一些数据写入主体流并更新HTTP代码。
func (c *Context) Data(code int, contentType string, data []byte) {
	c.Render(code, render.Data{
		ContentType: contentType,
		Data:        data,
	})
}

// DataFromReader writes the specified reader into the body stream and updates the HTTP code.
// DataFromReader将指定的读取器写入主体流并更新HTTP代码。
func (c *Context) DataFromReader(code int, contentLength int64, contentType string, reader io.Reader, extraHeaders map[string]string) {
	c.Render(code, render.Reader{
		Headers:       extraHeaders,
		ContentType:   contentType,
		ContentLength: contentLength,
		Reader:        reader,
	})
}

// File writes the specified file into the body stream in an efficient way.
// File以一种有效的方式将指定的文件写入主体流。
func (c *Context) File(filepath string) {
	http.ServeFile(c.Writer, c.Request, filepath)
}

// FileFromFS writes the specified file from http.FileSystem into the body stream in an efficient way.
// FileFromFS以一种有效的方式将http.FileSystem中的指定文件写入主体流。
func (c *Context) FileFromFS(filepath string, fs http.FileSystem) {
	defer func(old string) {
		c.Request.URL.Path = old
	}(c.Request.URL.Path)

	c.Request.URL.Path = filepath

	http.FileServer(fs).ServeHTTP(c.Writer, c.Request)
}

// FileAttachment writes the specified file into the body stream in an efficient way
// On the client side, the file will typically be downloaded with the given filename
// FileAttachment以一种有效的方式将指定的文件写入主体流。在客户端，通常会使用给定的文件名下载该文件
func (c *Context) FileAttachment(filepath, filename string) {
	if isASCII(filename) {
		c.Writer.Header().Set("Content-Disposition", `attachment; filename="`+filename+`"`)
	} else {
		c.Writer.Header().Set("Content-Disposition", `attachment; filename*=UTF-8''`+url.QueryEscape(filename))
	}
	http.ServeFile(c.Writer, c.Request, filepath)
}

// SSEvent writes a Server-Sent Event into the body stream.
// SSEvent将服务器发送的事件写入主体流。
func (c *Context) SSEvent(name string, message any) {
	c.Render(-1, sse.Event{
		Event: name,
		Data:  message,
	})
}

// Stream sends a streaming response and returns a boolean
// indicates "Is client disconnected in middle of stream"
// Stream发送一个流式响应并返回一个布尔值，指示“客户端是否在流中间断开连接”
func (c *Context) Stream(step func(w io.Writer) bool) bool {
	w := c.Writer
	clientGone := w.CloseNotify()
	for {
		select {
		case <-clientGone:
			return true
		default:
			keepOpen := step(w)
			w.Flush()
			if !keepOpen {
				return false
			}
		}
	}
}

/************************************/
/******** CONTENT NEGOTIATION *******/
/************************************/

// Negotiate contains all negotiations data.
// 协商包含所有协商数据。
type Negotiate struct {
	Offered  []string
	HTMLName string
	HTMLData any
	JSONData any
	XMLData  any
	YAMLData any
	Data     any
	TOMLData any
}

// Negotiate calls different Render according to acceptable Accept format.
// 协商根据可接受的Accept格式调用不同的Render。
func (c *Context) Negotiate(code int, config Negotiate) {
	switch c.NegotiateFormat(config.Offered...) {
	case binding.MIMEJSON:
		data := chooseData(config.JSONData, config.Data)
		c.JSON(code, data)

	case binding.MIMEHTML:
		data := chooseData(config.HTMLData, config.Data)
		c.HTML(code, config.HTMLName, data)

	case binding.MIMEXML:
		data := chooseData(config.XMLData, config.Data)
		c.XML(code, data)

	case binding.MIMEYAML:
		data := chooseData(config.YAMLData, config.Data)
		c.YAML(code, data)

	case binding.MIMETOML:
		data := chooseData(config.TOMLData, config.Data)
		c.TOML(code, data)

	default:
		c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server")) //nolint: errcheck
	}
}

// NegotiateFormat returns an acceptable Accept format.
// NegotiateFormat返回可接受的Accept格式。
func (c *Context) NegotiateFormat(offered ...string) string {
	assert1(len(offered) > 0, "you must provide at least one offer")

	if c.Accepted == nil {
		c.Accepted = parseAccept(c.requestHeader("Accept"))
	}
	if len(c.Accepted) == 0 {
		return offered[0]
	}
	for _, accepted := range c.Accepted {
		for _, offer := range offered {
			// According to RFC 2616 and RFC 2396, non-ASCII characters are not allowed in headers,
			// therefore we can just iterate over the string without casting it into []rune
			// 根据RFC 2616和RFC 2396，标头中不允许使用非ASCII字符，因此我们可以迭代字符串，而不将其转换为[]符文
			i := 0
			for ; i < len(accepted) && i < len(offer); i++ {
				if accepted[i] == '*' || offer[i] == '*' {
					return offer
				}
				if accepted[i] != offer[i] {
					break
				}
			}
			if i == len(accepted) {
				return offer
			}
		}
	}
	return ""
}

// SetAccepted sets Accept header data.
// SetAccepted设置Accept标头数据。
func (c *Context) SetAccepted(formats ...string) {
	c.Accepted = formats
}

/************************************/
/***** GOLANG.ORG/X/NET/CONTEXT *****/
/************************************/

// Deadline returns that there is no deadline (ok==false) when c.Request has no Context.
// 当c.请求没有上下文时，Deadline返回没有截止日期（ok==false）。
func (c *Context) Deadline() (deadline time.Time, ok bool) {
	if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil {
		return
	}
	return c.Request.Context().Deadline()
}

// Done returns nil (chan which will wait forever) when c.Request has no Context.
// 当c.请求没有上下文时，Done返回nil（chan将永远等待）。
func (c *Context) Done() <-chan struct{} {
	if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil {
		return nil
	}
	return c.Request.Context().Done()
}

// Err returns nil when c.Request has no Context.
// 当c.请求没有上下文时，Err返回nil。
func (c *Context) Err() error {
	if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil {
		return nil
	}
	return c.Request.Context().Err()
}

// Value returns the value associated with this context for key, or nil
// if no value is associated with key. Successive calls to Value with
// the same key returns the same result.
// Value为键返回与此上下文关联的值，如果没有值与键关联，则返回nil。使用相同的键连续调用Value将返回相同的结果。
func (c *Context) Value(key any) any {
	if key == 0 {
		return c.Request
	}
	if key == ContextKey {
		return c
	}
	if keyAsString, ok := key.(string); ok {
		if val, exists := c.Get(keyAsString); exists {
			return val
		}
	}
	if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil {
		return nil
	}
	return c.Request.Context().Value(key)
}