Comment utiliser http.Transport dans Go pour implémenter le transfert de reprise de point d'arrêt de fichiers volumineux ?

Comment utiliser http.Transport dans Go pour implémenter le transfert de reprise de point d'arrêt de fichiers volumineux ?

Pendant le processus de transmission réseau, la transmission de fichiers volumineux prend souvent beaucoup de temps Afin d'améliorer l'efficacité et la stabilité de la transmission, la technologie de reprise du point d'arrêt est devenue une solution courante. Dans le langage Go, nous pouvons utiliser http.Transport pour implémenter le transfert de reprise de point d'arrêt de fichiers volumineux, rendant la transmission réseau plus stable et plus fiable. Cet article explique comment utiliser http.Transport pour implémenter la reprise du point d'arrêt et fournit des exemples de code correspondants.

1. Initialize http.Transport

Tout d'abord, nous devons initialiser un objet http.Transport, qui sera responsable de la transmission réseau. Nous pouvons contrôler certains détails de la transmission en configurant les paramètres de l'objet http.Transport.

transport := &http.Transport{
    MaxIdleConnsPerHost:   10,
    DisableCompression:    true,
    DisableKeepAlives:     true,
    ResponseHeaderTimeout: time.Second * 5,
}

Dans le code ci-dessus, nous définissons le nombre maximum de connexions inactives à 10, désactivons la compression et l'option de maintien des connexions, et définissons le délai d'expiration de l'en-tête de réponse à 5 secondes. Ces paramètres peuvent être ajustés en fonction des besoins réels.

2. Initier une requête HTTP

Ensuite, nous pouvons utiliser l'objet http.Transport pour lancer une requête HTTP. Avant de lancer une requête, nous devons construire un objet http.Request et spécifier l'URL demandée, la méthode de requête, l'en-tête de la requête et d'autres informations.

req, err := http.NewRequest("GET", "http://example.com/large_file.zip", nil)
if err != nil {
    log.Fatal(err)
}
// 添加断点续传的相关请求头信息
if fileInfo, err := os.Stat("local_file.zip"); err == nil {
    req.Header.Set("Range", "bytes="+strconv.FormatInt(fileInfo.Size(), 10)+"-")
}

Dans le code ci-dessus, nous avons créé une requête GET en utilisant la méthode http.NewRequest et spécifié l'URL du gros fichier à télécharger. Parallèlement, nous implémentons la reprise du point d'arrêt en définissant l'en-tête de requête "Range" en fonction de la taille du fichier local téléchargé.

3. Exécuter la requête HTTP

Une fois la requête construite, nous pouvons exécuter la requête HTTP via la méthode RoundTrip de l'objet http.Transport et obtenir le résultat de la réponse.

resp, err := transport.RoundTrip(req)
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusPartialContent {
    // 如果服务器未返回部分内容，无法进行断点续传
    log.Fatal("Server does not support partial content")
}

// 检查是否支持断点续传
contentRange := resp.Header.Get("Content-Range")
if contentRange == "" {
    // 如果服务器未返回Content-Range头部，无法进行断点续传
    log.Fatal("Server does not support content range")
}

// 获取已下载的文件大小
currentSize, err := getCurrentFileSize(contentRange)
if err != nil {
    log.Fatal(err)
}

Dans le code ci-dessus, nous vérifions d'abord si le serveur a renvoyé une partie du contenu (le code d'état est 206). Si le serveur ne renvoie pas une partie du contenu, il ne sera pas possible de reprendre le téléchargement. Ensuite, nous confirmons si le serveur prend en charge les téléchargements pouvant être repris en vérifiant le champ « Content-Range » dans l'en-tête de réponse. Si le serveur ne renvoie pas le champ « Content-Range », le téléchargement ne reprendra pas.

4. Téléchargement de fichiers

Si les étapes précédentes sont réussies, c'est-à-dire que le serveur prend en charge la reprise du point d'arrêt, nous pouvons commencer à télécharger le fichier et enregistrer le fichier localement.

out, err := os.OpenFile("local_file.zip", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
    log.Fatal(err)
}
defer out.Close()

_, err = io.Copy(out, resp.Body)
if err != nil {
    log.Fatal(err)
}

// 下载完成后，检查文件完整性
fileSize, err := getFileSize(contentRange)
if err != nil {
    log.Fatal(err)
}

if currentSize != fileSize {
    log.Fatal("Downloaded file size does not match")
}

fmt.Println("Download completed")

Dans le code ci-dessus, nous ouvrons d'abord un fichier local pour enregistrer le contenu téléchargé. Ensuite, le contenu de la réponse est écrit dans le fichier local via la fonction io.Copy. Enfin, nous vérifions que la taille du fichier téléchargé correspond à la taille du fichier renvoyé par le serveur pour garantir l'intégrité du fichier.

À ce stade, nous avons terminé le processus d'utilisation de http.Transport pour implémenter le transfert avec reprise de fichiers volumineux. Grâce aux étapes ci-dessus, nous pouvons améliorer l'efficacité et la stabilité de la transmission pendant la transmission réseau et garantir la transmission sûre des fichiers volumineux.

Résumé

Cet article explique comment utiliser http.Transport en langage Go pour implémenter le transfert de reprise de point d'arrêt de fichiers volumineux. En configurant correctement les paramètres de l'objet http.Transport, nous pouvons contrôler les détails de la transmission, tels que le nombre maximum de connexions inactives, la fonction de compression, le délai d'expiration de la demande, etc. Dans le même temps, nous pouvons implémenter la reprise du point d'arrêt en définissant l'en-tête de requête "Range" en fonction de la taille du fichier téléchargé. Enfin, nous écrivons le contenu de la réponse dans le fichier local via la fonction io.Copy et vérifions l'intégrité du fichier. Ces étapes peuvent nous aider à améliorer l’efficacité et la stabilité de la transmission lors des transferts de fichiers volumineux et à offrir une meilleure expérience utilisateur.

Code de référence : https://gist.github.com/anonymous/043cdf4cf58e183d08c5ad7d01c8db82

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!