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

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

项目目录如下：

├── 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
}