12.3.1 概述

12.3.1.1 Web工作方式

我们平时浏览网页的时候,会打开浏览器，输入网址后按下回车键，然后就会显示出你想要浏览的内容。在这个看似简单的用户行为背后，到底隐藏了些什么呢？

对于普通的上网过程，系统其实是这样做的：浏览器本身是一个客户端，当你输入URL的时候，首先浏览器会去请求DNS服务器，通过DNS获取相应的域名对应的IP，然后通过IP地址找到IP对应的服务器后，要求建立TCP连接，等浏览器发送完HTTP Request（请求）包后，服务器接收到请求包之后才开始处理请求包，服务器调用自身服务，返回HTTP Response（响应）包；客户端收到来自服务器的响应后开始渲染这个Response包里的主体（body），等收到全部的内容随后断开与该服务器之间的TCP连接。

一个Web服务器也被称为HTTP服务器，它通过HTTP协议与客户端通信。这个客户端通常指的是Web浏览器(其实手机端客户端内部也是浏览器实现的)。

Web服务器的工作原理可以简单地归纳为：

  • 客户机通过TCP/IP协议建立到服务器的TCP连接
  • 客户端向服务器发送HTTP协议请求包，请求服务器里的资源文档
  • 服务器向客户机发送HTTP协议应答包，如果请求的资源包含有动态语言的内容，那么服务器会调用动态语言的解释引擎负责处理“动态内容”，并将处理得到的数据返回给客户端
  • 客户机与服务器断开。由客户端解释HTML文档，在客户端屏幕上渲染图形结果

12.3.1.2 HTTP协议

超文本传输协议(HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议，它详细规定了浏览器和万维网服务器之间互相通信的规则，通过因特网传送万维网文档的数据传送协议。

HTTP协议通常承载于TCP协议之上，有时也承载于TLS或SSL协议层之上，这个时候，就成了我们常说的HTTPS。如下图所示：

12.3.1.3 地址（URL）

URL全称为Unique Resource Location，用来表示网络资源，可以理解为网络文件路径。

URL的格式如下：

  1. http://host[":"port][abs_path]
  2. http://192.168.31.1/html/index

URL的长度有限制，不同的服务器的限制值不太相同，但是不能无限长。

12.3.2 HTTP报文浅析

12.3.2.1 请求报文格式

1) 测试代码
服务器测试代码：

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  6.     "net"
  7. )
  9. func main() {
  10.     //创建、监听socket
  11.     listenner, err := net.Listen("tcp", "127.0.0.1:8000")
  12.     if err != nil {
  13.         log.Fatal(err) //log.Fatal()会产生panic
  14.     }
  16.     defer listenner.Close()
  18.     conn, err := listenner.Accept() //阻塞等待客户端连接
  19.     if err != nil {
  20.         log.Println(err)
  21.         return
  22.     }
  24.     defer conn.Close() //此函数结束时，关闭连接套接字
  26.     //conn.RemoteAddr().String()：连接客服端的网络地址
  27.     ipAddr := conn.RemoteAddr().String()
  28.     fmt.Println(ipAddr, "连接成功")
  30.     buf := make([]byte, 4096) //缓冲区，用于接收客户端发送的数据
  32.     //阻塞等待用户发送的数据
  33.     n, err := conn.Read(buf) //n代码接收数据的长度
  34.     if err != nil {
  35.         fmt.Println(err)
  36.         return
  37.     }
  39.     //切片截取，只截取有效数据
  40.     result := buf[:n]
  41.     fmt.Printf("接收到数据来自[%s]==>:\n%s\n", ipAddr, string(result))
  42. }

2) 请求报文格式说明

HTTP 请求报文由请求行、请求头部、空行、请求包体4个部分组成，如下图所示：

1) 请求行
请求行由方法字段、URL 字段 和HTTP 协议版本字段 3 个部分组成，他们之间使用空格隔开。常用的 HTTP 请求方法有 GET、POST。

GET：

  • 当客户端要从服务器中读取某个资源时，使用GET 方法。GET 方法要求服务器将URL 定位的资源放在响应报文的数据部分，回送给客户端，即向服务器请求某个资源。
  • 使用GET方法时，请求参数和对应的值附加在 URL 后面，利用一个问号(“?”)代表URL 的结尾与请求参数的开始，传递参数长度受限制，因此GET方法不适合用于上传数据。
  • 通过GET方法来获取网页时，参数会显示在浏览器地址栏上，因此保密性很差。

POST：

  • 当客户端给服务器提供信息较多时可以使用POST 方法，POST 方法向服务器提交数据，比如完成表单数据的提交，将数据提交给服务器处理。
  • GET 一般用于获取/查询资源信息，POST 会附带用户数据，一般用于更新资源信息。POST 方法将请求参数封装在HTTP 请求数据中，而且长度没有限制，因为POST携带的数据，在HTTP的请求正文中，以名称/值的形式出现，可以传输大量数据。

2) 请求头部

请求头部为请求报文添加了一些附加信息，由“名/值”对组成，每行一对，名和值之间使用冒号分隔。
请求头部通知服务器有关于客户端请求的信息，典型的请求头有：

3) 空行

最后一个请求头之后是一个空行，发送回车符和换行符，通知服务器以下不再有请求头。

4) 请求包体

请求包体不在GET方法中使用，而是POST方法中使用。
POST方法适用于需要客户填写表单的场合。与请求包体相关的最常使用的是包体类型Content-Type和包体长度Content-Length。

12.3.2.2 响应报文格式

1) 测试代码

服务器示例代码：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6. )
  8. //服务端编写的业务逻辑处理程序
  9. func myHandler(w http.ResponseWriter, r *http.Request) {
  10.     fmt.Fprintln(w, "hello world")
  11. }
  13. func main() {
  14.     http.HandleFunc("/go", myHandler)
  16.     //在指定的地址进行监听，开启一个HTTP
  17.     http.ListenAndServe("127.0.0.1:8000", nil)
  18. }

客户端测试示例代码：

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  6.     "net"
  7. )
  9. func main() {
  10.     //客户端主动连接服务器
  11.     conn, err := net.Dial("tcp", "127.0.0.1:8000")
  12.     if err != nil {
  13.         log.Fatal(err) //log.Fatal()会产生panic
  14.         return
  15.     }
  17.     defer conn.Close() //关闭
  19.     requestHeader := "GET /go HTTP/1.1\r\nAccept: image/gif, image/jpeg, image/pjpeg, application/x-ms-application, application/xaml+xml, application/x-ms-xbap, */*\r\nAccept-Language: zh-Hans-CN,zh-Hans;q=0.8,en-US;q=0.5,en;q=0.3\r\nUser-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 10.0; WOW64; Trident/7.0; .NET4.0C; .NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729)\r\nAccept-Encoding: gzip, deflate\r\nHost: 127.0.0.1:8000\r\nConnection: Keep-Alive\r\n\r\n"
  21.     //先发送请求包
  22.     conn.Write([]byte(requestHeader))
  24.     buf := make([]byte, 4096) //缓冲区
  26.     //阻塞等待服务器回复的数据
  27.     n, err := conn.Read(buf) //n代码接收数据的长度
  28.     if err != nil {
  29.         fmt.Println(err)
  30.         return
  31.     }
  32.     //切片截取，只截取有效数据
  33.     result := buf[:n]
  34.     fmt.Printf("接收到数据[%d]:\n%s\n", n, string(result))
  35. }

2) 响应报文格式说明

HTTP 响应报文由状态行、响应头部、空行、响应包体4个部分组成，如下图所示：

1) 状态行
状态行由 HTTP 协议版本字段、状态码和状态码的描述文本3个部分组成，他们之间使用空格隔开。

状态码：
状态码由三位数字组成，第一位数字表示响应的类型，常用的状态码有五大类如下所示：

常见的状态码举例：

2) 响应头部

响应头可能包括：

响应头 含义
Location Location响应报头域用于重定向接受者到一个新的位置
Server Server 响应报头域包含了服务器用来处理请求的软件信息及其版本
Vary 指示不可缓存的请求头列表
Connection 连接方式

3) 空行
最后一个响应头部之后是一个空行，发送回车符和换行符，通知服务器以下不再有响应头部。

4) 响应包体
服务器返回给客户端的文本信息。

12.3.3 HTTP编程

Go语言标准库内建提供了net/http包，涵盖了HTTP客户端和服务端的具体实现。使用
net/http包，我们可以很方便地编写HTTP客户端或服务端的程序。

12.3.3.1 HTTP服务端
示例代码：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6. )
  8. //服务端编写的业务逻辑处理程序
  9. //hander函数： 具有func(w http.ResponseWriter, r *http.Requests)签名的函数
  10. func myHandler(w http.ResponseWriter, r *http.Request) {
  11.     fmt.Println(r.RemoteAddr, "连接成功")  //r.RemoteAddr远程网络地址
  12.     fmt.Println("method = ", r.Method) //请求方法
  13.     fmt.Println("url = ", r.URL.Path)
  14.     fmt.Println("header = ", r.Header)
  15.     fmt.Println("body = ", r.Body)
  17.     w.Write([]byte("hello go")) //给客户端回复数据
  18. }
  20. func main() {
  21.     http.HandleFunc("/go", myHandler)
  23.     //该方法用于在指定的 TCP 网络地址 addr 进行监听，然后调用服务端处理程序来处理传入的连接请求。
  24.     //该方法有两个参数：第一个参数 addr 即监听地址；第二个参数表示服务端处理程序，通常为空
  25.     //第二个参数为空意味着服务端调用 http.DefaultServeMux 进行处理
  26.     http.ListenAndServe("127.0.0.1:8000", nil)
  27. }

12.3.3.2 HTTP客户端

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "log"
  7.     "net/http"
  8. )
  10. func main() {
  12.     //get方式请求一个资源
  13.     //resp, err := http.Get("http://www.baidu.com")
  14.     //resp, err := http.Get("http://www.neihan8.com/article/index.html")
  15.     resp, err := http.Get("http://127.0.0.1:8000/go")
  16.     if err != nil {
  17.         log.Println(err)
  18.         return
  19.     }
  21.     defer resp.Body.Close() //关闭
  23.     fmt.Println("header = ", resp.Header)
  24.     fmt.Printf("resp status %s\nstatusCode %d\n", resp.Status, resp.StatusCode)
  25.     fmt.Printf("body type = %T\n", resp.Body)
  27.     buf := make([]byte, 2048) //切片缓冲区
  28.     var tmp string
  30.     for {
  31.         n, err := resp.Body.Read(buf) //读取body包内容
  32.         if err != nil && err != io.EOF {
  33.             fmt.Println(err)
  34.             return
  35.         }
  37.         if n == 0 {
  38.             fmt.Println("读取内容结束")
  39.             break
  40.         }
  41.         tmp += string(buf[:n]) //累加读取的内容
  42.     }
  44.     fmt.Println("buf = ", string(tmp))
  45. }
作者：admin  创建时间：2018-06-18 07:19
 更新时间：2018-06-18 07:35
上一篇：
下一篇：