20 网络编程 Web 服务器

[TOC]

Web 服务器

• Go 提供了一个完善的 net/http 包，通过 http 包很容易就可以搭建 Web 服务器。使用net/http包能很简单地对 Web 的路由、静态文件、模版、cookie 等数据进行设置和操作，不需要再去引入其它任何额外的依赖。

• net/http 包也提供了HTTP客户端的相关API，可以很简单发起HTTP请求。

Go HTTP 服务器

net/http下 常用API

• 注册处理函数 http.HandleFunc(资源url string, 资源对应处理函数))

• 监听一个端口启动HTTP服务器 http.ListenAndServe("ip:port",nil)

HTTP 处理器和处理器函数

处理器需要实现Handler接口，接口有一个ServeHTTP(ResponseWriter, *Request)方法，任何实现了这个接口的类型都是处理器。

• ListenAndServe 使用指定的监听地址和处理器启动一个HTTP服务端。处理器参数通常是nil，这表示采用包变量 DefaultServeMux 作为处理器。

• Handle 和 HandleFunc 函数可以向 DefaultServeMux 添加处理器。

package main

import (
	"fmt"
	"net/http"
)

type MyHandler1 struct {}
func (h1 *MyHandler1) ServeHTTP(writer http.ResponseWriter,request *http.Request){
	fmt.Println("h1处理器")
	writer.Write([]byte("h1响应数据"))
}

type MyHandler2 struct {}
func (h2 *MyHandler2) ServeHTTP(write http.ResponseWriter,request *http.Request){
	fmt.Println("h2处理器")
	write.Write([]byte("h2响应数据"))
}

func main() {
	server := http.Server{
		Addr: "0.0.0.0:8080",
	}
	http.Handle("/h1",&MyHandler1{})
	http.Handle("/h2",&MyHandler2{})
	server.ListenAndServe()
//	分别访问 http://localhost:8080/h1 和 http://localhost:8080/h2，不同处理器监听了不同的 url
}

处理器函数是与处理器拥有相同行为的函数，它与ServeHTTP(ResponseWriter, *Request)方法有相同的签名。

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/f1", func(writer http.ResponseWriter, request *http.Request) {
		fmt.Println("f1处理器函数")
		writer.Write([]byte("f1响应数据"))
	})
	http.HandleFunc("/f2", func(writer http.ResponseWriter, request *http.Request) {
		fmt.Println("f2处理器函数")
		writer.Write([]byte("f2响应数据"))
	})
	http.ListenAndServe("0.0.0.0:8080",nil)
//	访问 http://localhost:8080/f1 和 http://localhost:8080/f2 ， 分别访问两个处理器函数
}

读取数据 流方式

读取请求体body数据

• 请求方式除了Get以外，其它请求方式数据都可在body中读取。

• 如果body中的数据已经被读取，则其它方式都将读取不到数据。

package main

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

func main() {
	http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
		body := request.Body
		defer body.Close()
		// http 是文本传输，使用string将数据装入
		var req strings.Builder
		for {
			buf := make([]byte,1024)
			n,err := body.Read(buf)
			if io.EOF == err {
				// EOF 数据读取完，退出读取数据。
				req.Write(buf[:n])
				break
			}
			if nil != err {
				fmt.Println(err)
				break
			}
			req.Write(buf[:n])
		}
		fmt.Println(req.String())
		writer.Write([]byte("响应数据"))
	})
	http.ListenAndServe("0.0.0.0:8080",nil)
}

读取表单数据 FormValue，读取Header数据

通过FormValue读取数据，可以读取Get请求和表单提交，但要注意，在非Get请求情况如果先把body数据读取了，再到FormValue是读取不到数据的。

• 表单数据，增加请求头 【Content-Type:application/x-www-form-urlencoded】

• 要读取表单数据要先 request.ParseForm()

• 读取请求头使用 request.Header.Get(key)

• 设置响应头 writer.Header().Set("test-header","test")

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
		request.ParseForm()
		data := request.FormValue("data")
		fmt.Println(data)
		// 读取请求头
		userAgent := request.Header.Get("User-Agent")
		fmt.Println("userAgent=",userAgent)
		// 设置响应头
		writer.Header().Set("test-header","test")
		writer.Write([]byte("响应数据"))
	})
	http.ListenAndServe("0.0.0.0:8080",nil)
}

带有配置的Web服务器

要带配置的Web服务器使用http.Server，需要自定义Handler，自定义Handler需要实现Handler接口。

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

package main

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

type WebHandler struct {
	serverName string
}

func (handle *WebHandler) ServeHTTP(writer http.ResponseWriter,request *http.Request){
	request.ParseForm()
	data1 := request.FormValue("data1")
	data2 := request.FormValue("data2")
	fmt.Printf("%s：data1=%s,data2=%s\n",handle.serverName,data1,data2)
	writer.Write([]byte("自定义handler 响应数据"))
}

func main() {
	handler := WebHandler{"自定义handler"}
	server := http.Server{
		Addr: "0.0.0.0:8080",
		Handler: &handler,
		ReadTimeout: 5 * time.Second,	// 读取数据超时
		WriteTimeout: 5 * time.Second,	// 响应数据超时
		MaxHeaderBytes: 4096,	// 请求体最大字节，默认1M
	}
	server.ListenAndServe()
}

响应 json数据 application/json

	writer.Header().Set("Content-Type","application/json")
	mp := make(map[string]interface{})
	mp["name"] = "大黑"
	mp["age"] = 99
	json,_ := json.Marshal(mp)
	writer.Write(json)

响应状态码设置 重定向302

package main

import "net/http"

func main() {
	http.HandleFunc("/", func(writer http.ResponseWriter,request *http.Request) {
		writer.Header().Set("Location","https://www.google.com")
		writer.WriteHeader(302)	// 设置Http请求响应码 302重定向
	})
	http.ListenAndServe(":8080",nil)
}

多路复用器 ServeMux 和 DefaultServeMux

ServeMux是一个HTTP请求多路复用器，它负责接收HTTP请求并根据请求中的URL将请求交给正确的处理器。

• ServeMux结构包含了一个map，map会将URL作为key处理器作为value。

• ServeMux结构也实现了ServeHTTP方法，所以它也是一个处理器，当ServeMux的ServeHTTP方法接收到一个请求的时候，它会在结构的map中找出被请求URL最为匹配的URL（绝对路径将会优先于相对路径），然后调用与之相应的处理器。

• ServeMux不是接口而是一个结构体，所以DefaultServeMux并不是ServeMux的实现。

• DefaultServeMux是ServeMux的一个实例，并且所有引入net/http标准库的程序都可以使用这个实例。如果没有指定ServeMux，服务器就会默认使用DefaultServeMux。

• 第三方多路复用器 "github.com/julienschmidt/httprouter"，有开发了一些新的功能（如从URL中提取出参数）。

多路复用器转发给处理器图

多路复用器转发给处理器图

多路复用器的工作原理

多路复用器的工作原理图

• 多路复用器使用：

package main

import (
	"fmt"
	"net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
		fmt.Println("多路复用器")
		writer.Write([]byte("响应数据"))
	})
	server := &http.Server{
		Addr: "0.0.0.0:8080",
		Handler: mux,
	}
	server.ListenAndServe()
}

HTTP 静态资源处理器配置

静态资源处理器配置

• http.FileServer 创建一个文件HTTP请求的处理器，文件路径在Dir下，【http.FileServer(http.Dir("./web/webapp/page"))】。配置的路径是从goPath开始的，在集成开发工具中是从项目根路径开始。

• http.StripPrefix 如果URL前缀是prefix则URL会被TrimPrefix截去前缀，因为目录配置是【"./web/webapp/page"】访问的URL一般是http://域名/page/index.html，如果不截去前缀则会在【"./web/webapp/page/page/index.html"】，而实际上文件的目录在【"./web/webapp/page/index.html"】就会无法访问到而出现404。

• http.Handle注册处理器，处理请求资源URL与"/page/"最匹配的。

func main() {
	http.Handle("/page/",http.StripPrefix("/page/",http.FileServer(http.Dir("./web/webapp/page"))))
	http.Handle("/style/",http.StripPrefix("/style/",http.FileServer(http.Dir("./web/webapp/style"))))
	http.Handle("/img/",http.StripPrefix("/img/",http.FileServer(http.Dir("./web/webapp/image"))))
	http.Handle("/favicon.ico",http.FileServer(http.Dir("./web/webapp/image")))
	http.ListenAndServe(":80",nil)
}

使用 HTTPS

申请了SSL证书之后使用 ListenAndServeTLS 开启HTTPS。

• 开启HTTPS模式启动服务器，服务器默认使用HTTP2。

package main

import "net/http"

func main() {
	server := http.Server{
		Addr: "0.0.0.0:8080",
	}
	server.ListenAndServeTLS("cert.pem","key.pem")
}

Go HTTP 客户端

请求提交数据的常见编码格式有三种：

• application/x-www-form-urlencoded 浏览器的原生form表单，如果不设置enctype属性，那么最终就会默认以application/x-www-form-urlencoded方式提交数据。这种情况下请求头的Content-Type被设置成application/x-www-form-urlencoded，提交的数据按照key1=value1&key2=value2的方式进行编码，key和value都进行了URL转码。大部分服务端语言都对这种方式有很好的支持。默认用Ajax提交数据时，也是使用这种方式。

• multipart/form-data 是一个常见的POST数据提交的方式，表示在发送前不对数据进行编码，这种方式一般出现在通过form表单上传文件的场景中，在HTML的form标签中通过设置属性enctype=multipart/form-data来表示通过这种方式提交数据。上面提到的这两种POST数据的方式，都是浏览器原生支持的。各大服务端语言对它也有着良好的支持。

• application/json 这个Content-Type请求头和响应头都很常见，用来告诉服务端消息主体是序列化后的JSON字符串。由于JSON规范的流行，除了低版本IE之外的各大浏览器都原生支持JSON.stringify，服务端语言也都有处理JSON的函数，使用JSON不会遇上什么麻烦。

Go 作为客户端发起HTTP请求

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"
)

func onServer(){
	http.HandleFunc("/login", func(writer http.ResponseWriter, request *http.Request) {
		request.ParseForm()
		userName := request.FormValue("userName")
		pwd := request.FormValue("pwd")
		fmt.Println("userName=",userName,"pwd=",pwd)
		result := make(map[string]interface{})
		result["code"] = 2000
		result["tip"] = "登录成功"
		b,_ := json.Marshal(result)
		writer.Write(b)
	})
	http.ListenAndServe("0.0.0.0:8080",nil)
}

//	readBody 读取响应body中数据
func readBody(body io.ReadCloser) string {
	defer body.Close()
	str := strings.Builder{}
	buf := make([]byte,1024)
	for {
		n,err := body.Read(buf)
		if io.EOF == err {
			str.Write(buf[:n])
			break
		}
		if nil != err {
			fmt.Println(err)
			break
		}
		str.Write(buf[:n])
	}
	return str.String()
}

func main() {
	reqUrl := "http://127.0.0.1:8080/login"
	userName := "PandaMan"
	pwd := "666666"
	go onServer()
	time.Sleep(10*time.Millisecond)
	onGet(reqUrl,userName,pwd)
	onPost(reqUrl,userName,pwd)
	clientPost(reqUrl,userName,pwd)
	clientGet(reqUrl,userName,pwd)
}

Get、Post 函数发出 HTTP/ HTTPS请求

func onGet(reqUrl,userName,pwd string){
	fmt.Println("********************* get请求 ******************************")
	resp,err := http.Get(fmt.Sprintf("%s?userName=%s&pwd=%s",reqUrl,userName,pwd))
	if nil != err {
		fmt.Println(err)
		return
	}
	fmt.Println(resp)
	fmt.Println(readBody(resp.Body))
}

func onPost(reqUrl,userName,pwd string){
	fmt.Println("********************* post请求 ******************************")
	reqData := strings.NewReader(fmt.Sprintf("userName=%s&pwd=%s",userName,pwd))
	resp,err := http.Post(reqUrl,"application/x-www-form-urlencoded",reqData)
	if nil != err {
		fmt.Println(err)
		return
	}
	fmt.Println(resp)
	fmt.Println(readBody(resp.Body))
}

http.NewRequest 管理HTTP客户端的头和其他设置

func clientPost(reqUrl,userName,pwd string){
	fmt.Println("************************* client 发起post请求 ****************************")
	client := &http.Client{}
	reqData := strings.NewReader(fmt.Sprintf("userName=%s&pwd=%s",userName,pwd))
	req, err := http.NewRequest("POST", reqUrl, reqData)
	if nil != err {
		fmt.Println(err)
		return
	}
	req.Header.Add("userToken", `abc123df"`)
	req.Header.Add("Content-Type","application/x-www-form-urlencoded")
	resp, err := client.Do(req)
	if nil != err {
		fmt.Println(err)
		return
	}
	fmt.Println(resp)
	fmt.Println(readBody(resp.Body))
}

Transport

Client 和 Transport 类型都可以安全的被多个协程同时使用。出于效率考虑，应该一次建立、尽量重用。

• transport的主要功能其实就是缓存了长连接，用于大量http请求场景下的连接复用，减少发送请求时TCP(TLS)连接建立的时间损耗，同时transport还能对连接做一些限制，如连接超时时间，每个host的最大连接数等。transport对长连接的缓存和控制仅限于TCP+(TLS)+HTTP1，不对HTTP2做缓存和限制。

func clientGet(reqUrl,userName,pwd string) {
	fmt.Println("************************* client 发起get请求 ****************************")
	tr := &http.Transport{
		DisableCompression: true,
	}
	client := &http.Client{Transport: tr}
	resp, err := client.Get(fmt.Sprintf("%s?userName=%s&pwd=%s",reqUrl,userName,pwd))
	if nil != err {
		fmt.Println(err)
		return
	}
	fmt.Println(resp)
	fmt.Println(readBody(resp.Body))
}

Go 文件上传

接收文件上传服务器

package main

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

//	maxFileSize 30M
const maxFileSize int64 = 31457280
const M1 int64 = 1048576
const basePath string = "E:\\log"

func uploadFile(writer http.ResponseWriter, request *http.Request){
	http.MaxBytesReader(writer,request.Body,M1)
	file,fileHeader,err := request.FormFile("uploadFile")
	if nil != err {
		fmt.Println(err)
		return
	}
	defer file.Close()
	fmt.Printf("文件名=%s,文件大小=%d \n",fileHeader.Filename,fileHeader.Size)
	if fileHeader.Size > maxFileSize{
		writer.Write([]byte("不得上传30M以上文件"))
		return
	}

	newFilePath := fmt.Sprintf("%s%c%s",basePath,os.PathSeparator,fileHeader.Filename)
	toFile,err := os.OpenFile(newFilePath,os.O_RDWR | os.O_CREATE, os.ModePerm)
	if nil != err {
		fmt.Println(err)
		return
	}
	defer toFile.Close()
	buf := make([]byte,1024)
	for {
		n,err := file.Read(buf)
		if io.EOF == err {
			toFile.Write(buf[:n])
			break
		}
		toFile.Write(buf[:n])
	}
	fmt.Println("文件上传完成")
	writer.Write([]byte("ok"))
}

func main() {
	http.HandleFunc("/uploadFile", uploadFile)
	http.Handle("/page/",http.StripPrefix("/page/",http.FileServer(http.Dir("./web/page"))))
	http.ListenAndServe(":19580",nil)
}

HTML 表单上传文件

upload.html

• 访问 http://localhost:19580/page/upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form enctype="multipart/form-data" action="/uploadFile" method="post">
        <input type="file" name="uploadFile" />
        <input type="submit" value="upload" />
    </form>
</body>
</html>

Go 上传文件

func goUploadFile(){
	bodyBuf := &bytes.Buffer{}
	writer := multipart.NewWriter(bodyBuf)
	fileWriter, _ := writer.CreateFormFile("uploadFile", "20211208194621.gif")
	//	文件
	f, _ := os.Open("C:\\Users\\laoniqiu\\Pictures\\20211208194621.gif")
	//	拷贝文件到 fileWriter
	io.Copy(fileWriter, f)
	writer.Close()
	r,_ := http.Post(
		"http://localhost:23120/files/file/UploadFile",
		writer.FormDataContentType(),
		bodyBuf,
	)

	var str strings.Builder
	buf := make([]byte,1024)
	for {
		n,err := r.Body.Read(buf)
		if io.EOF == err {
			str.Write(buf[:n])
			break
		}
		str.Write(buf[:n])
	}
	fmt.Println(r)
	fmt.Println(str.String())
}