之前使用beego的http庫的時候，有的情況需要下載檔案。beego是能實現，但就是有點問題:不支援回撥，沒法顯示下載速度,這在日常開發中是不可忍受的。
看了下beego的實現主要是使用了io.copy函式,於是就深入的看了下實現原理，發現挺簡單的，於是就根據io.copy原理實現的一個簡單的下載器

//定義要下載的檔案
var durl = "https://dl.google.com/go/go1.10.3.darwin-amd64.pkg";
//解析url
uri, err := url.ParseRequestURI(durl)
if err != nil {
    panic
 
("網址錯誤")
}

正常的一個流程先看看Url有沒有錯誤

filename := path.Base(uri.Path)
log.Println("[*] Filename " + filename)

使用path.Base取出url的檔名稱，這裡有個可能會出現bug的地方:如果這個網址是302跳轉過去的話是沒法取出跳轉過後的檔名稱。
取檔名稱這步可以再發送http請求的時候 client.CheckRedirect定義一個函式取出檔名次即可。

client := http.DefaultClient;
client.Timeout = time.Second * 60 //設定超時時間
 

resp, err := client.Get(durl)

建立一個httpClient,另外這個客戶端的Timeout是設定讀取資料的時候多少時間算超時。
我這裡比較推崇用Do方法傳遞一個Reqeust過去，應為有的url需要校驗http頭之類的,你問我為啥不用一個字懶。

raw := resp.Body
defer raw.Close()
reader := bufio.NewReaderSize(raw, 1024*32);

其實說實話不太清楚bufio能不能真正的加快htpp讀取速度，沒有做過跟不用bufio的對比。但是為了心理上的安心就加上去了

file, err := os.Create(filename)
if
 
 err != nil {
    panic(err)
}
writer := bufio.NewWriter(file)

同上也不太確定bufio能對檔案寫入增加多少速度

buff := make([]byte, 32*1024)
written := 0
go func() {
    for {
        nr, er := reader.Read(buff)
        if nr > 0 {
            nw, ew := writer.Write(buff[0:nr])
            if nw > 0 {
                written += nw
            }
            if ew != nil {
                err = ew
                break
            }
            if nr != nw {
                err = io.ErrShortWrite
                break
            }
        }
        if er != nil {
            if er != io.EOF {
                err = er
            }
            break
        }
    }
    if err != nil {
        panic(err)
    }
}()

這個原始碼是我直接複製io.copyBuffer函式的只是做了一些簡單的修改理解大概意思就行

//間隔時間
spaceTime := time.Second * 1
//定時器
ticker := time.NewTicker(spaceTime)
//上次讀取資料大小
lastWtn := 0
stop := false

for {
    select {
    case <-ticker.C:
        //這次讀取的檔案大小-上次讀取的資料大小=速度
        speed := written - lastWtn
        log.Printf("[*] Speed %s / %s \n", bytesToSize(speed), spaceTime.String())
        if written-lastWtn == 0 {
            ticker.Stop()
            stop = true
            break
        }
        lastWtn = written
    }
    if stop {
        break
    }
}

這段程式碼堵塞住程式，然後定時器按照間隔時間來計算速度。這裡可能會出現bug的地方就是在間隔時間內沒有讀取到資料的時候回直接跳出迴圈。現在這個時間點非常困，寫個blog已經困的要死了以後有空把這個bug解決了吧

func bytesToSize(length int) string {
    var k = 1024 // or 1024
    var sizes = []string{"Bytes", "KB", "MB", "GB", "TB"}
    if length == 0 {
        return "0 Bytes"
    }
    i := math.Floor(math.Log(float64(length)) / math.Log(float64(k)))
    r := float64(length) / math.Pow(float64(k), i)
    return strconv.FormatFloat(r, 'f', 3, 64) + " " + sizes[int(i)]
}

這個函式是我從我個人的php專案中轉換過來的

2018/08/17 00:24:50 [*] Filename go1.10.3.darwin-amd64.pkg
2018/08/17 00:24:51 [*] Speed 9.000 MB / 1s 
2018/08/17 00:24:52 [*] Speed 11.125 MB / 1s 
2018/08/17 00:24:53 [*] Speed 11.125 MB / 1s 
2018/08/17 00:24:54 [*] Speed 10.562 MB / 1s 
2018/08/17 00:24:55 [*] Speed 11.187 MB / 1s 
2018/08/17 00:24:56 [*] Speed 11.109 MB / 1s 
2018/08/17 00:24:57 [*] Speed 11.109 MB / 1s 
2018/08/17 00:24:58 [*] Speed 11.141 MB / 1s 
2018/08/17 00:24:59 [*] Speed 11.172 MB / 1s 
2018/08/17 00:25:00 [*] Speed 11.141 MB / 1s 
2018/08/17 00:25:01 [*] Speed 8.453 MB / 1s 
2018/08/17 00:25:02 [*] Speed 6.385 MB / 1s 
2018/08/17 00:25:03 [*] Speed 0 Bytes / 1s 

這是最終的執行結果，然後我再把全部的原始碼放在下面就去睡了。

package main

import (
    "net/http"
    "log"
    "time"
    "net/url"
    "path"
    "os"
    "io"
    "bufio"
    "math"
    "strconv"
)

var durl = "https://dl.google.com/go/go1.10.3.darwin-amd64.pkg";

func main() {
    uri, err := url.ParseRequestURI(durl)
    if err != nil {
        panic("網址錯誤")
    }

    filename := path.Base(uri.Path)
    log.Println("[*] Filename " + filename)

    client := http.DefaultClient;
    client.Timeout = time.Second * 60 //設定超時時間
    resp, err := client.Get(durl)
    if err != nil {
        panic(err)
    }
    if resp.ContentLength <= 0 {
        log.Println("[*] Destination server does not support breakpoint download.")
    }
    raw := resp.Body
    defer raw.Close()
    reader := bufio.NewReaderSize(raw, 1024*32);


    file, err := os.Create(filename)
    if err != nil {
        panic(err)
    }
    writer := bufio.NewWriter(file)

    buff := make([]byte, 32*1024)
    written := 0
    go func() {
        for {
            nr, er := reader.Read(buff)
            if nr > 0 {
                nw, ew := writer.Write(buff[0:nr])
                if nw > 0 {
                    written += nw
                }
                if ew != nil {
                    err = ew
                    break
                }
                if nr != nw {
                    err = io.ErrShortWrite
                    break
                }
            }
            if er != nil {
                if er != io.EOF {
                    err = er
                }
                break
            }
        }
        if err != nil {
            panic(err)
        }
    }()

    spaceTime := time.Second * 1
    ticker := time.NewTicker(spaceTime)
    lastWtn := 0
    stop := false

    for {
        select {
        case <-ticker.C:
            speed := written - lastWtn
            log.Printf("[*] Speed %s / %s \n", bytesToSize(speed), spaceTime.String())
            if written-lastWtn == 0 {
                ticker.Stop()
                stop = true
                break
            }
            lastWtn = written
        }
        if stop {
            break
        }
    }
}

func bytesToSize(length int) string {
    var k = 1024 // or 1024
    var sizes = []string{"Bytes", "KB", "MB", "GB", "TB"}
    if length == 0 {
        return "0 Bytes"
    }
    i := math.Floor(math.Log(float64(length)) / math.Log(float64(k)))
    r := float64(length) / math.Pow(float64(k), i)
    return strconv.FormatFloat(r, 'f', 3, 64) + " " + sizes[int(i)]
}