http

最新推荐文章于 2023-01-13 11:23:03 发布
最新推荐文章于 2023-01-13 11:23:03 发布
阅读量750 收藏
点赞数
分类专栏： go-插件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39787367/article/details/107451626
版权

http

http包提供了http客户端和服务端的实现

Get，Head，Post和PostForm函数发出http、https的请求

程序在使用完回复后必须关闭回复的主体

Get 请求

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aPa6XFnQ-1595164545455)(net–http.assets/1588555382207.png)]

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    res,err:=http.Get("https://www.baidu.com")
    if err !=nil{
        panic(err)
	}
	fmt.Println(res)
    defer res.Body.Close()
    body, err := ioutil.ReadAll(res.Body)
    fmt.Println(string(body))
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-29HUblBH-1595164545457)(net–http.assets/1588555620147.png)]

ioutil.ReadAll

我们看到了，如果用ioutil.ReadAll来读取即使只有1byte也会申请512byte，如果数据量大的话浪费的更多每次都会申请512+2*cap(b.buf)，假如我们有1025byte那么它就会申请3584byte，浪费了2倍还多。
这在比如http大量请求时轻则导致内存浪费严重，重则导致内存泄漏影响业务。

http.Client 客户端请求添加header信息

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

//发起client 请求，并添加header信息
func main() {
    client:=&http.Client{}
    res,err:=http.NewRequest("GET","https://www.baidu.com",nil)
	res.Header.Add("User-Agent", 
	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36")
    resp,err:=client.Do(res)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l2Qq4PlO-1595164545458)(net–http.assets/1588555838508.png)]

访问指定路径 http.Dir

package main

import "net/http"

func main() {
　　//设置访问路由
    http.Handle("/",http.FileServer(http.Dir("./")))
    http.ListenAndServe(":8080",nil)
}

设置cookie 和请求头 http.Cookie

package main

import (
    "bufio"
    "fmt"
    "github.com/axgle/mahonia"
    "golang.org/x/net/html/charset"
    "golang.org/x/text/encoding"
    "io"
    "io/ioutil"
    "net/http"
    "strconv"
)

func main() {
    client := &http.Client{}
    request, err := http.NewRequest("GET", "http://www.baidu.com", nil)
    if err != nil {
        fmt.Println(err)
    }
    //建立cookie对象
    cookie := &http.Cookie{Name: "maple", Value: strconv.Itoa(123)}
    request.AddCookie(cookie) //向request中添加cookie

    //设置request的header
    request.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3")
    request.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
    request.Header.Set("Cache-Control", "no-cache")
    request.Header.Set("Connection", "keep-alive")

    response, err := client.Do(request)
    if err != nil {
        fmt.Println(err)
        return
    }
    e:=determineEncoding(response.Body)
    fmt.Println("当前编码：",e)

    defer response.Body.Close()
    if response.StatusCode == 200 {
        r, err := ioutil.ReadAll(response.Body)
        if err != nil {
            fmt.Println(err)
        }


        //编码转换，如编码不正确可转成指定编码
        srcCoder :=mahonia.NewEncoder("utf-8")
        res:=srcCoder.ConvertString(string(r))

        fmt.Println(res)
    }
}

//编码检测
func determineEncoding(r io.Reader) encoding.Encoding  {
    bytes, err := bufio.NewReader(r).Peek(1024)
    if err != nil {
        panic(err)
    }
    e, _, _ := charset.DetermineEncoding(bytes, "")
    return e
}

路由规则设置 http.HandleFunc

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

//HandleFunc注册一个处理器函数handler和对应的模式pattern（注册到DefaultServeMux）。ServeMux的文档解释了模式的匹配机制。

	// uri   回调函数
	http.HandleFunc("/", sayhelloName) //设置访问的路由
	err := http.ListenAndServe(":9090", nil) //设置监听的端口
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}

HTTP包默认的路由器：DefaultServeMux

https://blog.csdn.net/linkvivi/article/details/80250602

HTTP 请求路由器 servMux

ServrMux 本质上是一个 HTTP 请求路由器（或者叫多路复用器，Multiplexor）。它把收到的请求与一组预先定义的 URL 路径列表做对比，然后在匹配到路径的时候调用关联的处理器（Handler）。

**处理器（Handler）**负责输出HTTP响应的头和正文。任何满足了http.Handler接口的对象都可作为一个处理器。通俗的说，对象只要有个如下签名的ServeHTTP方法即可：

ServeHTTP(http.ResponseWriter, *http.Request)

package main

import (
  "log"
  "net/http"
)

func main() {
  mux := http.NewServeMux()

  rh := http.RedirectHandler("http://example.org", 307)
  mux.Handle("/foo", rh)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

  • 在 main 函数中我们只用了 http.NewServeMux 函数来创建一个空的 ServeMux。

  • 然后我们使用 http.RedirectHandler 函数创建了一个新的处理器，这个处理器会对收到的所有请求，都执行307重定向操作到 http://example.org。

  • 接下来我们使用 ServeMux.Handle 函数将处理器注册到新创建的 ServeMux，所以它在 URL 路径/foo 上收到所有的请求都交给这个处理器。

  • 最后我们创建了一个新的服务器，并通过 http.ListenAndServe 函数监听所有进入的请求，通过传递刚才创建的 ServeMux来为请求去匹配对应处理器。

然后在浏览器中访问 http://localhost:3000/foo，你应该能发现请求已经成功的重定向了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6U68PaFy-1595164545459)(net–http.assets/1588557110497.png)]

明察秋毫的你应该能注意到一些有意思的事情：ListenAndServer 的函数签名是 ListenAndServe(addr string, handler Handler) ，但是第二个参数我们传递的是个 ServeMux。

我们之所以能这么做，是因为 ServeMux 也有 ServeHTTP 方法，因此它也是个合法的 Handler。

对我来说，将 ServerMux 用作一个特殊的Handler是一种简化。它不是自己输出响应而是将请求传递给注册到它的其他 Handler。这乍一听起来不是什么明显的飞跃 - 但在 Go 中将 Handler 链在一起是非常普遍的用法。

自定义路由转换器

package main

import (
  "log"
  "net/http"
  "time"
)

type timeHandler struct {
  format string
}
	//SerceHtpp 是 Handle的接口中的方法的实现，所有Handle作转发的时候，实现了这个接口的会自动触发
func (th *timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  tm := time.Now().Format(th.format)
  w.Write([]byte("The time is: " + tm))
}

func main() {
  mux := http.NewServeMux()

  th := &timeHandler{format: time.RFC1123}
  mux.Handle("/time", th)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0fJwPXIH-1595164545460)(net–http.assets/1588558608652.png)]

main函数中，我们像初始化一个常规的结构体一样，初始化了timeHandler，用 & 符号获得了其地址。随后，像之前的例子一样，我们使用 mux.Handle 函数来将其注册到 ServerMux。

现在当我们运行这个应用，ServerMux 将会将任何对 /time的请求直接交给 timeHandler.ServeHTTP 方法处理。

访问一下这个地址看一下效果：http://localhost:3000/time 。

注意我们可以在多个路由中轻松的复用 timeHandler：

func main() {
  mux := http.NewServeMux()

  th1123 := &timeHandler{format: time.RFC1123}
  mux.Handle("/time/rfc1123", th1123)

  th3339 := &timeHandler{format: time.RFC3339}
  mux.Handle("/time/rfc3339", th3339)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

自定义 处理函 http.HandlerFunc(timeHandler)

将函数作为处理器

对于简单的情况（比如上面的例子），定义个新的有 ServerHTTP 方法的自定义类型有些累赘。我们看一下另外一种方式，我们借助 http.HandlerFunc 类型来让一个常规函数满足作为一个 Handler 接口的条件。

任何有 func(http.ResponseWriter, *http.Request) 签名的函数都能转化为一个 HandlerFunc 类型。这很有用，因为 HandlerFunc 对象内置了 ServeHTTP 方法，后者可以聪明又方便的调用我们最初提供的函数内容。

如果你听起来还有些困惑，可以尝试看一下[相关的源代码]http://golang.org/src/pkg/net/http/server.go?s=35455:35502#L1221()。你将会看到让一个函数对象满足 Handler 接口是非常简洁优雅的。

让我们使用这个技术重新实现一遍timeHandler应用：

//File: main.go
package main

import (
  "log"
  "net/http"
  "time"
)

func timeHandler(w http.ResponseWriter, r *http.Request) {
  tm := time.Now().Format(time.RFC1123)
  w.Write([]byte("The time is: " + tm))
}

func main() {
  mux := http.NewServeMux()

  // Convert the timeHandler function to a HandlerFunc type
  th := http.HandlerFunc(timeHandler)
  // And add it to the ServeMux
  mux.Handle("/time", th)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

实际上，将一个函数转换成 HandlerFunc 后注册到 ServeMux 是很普遍的用法，所以 Go 语言为此提供了个便捷方式：ServerMux.HandlerFunc 方法。

我们使用便捷方式重写 main() 函数看起来是这样的：

func main() {
  mux := http.NewServeMux()

  mux.HandleFunc("/time", timeHandler)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

绝大多数情况下这种用函数当处理器的方式工作的很好。但是当事情开始变得更复杂的时候，就会有些产生一些限制了。

你可能已经注意到了，跟之前的方式不同，我们不得不将时间格式硬编码到 timeHandler 的方法中。如果我们想从 main() 函数中传递一些信息或者变量给处理器该怎么办？

一个优雅的方式是将我们处理器放到一个闭包中，将我们要使用的变量带进去：

//File: main.go
package main

import (
  "log"
  "net/http"
  "time"
)

func timeHandler(format string) http.Handler {
  fn := func(w http.ResponseWriter, r *http.Request) {
    tm := time.Now().Format(format)
    w.Write([]byte("The time is: " + tm))
  }
  return http.HandlerFunc(fn)
}

func main() {
  mux := http.NewServeMux()

  th := timeHandler(time.RFC1123)
  mux.Handle("/time", th)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

timeHandler 函数现在有了个更巧妙的身份。除了把一个函数封装成 Handler(像我们之前做到那样)，我们现在使用它来返回一个处理器。这种机制有两个关键点：

首先是创建了一个fn，这是个匿名函数，将 format 变量封装到一个闭包里。闭包的本质让处理器在任何情况下，都可以在本地范围内访问到 format 变量。

其次我们的闭包函数满足 func(http.ResponseWriter, *http.Request) 签名。如果你记得之前我们说的，这意味我们可以将它转换成一个HandlerFunc类型（满足了http.Handler接口）。我们的timeHandler 函数随后转换后的 HandlerFunc 返回。

在上面的例子中我们已经可以传递一个简单的字符串给处理器。但是在实际的应用中可以使用这种方法传递数据库连接、模板组，或者其他应用级的上下文。使用全局变量也是个不错的选择，还能得到额外的好处就是编写更优雅的自包含的处理器以便测试。

你也可能见过相同的写法，像这样：

func timeHandler(format string) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    tm := time.Now().Format(format)
    w.Write([]byte("The time is: " + tm))
  })
}

或者在返回时，使用一个到 HandlerFunc 类型的隐式转换：

func timeHandler(format string) http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
    tm := time.Now().Format(format)
    w.Write([]byte("The time is: " + tm))
  }
}

http

http包提供了http客户端和服务端的实现

Get，Head，Post和PostForm函数发出http、https的请求

程序在使用完回复后必须关闭回复的主体

Get 请求

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3wCoFPUg-1595164548211)(net–http.assets/1588555382207.png)]

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    res,err:=http.Get("https://www.baidu.com")
    if err !=nil{
        panic(err)
	}
	fmt.Println(res)
    defer res.Body.Close()
    body, err := ioutil.ReadAll(res.Body)
    fmt.Println(string(body))
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9zRuBpp3-1595164548212)(net–http.assets/1588555620147.png)]

ioutil.ReadAll

我们看到了，如果用ioutil.ReadAll来读取即使只有1byte也会申请512byte，如果数据量大的话浪费的更多每次都会申请512+2*cap(b.buf)，假如我们有1025byte那么它就会申请3584byte，浪费了2倍还多。
这在比如http大量请求时轻则导致内存浪费严重，重则导致内存泄漏影响业务。

http.Client 客户端请求添加header信息

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

//发起client 请求，并添加header信息
func main() {
    client:=&http.Client{}
    res,err:=http.NewRequest("GET","https://www.baidu.com",nil)
	res.Header.Add("User-Agent", 
	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36")
    resp,err:=client.Do(res)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nwXyPsf8-1595164548212)(net–http.assets/1588555838508.png)]

访问指定路径 http.Dir

package main

import "net/http"

func main() {
　　//设置访问路由
    http.Handle("/",http.FileServer(http.Dir("./")))
    http.ListenAndServe(":8080",nil)
}

设置cookie 和请求头 http.Cookie

package main

import (
    "bufio"
    "fmt"
    "github.com/axgle/mahonia"
    "golang.org/x/net/html/charset"
    "golang.org/x/text/encoding"
    "io"
    "io/ioutil"
    "net/http"
    "strconv"
)

func main() {
    client := &http.Client{}
    request, err := http.NewRequest("GET", "http://www.baidu.com", nil)
    if err != nil {
        fmt.Println(err)
    }
    //建立cookie对象
    cookie := &http.Cookie{Name: "maple", Value: strconv.Itoa(123)}
    request.AddCookie(cookie) //向request中添加cookie

    //设置request的header
    request.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3")
    request.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
    request.Header.Set("Cache-Control", "no-cache")
    request.Header.Set("Connection", "keep-alive")

    response, err := client.Do(request)
    if err != nil {
        fmt.Println(err)
        return
    }
    e:=determineEncoding(response.Body)
    fmt.Println("当前编码：",e)

    defer response.Body.Close()
    if response.StatusCode == 200 {
        r, err := ioutil.ReadAll(response.Body)
        if err != nil {
            fmt.Println(err)
        }


        //编码转换，如编码不正确可转成指定编码
        srcCoder :=mahonia.NewEncoder("utf-8")
        res:=srcCoder.ConvertString(string(r))

        fmt.Println(res)
    }
}

//编码检测
func determineEncoding(r io.Reader) encoding.Encoding  {
    bytes, err := bufio.NewReader(r).Peek(1024)
    if err != nil {
        panic(err)
    }
    e, _, _ := charset.DetermineEncoding(bytes, "")
    return e
}

路由规则设置 http.HandleFunc

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

//HandleFunc注册一个处理器函数handler和对应的模式pattern（注册到DefaultServeMux）。ServeMux的文档解释了模式的匹配机制。

	// uri   回调函数
	http.HandleFunc("/", sayhelloName) //设置访问的路由
	err := http.ListenAndServe(":9090", nil) //设置监听的端口
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}

HTTP包默认的路由器：DefaultServeMux

https://blog.csdn.net/linkvivi/article/details/80250602

HTTP 请求路由器 servMux

ServrMux 本质上是一个 HTTP 请求路由器（或者叫多路复用器，Multiplexor）。它把收到的请求与一组预先定义的 URL 路径列表做对比，然后在匹配到路径的时候调用关联的处理器（Handler）。

**处理器（Handler）**负责输出HTTP响应的头和正文。任何满足了http.Handler接口的对象都可作为一个处理器。通俗的说，对象只要有个如下签名的ServeHTTP方法即可：

ServeHTTP(http.ResponseWriter, *http.Request)

package main

import (
  "log"
  "net/http"
)

func main() {
  mux := http.NewServeMux()

  rh := http.RedirectHandler("http://example.org", 307)
  mux.Handle("/foo", rh)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

  • 在 main 函数中我们只用了 http.NewServeMux 函数来创建一个空的 ServeMux。

  • 然后我们使用 http.RedirectHandler 函数创建了一个新的处理器，这个处理器会对收到的所有请求，都执行307重定向操作到 http://example.org。

  • 接下来我们使用 ServeMux.Handle 函数将处理器注册到新创建的 ServeMux，所以它在 URL 路径/foo 上收到所有的请求都交给这个处理器。

  • 最后我们创建了一个新的服务器，并通过 http.ListenAndServe 函数监听所有进入的请求，通过传递刚才创建的 ServeMux来为请求去匹配对应处理器。

然后在浏览器中访问 http://localhost:3000/foo，你应该能发现请求已经成功的重定向了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lDLEuCHU-1595164548213)(net–http.assets/1588557110497.png)]

明察秋毫的你应该能注意到一些有意思的事情：ListenAndServer 的函数签名是 ListenAndServe(addr string, handler Handler) ，但是第二个参数我们传递的是个 ServeMux。

我们之所以能这么做，是因为 ServeMux 也有 ServeHTTP 方法，因此它也是个合法的 Handler。

对我来说，将 ServerMux 用作一个特殊的Handler是一种简化。它不是自己输出响应而是将请求传递给注册到它的其他 Handler。这乍一听起来不是什么明显的飞跃 - 但在 Go 中将 Handler 链在一起是非常普遍的用法。

自定义路由转换器

package main

import (
  "log"
  "net/http"
  "time"
)

type timeHandler struct {
  format string
}
	//SerceHtpp 是 Handle的接口中的方法的实现，所有Handle作转发的时候，实现了这个接口的会自动触发
func (th *timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  tm := time.Now().Format(th.format)
  w.Write([]byte("The time is: " + tm))
}

func main() {
  mux := http.NewServeMux()

  th := &timeHandler{format: time.RFC1123}
  mux.Handle("/time", th)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uWovKft5-1595164548213)(net–http.assets/1588558608652.png)]

main函数中，我们像初始化一个常规的结构体一样，初始化了timeHandler，用 & 符号获得了其地址。随后，像之前的例子一样，我们使用 mux.Handle 函数来将其注册到 ServerMux。

现在当我们运行这个应用，ServerMux 将会将任何对 /time的请求直接交给 timeHandler.ServeHTTP 方法处理。

访问一下这个地址看一下效果：http://localhost:3000/time 。

注意我们可以在多个路由中轻松的复用 timeHandler：

func main() {
  mux := http.NewServeMux()

  th1123 := &timeHandler{format: time.RFC1123}
  mux.Handle("/time/rfc1123", th1123)

  th3339 := &timeHandler{format: time.RFC3339}
  mux.Handle("/time/rfc3339", th3339)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

自定义 处理函 http.HandlerFunc(timeHandler)

将函数作为处理器

对于简单的情况（比如上面的例子），定义个新的有 ServerHTTP 方法的自定义类型有些累赘。我们看一下另外一种方式，我们借助 http.HandlerFunc 类型来让一个常规函数满足作为一个 Handler 接口的条件。

任何有 func(http.ResponseWriter, *http.Request) 签名的函数都能转化为一个 HandlerFunc 类型。这很有用，因为 HandlerFunc 对象内置了 ServeHTTP 方法，后者可以聪明又方便的调用我们最初提供的函数内容。

如果你听起来还有些困惑，可以尝试看一下[相关的源代码]http://golang.org/src/pkg/net/http/server.go?s=35455:35502#L1221()。你将会看到让一个函数对象满足 Handler 接口是非常简洁优雅的。

让我们使用这个技术重新实现一遍timeHandler应用：

//File: main.go
package main

import (
  "log"
  "net/http"
  "time"
)

func timeHandler(w http.ResponseWriter, r *http.Request) {
  tm := time.Now().Format(time.RFC1123)
  w.Write([]byte("The time is: " + tm))
}

func main() {
  mux := http.NewServeMux()

  // Convert the timeHandler function to a HandlerFunc type
  th := http.HandlerFunc(timeHandler)
  // And add it to the ServeMux
  mux.Handle("/time", th)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

实际上，将一个函数转换成 HandlerFunc 后注册到 ServeMux 是很普遍的用法，所以 Go 语言为此提供了个便捷方式：ServerMux.HandlerFunc 方法。

我们使用便捷方式重写 main() 函数看起来是这样的：

func main() {
  mux := http.NewServeMux()

  mux.HandleFunc("/time", timeHandler)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

绝大多数情况下这种用函数当处理器的方式工作的很好。但是当事情开始变得更复杂的时候，就会有些产生一些限制了。

你可能已经注意到了，跟之前的方式不同，我们不得不将时间格式硬编码到 timeHandler 的方法中。如果我们想从 main() 函数中传递一些信息或者变量给处理器该怎么办？

一个优雅的方式是将我们处理器放到一个闭包中，将我们要使用的变量带进去：

//File: main.go
package main

import (
  "log"
  "net/http"
  "time"
)

func timeHandler(format string) http.Handler {
  fn := func(w http.ResponseWriter, r *http.Request) {
    tm := time.Now().Format(format)
    w.Write([]byte("The time is: " + tm))
  }
  return http.HandlerFunc(fn)
}

func main() {
  mux := http.NewServeMux()

  th := timeHandler(time.RFC1123)
  mux.Handle("/time", th)

  log.Println("Listening...")
  http.ListenAndServe(":3000", mux)
}

timeHandler 函数现在有了个更巧妙的身份。除了把一个函数封装成 Handler(像我们之前做到那样)，我们现在使用它来返回一个处理器。这种机制有两个关键点：

首先是创建了一个fn，这是个匿名函数，将 format 变量封装到一个闭包里。闭包的本质让处理器在任何情况下，都可以在本地范围内访问到 format 变量。

其次我们的闭包函数满足 func(http.ResponseWriter, *http.Request) 签名。如果你记得之前我们说的，这意味我们可以将它转换成一个HandlerFunc类型（满足了http.Handler接口）。我们的timeHandler 函数随后转换后的 HandlerFunc 返回。

在上面的例子中我们已经可以传递一个简单的字符串给处理器。但是在实际的应用中可以使用这种方法传递数据库连接、模板组，或者其他应用级的上下文。使用全局变量也是个不错的选择，还能得到额外的好处就是编写更优雅的自包含的处理器以便测试。

你也可能见过相同的写法，像这样：

func timeHandler(format string) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    tm := time.Now().Format(format)
    w.Write([]byte("The time is: " + tm))
  })
}

或者在返回时，使用一个到 HandlerFunc 类型的隐式转换：

func timeHandler(format string) http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
    tm := time.Now().Format(format)
    w.Write([]byte("The time is: " + tm))
  }
}
a...Z
关注
专栏目录
java中http调用组件深入详解
congge
04-27 6933
java中http调用组件深入详解
走进 - Http - a
wyc的博客
12-15 4739
走进 - Http - a 文章目录1.发展历史2.TCP/IP2.1 TCP/IP协议分层管理2.2 通信传输流2.3 IP协议（Internet Protocol）2.4 TCP协议2.5 DNS服务（Domain Name System）2.6 URI和URL2.7 统一资源标识符2.8 URI格式3.HTTP协议3.1 定位资源3.2 告知服务器意图的HTTP方法3.3 1.0和1.1支持...
httpa:http 认证服务器
06-25
HTTPA 经过身份验证的 http 服务器 伴侣和概念证明。 它将签署普通的 http 响应，并确保它们在传输过程中不被修改，同时允许中间人服务器检查、缓存和加速它们的交付。
HTTP协议
zylbs0501的博客
04-21 122
简介： HTTP协议,全称为HyperTextTransferProtocol,中文名为超文本传输协议。HTTP的重要应用之一是www服务。HTTP协议是互联网上常用的通信协议之一。 HTTP协议请求的工作流程如下: 1)终端客户在Web浏览器地址栏输入访问地址http:/w. etiantian. org/index. html 2)Web浏览器请求DNS服务器把域名www.etiantian....
HTTPS
qq_22648091的博客
01-27 567
三、HTTPS 基本原理 https 介绍 HTTPS（全称：HyperText Transfer Protocol over Secure Socket Layer），其实 HTTPS 并不是一个新鲜协议，Google 很早就开始启用了，初衷是为了保证数据安全。 国内外的大型互联网公司很多也都已经启用了HTTPS，这也是未来互联网发展的趋势。 1、加密算法 对称加密 A要给B发送数据 1，A做一个对称密钥 2，使用密钥给文件加密 3，发送加密以后的文件和钥匙 4，B拿钥匙解密 加密和解密都是使用的同
轻量级C++实现的httpserver和httpclient
03-17
本项目聚焦于轻量级的C++实现的HTTP服务器（httpserver）和HTTP客户端（httpclient），利用mongoose库作为基础，为开发者提供了一种简单且高效的方法来添加HTTP功能，而无需依赖如libcurl这样的大型库。 HTTP（超...
C#版支持高并发的HTTP服务器源码
09-30
本资源提供的“C#版支持高并发的HTTP服务器源码”正是为解决这一问题而设计的，特别适用于WINFORM程序，让你能够快速创建自定义的HTTP服务器。 首先，我们要理解HTTP服务器的工作原理。HTTP（超文本传输协议）是...
httppost和httpget需要的jar包
12-06
在Java编程中，HTTP POST和GET是两种基本的HTTP请求方法，用于客户端向服务器发送数据。为了在Java中实现这些功能，我们需要引入特定的库，这些库通常被打包成JAR（Java Archive）文件。本篇文章将详细讲解HTTP POST...
nginx-1.19.3_nginx-http-flv-module.rar
09-01
标题中的"nginx-1.19.3_nginx-http-flv-module.rar"表明这是一个关于Nginx服务器的软件包，特别地，它包含了Nginx的1.19.3版本，并且已经集成了`nginx-http-flv-module`模块。这个模块是用于支持HTTP FLV（Flash ...
golang.org/x下的包集合
08-23
https://golang.org/x/下的相关的包国内无法下载，这个可以直接将解压后的golang.org-master/x目录下到包放到GOPATH目录下的golang.org/x路径下面，执行go install 包名称就行了
a http协议目录
wanxiaoderen的博客
06-07 558
http 1一、 http基础介绍二、URI于URL区别三、 简单HTTP协议四、HTTP报文详解五、状态码六、Web服务器七、HTTP头部协议八、HTTPS的加密协议九、HTTP用户认证十、HTTP追加协议十一、web攻击技术 一、 http基础介绍 http介绍 二、URI于URL区别 三、 简单HTTP协议 四、HTTP报文详解 五、状态码 六、Web服务器 七、HTTP头部协议 八、HTTPS的加密协议 九、HTTP用户认证 十、HTTP追加协议 十一、web攻击技术 ...
Golang.org/x库初探2——text库
最新发布
baijiafan的博客
01-13 2033
golang/x 库下text库详解，提供国际化、编码转换等丰富功能
探究HTTP
A_D_H_E_R_E的博客
09-20 2520
认识HTTP HTTP 是一种超文本传输协议(Hypertext Transfer Protocol)，什么是超文本传输协议？ 超文本传输协议可以进行文字分割：超文本（Hypertext）、传输（Transfer）、协议（Protocol） 什么是超文本 在互联网早期的时候，我们输入的信息只能保存在本地，无法和其他电脑进行交互。我们保存的信息通常都以文本即简单字符的形式存在，文本是一种能够被计算机解析的有意义的二进制数据包。而随着互联网的高速发展，两台电脑之间能够进行数据的传输后，人们不满足..
http抓包工具
a...Z
12-10 689
抓包工具
解决 go get golang.org/x/* 拉取失败问题
weixin_30553837的博客
12-27 858
go get -u -v golang.org/x/text 有时候会因为网络问题，导致失败。 在不用代理的情况下，可以使用以下方案。 golang.org，他们在github上有一个镜像库 以golang.org/x/text为例 github上的托管位置 一般在 https://github.com/golang/text 解决方案： 1.下载源码: 到gi...
Go mod常用与高级操作
剑心！的博客
05-31 559
1. 开启Go module 1.11和1.12版本 将下面两个设置添加到系统的环境变量中 GO111MODULE=on GOPROXY=https://goproxy.io 1.13版本之后 这种方式并不会覆盖之前的配置，需要先把系统的环境变量里面的给删掉再设置 go env -w GO111MODULE=on go env -w GOPROXY=https://goproxy.cn,https://goproxy.io,direct 2. go get使用 使用go module之后，go get
程序代写淘宝店地址：http://apenny.taobao.com
dfu54516的博客
03-29 629
程序代写淘宝店地址：http://apenny.taobao.com 交易流程： 1.您需要先与我联系，并给出需求描述，由我方判断需求的可行性，确认是否接单。 2.确认接单后，根据您给出的需求文档，我方估计完成时间和工作量以及价格。 3.您拍下宝贝并支付货款到支付宝。 4.在软件开始过程中，本工作室将与您即时沟通，一直到软件开发结束，方便与您即时反馈，做出您满意的软件产...
go标准库的学习-net/http
weixin_33834679的博客
02-28 1200
参考：https://studygolang.com/pkgdoc 概念解释： request：用户请求的信息，用来解析用户的请求信息，包括post、get、cookie、url等信息 response：服务器返回给客户端的信息 conn：用户的每次请求链接 handler：处理请求和生成返回信息的处理逻辑 该图来自https://www.sohu.com/a/208720...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

a...Z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值