Golang实现http server提供压缩文件下载功能

最近遇到了一个下载静态html报表的需求，需要以提供压缩包的形式完成下载功能，实现的过程中发现相关文档非常杂，故总结一下自己的实现。

开发环境：

系统环境：macos + chrome
框架：beego
压缩功能：tar + gzip
目标压缩文件：自带数据和全部包的静态html文件

首先先提一下http server文件下载的实现，其实就是在后端返回前端的数据包中，将数据头设置为下载文件的格式，这样前端收到返回的响应时，会直接触发下载功能(就像时平时我们在chrome中点击下载那样)
数据头设置格式如下：

func (c *controller)download() {
  //...文件信息的产生逻辑
  //
  //rw为responsewriter
  rw := c.ctx.responsewriter
  //规定下载后的文件名
  rw.header().set("content-disposition", "attachment; filename="+"(文件名字)")
  rw.header().set("content-description", "file transfer")
  //标明传输文件类型
  //如果是其他类型，请参照：https://www.runoob.com/http/http-content-type.html
  rw.header().set("content-type", "application/octet-stream")
  rw.header().set("content-transfer-encoding", "binary")
  rw.header().set("expires", "0")
  rw.header().set("cache-control", "must-revalidate")
  rw.header().set("pragma", "public")
  rw.writeheader(http.statusok)
  //文件的传输是用byte slice类型，本例子中：b是一个bytes.buffer，则需调用b.bytes()
  http.servecontent(rw, c.ctx.request, "(文件名字)", time.now(), bytes.newreader(b.bytes()))
}

这样，beego后端就会将在头部标记为下载文件的数据包发送给前端，前端收到后会自动启动下载功能。

然而这只是最后一步的情况，如何将我们的文件先进行压缩再发送给前端提供下载呢？

如果需要下载的不只一个文件，需要用tar打包，再用gzip进行压缩，实现如下：

  //最内层用bytes.buffer来进行文件的存储
  var b bytes.buffer
  //嵌套tar包的writter和gzip包的writer
  gw := gzip.newwriter(&b)
  tw := tar.newwriter(gw)


  datafile := //...文件的产生逻辑，datafile为file类型
  info, _ := datafile.stat()
  header, _ := tar.fileinfoheader(info, "")
  //下载后当前文件的路径设置
  header.name = "report" + "/" + header.name
  err := tw.writeheader(header)
  if err != nil {
    utils.logerrorln(err.error())
    return
  }
  _, err = io.copy(tw, datafile)
  if err != nil {
    utils.logerrorln(err.error())
  }
  //...可以继续添加文件
  //tar writer 和 gzip writer的关闭顺序一定不能反
  tw.close()
  gw.close()

最后和中间步骤完成了，我们只剩file文件的产生逻辑了，由于是静态html文件，我们需要把所有html引用的依赖包全部完整的写入到生成的文件中的<script>和<style>标签下。此外，在本例子中，报告部分还需要一些静态的json数据来填充表格和图像，这部分数据是以map存储在内存中的。当然可以先保存成文件再进行上面一步的打包压缩，但是这样会产生并发的问题，因此我们需要先将所有的依赖包文件和数据写入一个byte.buffer中，最后将这个byte.buffer转回file格式。

golang中并没有写好的byte.buffer转文件的函数可以用，于是我们需要自己实现。

实现如下：

type myfileinfo struct {
  name string
  data []byte
}

func (mif myfileinfo) name() string    { return mif.name }
func (mif myfileinfo) size() int64    { return int64(len(mif.data)) }
func (mif myfileinfo) mode() os.filemode { return 0444 }    // read for all
func (mif myfileinfo) modtime() time.time { return time.time{} } // return whatever you want
func (mif myfileinfo) isdir() bool    { return false }
func (mif myfileinfo) sys() interface{}  { return nil }

type myfile struct {
  *bytes.reader
  mif myfileinfo
}

func (mf *myfile) close() error { return nil } // noop, nothing to do

func (mf *myfile) readdir(count int) ([]os.fileinfo, error) {
  return nil, nil // we are not a directory but a single file
}

func (mf *myfile) stat() (os.fileinfo, error) {
  return mf.mif, nil
}

依赖包和数据的写入逻辑：

func testwrite(data map[string]interface{}, taskid string) http.file {
  //最后生成的html，打开html模版
  tempfilep, _ := os.open("views/traffic/generatepage.html")
  info, _ := tempfilep.stat()
  html := make([]byte, info.size())
  _, err := tempfilep.read(html)
  // 将data数据写入html
  var b bytes.buffer
  // 创建json编码器
  encoder := json.newencoder(&b)

  err = encoder.encode(data)
  if err != nil {
    utils.logerrorln(err.error())
  }
  
  // 将json数据添加到html模版中
  // 方式为在html模版中插入一个特殊的替换字段，本例中为{data_json_source}
  html = bytes.replace(html, []byte("{data_json_source}"), b.bytes(), 1)

  // 将静态文件添加进html
  // 如果是.css,则前后增加<style></style>标签
  // 如果是.js,则前后增加<script><script>标签
  allstaticfiles := make([][]byte, 0)
  // jquery 需要最先进行添加
  tempfilename := "static/report/jquery.min.js"

  tempfilep, _ = os.open(tempfilename)
  info, _ = os.stat(tempfilename)
  curfilebyte := make([]byte, info.size())
  _, err = tempfilep.read(curfilebyte)

  allstaticfiles = append(allstaticfiles, []byte("<script>"))
  allstaticfiles = append(allstaticfiles, curfilebyte)
  allstaticfiles = append(allstaticfiles, []byte("</script>"))
  //剩下的所有静态文件
  staticfiles, _ := ioutil.readdir("static/report/")
  for _, tempfile := range staticfiles {
    if tempfile.name() == "jquery.min.js" {
      continue
    }
    tempfilename := "static/report/" + tempfile.name()

    tempfilep, _ := os.open(tempfilename)
    info, _ := os.stat(tempfilename)
    curfilebyte := make([]byte, info.size())
    _, err := tempfilep.read(curfilebyte)
    if err != nil {
      utils.logerrorln(err.error())
    }
    if isjs, _ := regexp.matchstring(`\.js$`, tempfilename); isjs {
      allstaticfiles = append(allstaticfiles, []byte("<script>"))
      allstaticfiles = append(allstaticfiles, curfilebyte)
      allstaticfiles = append(allstaticfiles, []byte("</script>"))
    } else if iscss, _ := regexp.matchstring(`\.css$`, tempfilename); iscss {
      allstaticfiles = append(allstaticfiles, []byte("<style>"))
      allstaticfiles = append(allstaticfiles, curfilebyte)
      allstaticfiles = append(allstaticfiles, []byte("</style>"))
    }
    tempfilep.close()
  }
  
  // 转成http.file格式进行返回
  mf := &myfile{
    reader: bytes.newreader(html),
    mif: myfileinfo{
      name: "report.html",
      data: html,
    },
  }
  var f http.file = mf
  return f
}

ok！ 目前为止，后端的文件生成->打包->压缩都已经做好啦，我们把他们串起来：

func (c *controller)download() {
  var b bytes.buffer
  gw := gzip.newwriter(&b)

  tw := tar.newwriter(gw)

  // 生成动态report,并添加进压缩包
  // 调用上文中的testwrite方法
  datafile := testwrite(responsebyrules, strtaskid)
  info, _ := datafile.stat()
  header, _ := tar.fileinfoheader(info, "")
  header.name = "report_" + strtaskid + "/" + header.name
  err := tw.writeheader(header)
  if err != nil {
    utils.logerrorln(err.error())
    return
  }
  _, err = io.copy(tw, datafile)
  if err != nil {
    utils.logerrorln(err.error())
  }

  tw.close()
  gw.close()
  rw := c.ctx.responsewriter
  rw.header().set("content-disposition", "attachment; filename="+"report_"+strtaskid+".tar.gz")
  rw.header().set("content-description", "file transfer")
  rw.header().set("content-type", "application/octet-stream")
  rw.header().set("content-transfer-encoding", "binary")
  rw.header().set("expires", "0")
  rw.header().set("cache-control", "must-revalidate")
  rw.header().set("pragma", "public")
  rw.writeheader(http.statusok)
  http.servecontent(rw, c.ctx.request, "report_"+strtaskid+".tar.gz", time.now(), bytes.newreader(b.bytes()))
}

后端部分已经全部实现了，前端部分如何接收呢，本例中我做了一个按钮嵌套<a>标签来进行请求:

<a href="/traffic/download_indicator?task_id={{$.taskid}}&task_type={{$.tasktype}}&status={{$.status}}&agent_addr={{$.agentaddr}}&glaucus_addr={{$.glaucusaddr}}" rel="external nofollow" >
   <button style="font-family: 'simhei';font-size: 14px;font-weight: bold;color: #0d6aad;text-decoration: underline;margin-left: 40px;" type="button" class="btn btn-link">下载报表</button>
</a>

这样，当前端页面中点击下载报表按钮之后，会自动启动下载，下载我们后端传回的report.tar.gz文件。

到此这篇关于golang实现http server提供压缩文件下载功能的文章就介绍到这了,更多相关golang http server 压缩下载内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！