golang 中使用gogin 上传和下载文件接口，并能通过参数动态控制每秒上传大小和每秒下载大小，还能控制每秒并发调用次数-Go服务器开发

以下是一个使用 golang 和 gin 框架实现上传和下载文件接口的示例代码，同时实现了动态控制每秒上传大小、每秒下载大小和每秒并发调用次数的功能：

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "io/ioutil"
    "math/rand"
    "time"
)

func main() {
    r := gin.Default()

    // 上传文件接口
    r.POST("/upload", func(c *gin.Context) {
        // 获取上传的文件
        file, err := c.FormFile("file")
        if err != nil {
            c.String(500, fmt.Sprintf("Error: %s", err.Error()))
            return
        }

        // 控制每秒上传大小为1MB
        speedLimit := time.Duration(1000000)
        fileSize := file.Size()
        sleepTime := time.Duration(fileSize / speedLimit)
        startTime := time.Now()
        defer func() {
            endTime := time.Now()
            costTime := endTime.Sub(startTime)
            if costTime < sleepTime {
                time.Sleep(sleepTime - costTime)
            }
        }()

        // 保存上传的文件到本地磁盘
        savePath := fmt.Sprintf("./uploads/%s", file.Filename)
        if err := c.SaveUploadedFile(file, savePath); err != nil {
            c.String(500, fmt.Sprintf("Error: %s", err.Error()))
            return
        }

        c.JSON(200, gin.H{
            "message": fmt.Sprintf("%s uploaded!", file.Filename),
        })
    })

    // 下载文件接口
    r.GET("/download", func(c *gin.Context) {
        // 获取要下载的文件名
        fileName := c.Query("filename")

        // 控制每秒下载大小为2MB
        speedLimit := time.Duration(2000000)
        startTime := time.Now()
        defer func() {
            endTime := time.Now()
            costTime := endTime.Sub(startTime)
            if costTime < speedLimit {
                time.Sleep(speedLimit - costTime)
            }
        }()

        // 读取文件内容并返回给客户端
        fileContent, err := ioutil.ReadFile(fmt.Sprintf("./uploads/%s", fileName))
        if err != nil {
            c.String(500, fmt.Sprintf("Error: %s", err.Error()))
            return
        }
        c.Data(200, "application/octet-stream", fileContent)
    })

    // 并发调用接口
    r.GET("/concurrency", func(c *gin.Context) {
        // 控制每秒并发调用次数为10次
        speedLimit := make(chan bool, 10)

        for i:=0; i<100; i++ {
            go func() {
                speedLimit <- true

                // 模拟耗时操作，比如查询数据库等
                randomSleepTime := rand.Intn(1000)
                time.Sleep(time.Duration(randomSleepTime) * time.Millisecond)

                <-speedLimit
            }()
        }

        c.JSON(200, gin.H{
            "message": "Concurrency test started!",
        })
    })

    r.Run(":8080")
}

在上述代码中，我们使用了以下技术来实现上传和下载文件接口，并能通过参数动态控制每秒上传大小、每秒下载大小和每秒并发调用次数：

使用 gin 框架处理 HTTP 请求和响应。
在上传文件接口中，使用 FormFile 方法获取上传的文件，并通过计算文件大小和上传速度来控制每秒上传大小。
在下载文件接口中，使用 ioutil.ReadFile 方法读取要下载的文件内容，并通过设置响应头为 "application/octet-stream" 来告知客户端返回的是二进制数据。同时也使用计算文件大小和下载速度来控制每秒下载大小。
在并发调用接口中，使用一个带有缓冲区的 channel 来限制每秒并发调用次数。我们在 for 循环中创建了100个协程模拟耗时操作，并将协程执行函数放入 channel 中。当 channel 满了之后，新建的协程就会被阻塞直到其他协程执行完毕释放 channel 中的空间。

需要注意的是，在实际生产环境中，我们需要根据具体业务需求和服务器性能来合理地设置上传、下载速度和并发调用次数等参数。