Go实现http接口压测工具

浅浅的花香味﹌ 2022-09-09 00:25 108阅读 0赞

**使用方式**  
切换到根目录下，执行：

go run main.go -c 500 -n 20 -u https://www.baidu.com

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA566A5Y2V6ZqP6aOO_size_20_color_FFFFFF_t_70_g_se_x_16]

项目目录如下：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA566A5Y2V6ZqP6aOO_size_16_color_FFFFFF_t_70_g_se_x_16]

├── go.mod    						 依赖管理
    ├── main.go    						 启动函数
    ├── model
    │   └── request.go					 对象定义
    └── server
        ├── client
        │   └── http_client.go			 http请求发起客户端
        ├── dispose.go					 执行入口
        ├── golink
        │   └── http_link.go			 http接口具体的执行
        └── statistics
            └── statistics.go			 统计测试结果

**main.go**  
主要负责命令行传递的参数校验，然后启动`server.Dispose()`开始具体的执行

import (
    	"flag"
    	"fmt"
    	"httpPressureTest/model"
    	"httpPressureTest/server"
    	"runtime"
    )
    
    type array []string
    
    func (a *array) String() string { 
    	return fmt.Sprint(*a)
    }
    
    func (a *array) Set(s string) error { 
    	*a = append(*a, s)
    
    	return nil
    }
    
    func main() { 
    
    	runtime.GOMAXPROCS(1)
    
    	var (
    		concurrency uint64 // 并发数
    		totalNumber uint64 // 请求数(单个并发/协程)
    		requestUrl  string // 压测的url 目前支持，http/https ws/wss
    		headers     array  // 自定义头信息传递给服务器
    		body        string // HTTP POST方式传送数据
    	)
    
    	flag.Uint64Var(&concurrency, "c", 1, "并发数")
    	flag.Uint64Var(&totalNumber, "n", 1, "请求数(单个并发/协程)")
    	flag.StringVar(&requestUrl, "u", "", "压测地址")
    	flag.Var(&headers, "H", "自定义头信息传递给服务器 示例:-H 'Content-Type: application/json'")
    	flag.StringVar(&body, "data", "", "HTTP POST方式传送数据")
    
    	// 解析参数
    	flag.Parse()
    	if concurrency == 0 || totalNumber == 0 || (requestUrl == "") { 
    		fmt.Printf("示例: go run main.go -c 1 -n 1 -u https://www.baidu.com/ \n")
    		fmt.Printf("当前请求参数: -c %d -n %d -u %s \n", concurrency, totalNumber, requestUrl)
    
    		flag.Usage()
    
    		return
    	}
    
    	request, err := model.NewRequest(requestUrl, headers, body)
    	if err != nil { 
    		fmt.Printf("参数不合法 %v \n", err)
    
    		return
    	}
    
    	fmt.Printf("\n 开始启动 并发数:%d 请求数:%d 请求参数: \n", concurrency, totalNumber)
    	request.Print()
    
    	// 开始处理
    	server.Dispose(concurrency, totalNumber, request)
    
    	return
    }

**server.Dispose**  
对统计模块`statistics.ReceivingResults()`和请求模块`golink.Http()`进行调度

import (
    	"httpPressureTest/model"
    	"httpPressureTest/server/golink"
    	"httpPressureTest/server/statistics"
    	"sync"
    	"time"
    )
    
    
    // 处理函数
    func Dispose(concurrency, totalNumber uint64, request *model.Request) { 
    
    	// 设置接收数据缓存
    	ch := make(chan *model.RequestResults, 1000)
    	var (
    		wg          sync.WaitGroup // 发送数据完成
    		wgReceiving sync.WaitGroup // 数据处理完成
    	)
    
    	wgReceiving.Add(1)
    	go statistics.ReceivingResults(concurrency, ch, &wgReceiving)
    
    	for i := uint64(0); i < concurrency; i++ { 
    		wg.Add(1)
    		go golink.Http(i, ch, totalNumber, &wg, request)
    	}
    
    	// 等待所有的数据都发送完成
    	wg.Wait()
    
    	// 延时1毫秒 确保数据都处理完成了
    	time.Sleep(1 * time.Millisecond)
    	close(ch)
    
    	// 数据全部处理完成了
    	wgReceiving.Wait()
    
    	return
    }

**statistics.ReceivingResults**  
接受并处理测试结果

import (
    	"fmt"
    	"httpPressureTest/model"
    	"sort"
    	"strings"
    	"sync"
    	"time"
    )
    
    var (
    	// 输出统计数据的时间
    	exportStatisticsTime = 1 * time.Second
    )
    
    // 接收结果并处理
    // 统计的时间都是纳秒，显示的时间 都是毫秒
    // concurrent 并发数
    func ReceivingResults(concurrent uint64, ch <-chan *model.RequestResults, wg *sync.WaitGroup) { 
    
    	defer func() { 
    		wg.Done()
    	}()
    
    	var (
    		stopChan = make(chan bool)
    	)
    
    	// 时间
    	var (
    		processingTime uint64 // 处理总时间
    		requestTime    uint64 // 请求总时间
    		maxTime        uint64 // 最大时长
    		minTime        uint64 // 最小时长
    		successNum     uint64 // 成功处理数，code为0
    		failureNum     uint64 // 处理失败数，code不为0
    		chanIdLen      int    // 并发数
    		chanIds        = make(map[uint64]bool)
    		receivedBytes  int64
    	)
    
    	statTime := uint64(time.Now().UnixNano())
    
    	// 错误码/错误个数
    	var errCode = make(map[int]int)
    
    	// 定时输出一次计算结果
    	ticker := time.NewTicker(exportStatisticsTime)
    	go func() { 
    		for { 
    			select { 
    			case <-ticker.C:
    				endTime := uint64(time.Now().UnixNano())
    				requestTime = endTime - statTime
    				go calculateData(concurrent, processingTime, requestTime, maxTime, minTime, successNum, failureNum, chanIdLen, errCode, receivedBytes)
    			case <-stopChan:
    				// 处理完成
    
    				return
    			}
    		}
    	}()
    
    	header()
    
    	for data := range ch { 
    		processingTime = processingTime + data.Time
    
    		if maxTime <= data.Time { 
    			maxTime = data.Time
    		}
    
    		if minTime == 0 { 
    			minTime = data.Time
    		} else if minTime > data.Time { 
    			minTime = data.Time
    		}
    
    		// 是否请求成功
    		if data.IsSucceed == true { 
    			successNum = successNum + 1
    		} else { 
    			failureNum = failureNum + 1
    		}
    
    		// 统计错误码
    		if value, ok := errCode[data.ErrCode]; ok { 
    			errCode[data.ErrCode] = value + 1
    		} else { 
    			errCode[data.ErrCode] = 1
    		}
    
    		receivedBytes += data.ReceivedBytes
    
    		if _, ok := chanIds[data.ChanId]; !ok { 
    			chanIds[data.ChanId] = true
    			chanIdLen = len(chanIds)
    		}
    	}
    
    	// 数据全部接受完成，停止定时输出统计数据
    	stopChan <- true
    
    	endTime := uint64(time.Now().UnixNano())
    	requestTime = endTime - statTime
    
    	calculateData(concurrent, processingTime, requestTime, maxTime, minTime, successNum, failureNum, chanIdLen, errCode, receivedBytes)
    
    	fmt.Printf("\n\n")
    
    	fmt.Println("************************* 结果 stat ****************************")
    	fmt.Println("处理协程数量:", concurrent)
    	fmt.Println("请求总数（并发数*请求数 -c * -n）:", successNum+failureNum, "总请求时间:", fmt.Sprintf("%.3f", float64(requestTime)/1e9),
    		"秒", "successNum:", successNum, "failureNum:", failureNum)
    
    	fmt.Println("************************* 结果 end ****************************")
    
    	fmt.Printf("\n\n")
    }
    
    // 计算数据
    func calculateData(concurrent, processingTime, requestTime, maxTime, minTime, successNum, failureNum uint64, chanIdLen int, errCode map[int]int, receivedBytes int64) { 
    	if processingTime == 0 { 
    		processingTime = 1
    	}
    
    	var (
    		qps              float64
    		averageTime      float64
    		maxTimeFloat     float64
    		minTimeFloat     float64
    		requestTimeFloat float64
    	)
    
    	// 平均 每个协程成功数*总协程数据/总耗时 (每秒)
    	if processingTime != 0 { 
    		qps = float64(successNum*1e9*concurrent) / float64(processingTime)
    	}
    
    	// 平均时长 总耗时/总请求数/并发数 纳秒=>毫秒
    	if successNum != 0 && concurrent != 0 { 
    		averageTime = float64(processingTime) / float64(successNum*1e6)
    	}
    
    	// 纳秒=>毫秒
    	maxTimeFloat = float64(maxTime) / 1e6
    	minTimeFloat = float64(minTime) / 1e6
    	requestTimeFloat = float64(requestTime) / 1e9
    
    	// 打印的时长都为毫秒
    	// result := fmt.Sprintf("请求总数:%8d|successNum:%8d|failureNum:%8d|qps:%9.3f|maxTime:%9.3f|minTime:%9.3f|平均时长:%9.3f|errCode:%v", successNum+failureNum, successNum, failureNum, qps, maxTimeFloat, minTimeFloat, averageTime, errCode)
    	// fmt.Println(result)
    	table(successNum, failureNum, errCode, qps, averageTime, maxTimeFloat, minTimeFloat, requestTimeFloat, chanIdLen, receivedBytes)
    }
    
    
    // 打印表头信息
    func header() { 
    	fmt.Printf("\n\n")
    	// 打印的时长都为毫秒 总请数
    	fmt.Println("─────┬───────┬───────┬───────┬────────┬────────┬────────┬────────┬────────┬────────┬────────")
    	result := fmt.Sprintf(" 耗时│ 并发数│ 成功数│ 失败数│ qps │最长耗时│最短耗时│平均耗时│下载字节│字节每秒│ 错误码")
    	fmt.Println(result)
    	// result = fmt.Sprintf("耗时(s) │总请求数│成功数│失败数│QPS│最长耗时│最短耗时│平均耗时│错误码")
    	// fmt.Println(result)
    	fmt.Println("─────┼───────┼───────┼───────┼────────┼────────┼────────┼────────┼────────┼────────┼────────")
    
    	return
    }
    
    // 打印表格
    func table(successNum, failureNum uint64, errCode map[int]int, qps, averageTime, maxTimeFloat, minTimeFloat, requestTimeFloat float64, chanIdLen int, receivedBytes int64) { 
    	var (
    		speed int64
    	)
    
    	if requestTimeFloat > 0 { 
    		speed = int64(float64(receivedBytes) / requestTimeFloat)
    	} else { 
    		speed = 0
    	}
    	// 打印的时长都为毫秒
    	result := fmt.Sprintf("%4.0fs│%7d│%7d│%7d│%8.2f│%8.2f│%8.2f│%8.2f│%8s|%8s│%v",
    		requestTimeFloat, chanIdLen, successNum, failureNum, qps, maxTimeFloat, minTimeFloat, averageTime,
    		fmt.Sprintf("%d", receivedBytes),
    		fmt.Sprintf("%d", speed),
    		printMap(errCode))
    	fmt.Println(result)
    
    	return
    }
    
    // 输出错误码、次数 节约字符(终端一行字符大小有限)
    func printMap(errCode map[int]int) (mapStr string) { 
    
    	var (
    		mapArr []string
    	)
    	for key, value := range errCode { 
    		mapArr = append(mapArr, fmt.Sprintf("%d:%d", key, value))
    	}
    
    	sort.Strings(mapArr)
    
    	mapStr = strings.Join(mapArr, ";")
    
    	return
    }

**golink.Http**  
发起请求

import (
    	"bytes"
    	"httpPressureTest/model"
    	"httpPressureTest/server/client"
    	"io/ioutil"
    	"net/http"
    	"sync"
    )
    
    type ReqListMany struct { 
    	list []*model.Request
    }
    
    func (r *ReqListMany) getCount() int { 
    	return len(r.list)
    }
    
    var (
    	clientList *ReqListMany
    )
    
    func init() { 
    	clientList = &ReqListMany{ }
    }
    
    func Http(chanId uint64, ch chan<- *model.RequestResults, totalNumber uint64, wg *sync.WaitGroup, request *model.Request) { 
    
    	defer func() { 
    		wg.Done()
    	}()
    
    	// fmt.Printf("启动协程 编号:%05d \n", chanId)
    	for i := uint64(0); i < totalNumber; i++ { 
    
    		list := getRequestList(request)
    
    		isSucceed, errCode, requestTime, contentLength := sendList(list)
    
    		requestResults := &model.RequestResults{ 
    			Time:          requestTime,
    			IsSucceed:     isSucceed,
    			ErrCode:       errCode,
    			ReceivedBytes: contentLength,
    		}
    
    		requestResults.SetId(chanId, i)
    
    		ch <- requestResults
    	}
    
    	return
    }
    
    func getRequestList(request *model.Request) []*model.Request { 
    
    	if len(clientList.list) <= 0 { 
    
    		return []*model.Request{ request}
    	}
    
    	return clientList.list
    }
    
    // 多个接口分步压测
    func sendList(requestList []*model.Request) (isSucceed bool, errCode int, requestTime uint64, contentLength int64) { 
    
    	errCode = model.HttpOk
    	for _, request := range requestList { 
    		succeed, code, u, length := send(request)
    		isSucceed = succeed
    		errCode = code
    		requestTime = requestTime + u
    		contentLength = contentLength + length
    		if succeed == false { 
    
    			break
    		}
    	}
    
    	return
    }
    
    var buf = make([]byte, 1024*1024)
    
    // send 发送一次请求
    func send(request *model.Request) (bool, int, uint64, int64) { 
    	var (
    		isSucceed     = false
    		errCode       = model.HttpOk
    		contentLength = int64(0)
    	)
    
    	newRequest := request
    
    	resp, requestTime, err := client.HttpRequest(newRequest.Method, newRequest.Url, newRequest.GetBody(), newRequest.Headers, newRequest.Timeout)
    	if err != nil { 
    		errCode = model.RequestErr // 请求错误
    	} else { 
    
    		contentLength = 0
    		for { 
    			n, err := resp.Body.Read(buf)
    			resp.Body = ioutil.NopCloser(bytes.NewReader(buf))
    			contentLength += int64(n)
    			if err != nil { 
    				break
    			}
    		}
    
    
    		// 验证请求是否成功
    		if resp.StatusCode == http.StatusOK { 
    			isSucceed = true
    		} else { 
    			errCode = resp.StatusCode
    		}
    
    	}
    	return isSucceed, errCode, requestTime, contentLength
    }

**client.HttpRequest**  
request的请求体处理

import (
    	"crypto/tls"
    	"fmt"
    	"io"
    	"net/http"
    	"time"
    )
    
    
    
    // HTTP 请求
    // method 方法 GET POST
    // url 请求的url
    // body 请求的body
    // headers 请求头信息
    // timeout 请求超时时间
    func HttpRequest(method, url string, body io.Reader, headers map[string]string, timeout time.Duration) (resp *http.Response, requestTime uint64, err error) { 
    
    	// 跳过证书验证
    	tr := &http.Transport{ 
    		TLSClientConfig: &tls.Config{ InsecureSkipVerify: true},
    	}
    
    	client := &http.Client{ 
    		Transport: tr,
    		Timeout:   timeout,
    	}
    
    	req, err := http.NewRequest(method, url, body)
    	if err != nil { 
    
    		return
    	}
    	// 在req中设置Host，解决在header中设置Host不生效问题
    	if _, ok := headers["Host"]; ok { 
    		req.Host = headers["Host"]
    	}
    	// 设置默认为utf-8编码
    	if _, ok := headers["Content-Type"]; !ok { 
    		if headers == nil { 
    			headers = make(map[string]string)
    		}
    		headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
    	}
    
    	for key, value := range headers { 
    		req.Header.Set(key, value)
    	}
    
    	startTime := time.Now()
    	resp, err = client.Do(req)
    	requestTime = uint64(time.Since(startTime))
    	if err != nil { 
    		fmt.Println("请求失败:", err)
    		return
    	}
    
    	return
    }

**model.request**  
存放实体类

import (
    	"fmt"
    	"io"
    	"net/http"
    	"strings"
    	"time"
    )
    
    const (
    	HttpOk         = 200 // 请求成功
    	RequestTimeout = 506 // 请求超时
    	RequestErr     = 509 // 请求错误
    	ParseError     = 510 // 解析错误
    
    	FormTypeHttp      = "http"
    	TimeOut  = 30 * time.Second
    
    )
    
    // 验证方法
    type VerifyHttp func(request *Request, response *http.Response) (code int, isSucceed bool)
    
    
    // 请求结果
    type Request struct { 
    	Url     string            // Url
    	Form    string            // http/webSocket/tcp
    	Method  string            // 方法 GET/POST/PUT
    	Headers map[string]string // Headers
    	Body    string            // body
    	Verify  string            // 验证的方法
    	Timeout time.Duration     // 请求超时时间
    	Debug   bool              // 是否开启Debug模式
    }
    
    func (r *Request) GetBody() (body io.Reader) { 
    	body = strings.NewReader(r.Body)
    
    	return
    }
    
    func (r *Request) GetDebug() bool { 
    
    	return r.Debug
    }
    
    
    // NewRequest
    // url 压测的url
    // verify 验证方法 在server/verify中 http 支持:statusCode、json webSocket支持:json
    // timeout 请求超时时间
    // debug 是否开启debug
    // path curl文件路径 http接口压测，自定义参数设置
    func NewRequest(url string, reqHeaders []string, reqBody string) (request *Request, err error) { 
    
    	var (
    		method  = "GET"
    		headers = make(map[string]string)
    		body    string
    	)
    
    	// body取值
    	if reqBody != "" { 
    		method = "POST"
    		body = reqBody
    		headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
    	}
    
    	// 获取请求头
    	for _, v := range reqHeaders { 
    		getHeaderValue(v, headers)
    	}
    
    	// url拼接
    	form := FormTypeHttp
    	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") { 
    		url = fmt.Sprintf("http://%s", url)
    	}
    
    	request = &Request{ 
    		Url:     url,
    		Form:    form,
    		Method:  strings.ToUpper(method),
    		Headers: headers,
    		Body:    body,
    		Timeout: TimeOut,
    	}
    
    	return
    
    }
    
    func getHeaderValue(v string, headers map[string]string) { 
    	index := strings.Index(v, ":")
    	if index < 0 { 
    		return
    	}
    
    	vIndex := index + 1
    	if len(v) >= vIndex { 
    		value := strings.TrimPrefix(v[vIndex:], " ")
    
    		if _, ok := headers[v[:index]]; ok { 
    			headers[v[:index]] = fmt.Sprintf("%s; %s", headers[v[:index]], value)
    		} else { 
    			headers[v[:index]] = value
    		}
    	}
    }
    
    // 打印
    func (r *Request) Print() { 
    	if r == nil { 
    
    		return
    	}
    
    	result := fmt.Sprintf("request:\n form:%s \n url:%s \n method:%s \n headers:%v \n", r.Form, r.Url, r.Method, r.Headers)
    	result = fmt.Sprintf("%s data:%v \n", result, r.Body)
    	result = fmt.Sprintf("%s \n timeout:%s \n debug:%v \n", result, r.Timeout, r.Debug)
    	fmt.Println(result)
    
    	return
    }
    
    
    // 请求结果
    type RequestResults struct { 
    	Id            string // 消息Id
    	ChanId        uint64 // 消息Id
    	Time          uint64 // 请求时间 纳秒
    	IsSucceed     bool   // 是否请求成功
    	ErrCode       int    // 错误码
    	ReceivedBytes int64
    }
    
    func (r *RequestResults) SetId(chanId uint64, number uint64) { 
    	id := fmt.Sprintf("%d_%d", chanId, number)
    
    	r.Id = id
    	r.ChanId = chanId
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA566A5Y2V6ZqP6aOO_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/b0f342e566e54349902b681bd803b462.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA566A5Y2V6ZqP6aOO_size_16_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/ffc268c575b64145be457c0c5950dcca.png