Téléchargement de pièces jointes dans Beego - Enrichissez votre application Web

Avec le développement continu des applications Web, les demandes des utilisateurs pour des fonctions et des expériences plus riches sont également de plus en plus élevées. Parmi eux, le téléchargement de pièces jointes est une fonction fondamentale et importante. Il permet non seulement aux utilisateurs de télécharger et de partager leurs propres fichiers, mais permet également aux développeurs de mettre en œuvre facilement une variété de scénarios commerciaux, tels que le téléchargement d'avatars, l'affichage d'images, le téléchargement de fichiers, etc. .

Beego est un framework web basé sur le langage Go. Il fournit une multitude de fonctions et d'outils, permettant aux développeurs de créer rapidement des applications web efficaces, évolutives et sécurisées. Dans Beego, vous pouvez facilement implémenter la fonction de téléchargement de pièces jointes dans les applications Web en utilisant son outil de téléchargement de pièces jointes intégré.

Dans cet article, nous présenterons comment utiliser la fonction de téléchargement de pièces jointes dans Beego, et donnerons quelques considérations pratiques et conseils d'optimisation.

1. Utilisez la fonction de téléchargement de pièces jointes de Beego

Dans Beego, la clé pour implémenter la fonction de téléchargement de pièces jointes est d'utiliser son outil de téléchargement de fichiers intégré - beego.Context.Input. Cet outil propose deux méthodes : RetrieveFile (récupérer les fichiers téléchargés) et SaveToFile (enregistrer les fichiers téléchargés sur le disque).

Ce qui suit est un exemple de code de téléchargement de pièce jointe simple :

// 控制器代码
func (c *AttachmentController) Post() {
    _, header, err := c.GetFile("att_file")
    if err != nil {
        // 处理上传失败的情况
        c.Data["json"] = map[string]interface{}{
            "code":    1,
            "message": "Upload failed",
        }
    } else {
        // 处理上传成功的情况
        err = c.SaveToFile("att_file", header.Filename)
        if err != nil {
            c.Data["json"] = map[string]interface{}{
                "code":    1,
                "message": "Save file failed",
            }
        } else {
            c.Data["json"] = map[string]interface{}{
                "code":    0,
                "message": "Upload success",
            }
        }
    }
    c.ServeJSON()
}

// 视图代码
<form method="post" enctype="multipart/form-data" action="/attachment/upload">
  <input type="file" name="att_file" required>
  <input type="submit" value="Upload">
</form>

Dans le code ci-dessus, nous obtenons le fichier téléchargé via la méthode c.GetFile("att_file") dans le contrôleur. Si la méthode renvoie une erreur, le téléchargement a échoué. , nous pouvons renvoyer les informations d'erreur correspondantes dans l'interface. Si le téléchargement réussit, enregistrez le fichier sur le disque via la méthode c.SaveToFile("att_file", header.Filename) et renvoyez les informations de réussite.

Il convient de noter que nous avons spécifié l'attribut enctype du formulaire en tant que type de données de formulaire en plusieurs parties via l'attribut enctype="multipart/form-data" dans la vue. En effet, le téléchargement de pièces jointes doit prendre en charge plusieurs types de fichiers. il est donc obligatoire d'utiliser cette propriété.

2. Configurations associées

Dans le développement réel, nous devons définir certains paramètres pour le téléchargement des pièces jointes, tels que la limite de taille de fichier, les types de fichiers autorisés à être téléchargés, le répertoire pour les fichiers téléchargés, etc.

Vous pouvez effectuer les configurations pertinentes dans le fichier de configuration dans beego.AppConfig, par exemple :

# 支持的文件类型
file_types = ["jpg", "jpeg", "png", "gif", "txt", "doc", "docx", "pdf"]

# 上传文件大小限制
file_size = 10 << 20

# 上传文件目录
attachment_dir = "static/upload"

Dans la configuration ci-dessus, nous limitons la taille des fichiers téléchargés par l'utilisateur à 10 Mo maximum (10 <<20 signifie converti en octets ), Les types de fichiers que les utilisateurs sont autorisés à télécharger incluent jpg, jpeg, png, gif, txt, doc, docx et pdf, et le répertoire de stockage des fichiers téléchargés est spécifié comme static/upload.

Il est à noter que la lecture des fichiers de configuration dans Beego est basée sur la lecture de variables d'environnement, qui peuvent être définies via la méthode os.Setenv ("nom de variable d'environnement", "valeur de variable"). Par exemple :

os.Setenv("file_types", `["jpg", "jpeg", "png", "gif", "txt", "doc", "docx", "pdf"]`)

3. Optimisation du téléchargement des pièces jointes

En plus de la mise en œuvre de la fonction de téléchargement de pièces jointes de base, nous devons également prêter attention à certains problèmes supplémentaires.

1. Mise à l'échelle de l'image

Dans les applications pratiques, nous devons généralement redimensionner et adapter les images téléchargées. Beego propose deux classes d'outils, ImageCropper et ImageFilter, qui peuvent facilement traiter les images. Par exemple :

import (
    "github.com/astaxie/beego/utils/captcha"
    "github.com/astaxie/beego/utils/captcha/drivers"
)

func (c *AttachmentController) Post() {
    f, h, err := c.GetFile("att_file")
    if err != nil {
        // 处理上传失败的情况
        c.Data["json"] = map[string]interface{}{
            "code":    1,
            "message": "Upload failed",
        }
    } else {
        // 处理上传成功的情况
        fileDir := beego.AppConfig.String("attachment_dir")
        fileName := beego.Date(time.Now(), "20060102150405")+filepath.Ext(h.Filename)
        fPath := fileDir + "/" + fileName
        err = c.SaveToFile("att_file", fPath)
        if err != nil {
            c.Data["json"] = map[string]interface{}{
                "code":    1,
                "message": "Save file failed",
            }
        } else {
            c.Data["json"] = map[string]interface{}{
                "code":    0,
                "message": "Upload success",
                "url":     "/"+fPath,
            }
            fUrl := beego.URLFor("AttachmentController.ShowAttachment", ":filename", fileName)
            c.Data["json"].(map[string]interface{})["url"] = fUrl
        }

        // 图片缩放
        scaleWidth := 800 // 等比例缩放至800
        imageCropper := captcha.NewImageCrop(captcha.DriverImaging, fPath)
        err := imageCropper.Resize(scaleWidth)
        if err != nil {
            beego.Error(err)
        }

        // 图片滤镜
        imageFilter := captcha.NewImageFilter(captcha.DriverImaging, fPath)
        err = imageFilter.Hue(-25).Saturation(10).Brightness(-10).Contrast(-5)
        if err != nil {
            beego.Error(err)
        }
    }
    c.ServeJSON()
}

Dans le code ci-dessus, nous utilisons les classes d'outils ImageCropper et ImageFilter pour obtenir respectivement une mise à l'échelle et un traitement des couleurs égaux.

2. Téléchargement bloqué

Pour certains fichiers plus volumineux, le téléchargement unique entraîne souvent des problèmes de décalage et de délai d'attente. Afin d'améliorer l'expérience utilisateur, nous pouvons utiliser la méthode de téléchargement par blocage. Beego fournit la classe d'outils MultipartReader, qui peut analyser et traiter les données de formulaire. Par exemple :

func (c *AttachmentController) ChunkUpload() {
    // 读取表单数据
    reader, _ := c.Ctx.Request.MultipartReader()
    var (
        bigFile *os.File
        noi     int
    )
    for {
        part, err := reader.NextPart()
        if err == io.EOF {
            // 读取完成
            break
        }
        if part.FileName() == "" {
            continue
        }
        fileName := part.FileName()
        bigFile, err = os.OpenFile("static/chunk/"+fileName, os.O_WRONLY|os.O_CREATE, 0666)
        defer bigFile.Close()
        if err != nil {
            c.Data["json"] = map[string]interface{}{
                "code":    1,
                "message": "Create file failed",
            }
            c.ServeJSON()
            return
        }
        buf := make([]byte, 1024*1024) // 1MB的缓存
        for {
            n := 0
            n, err = part.Read(buf)
            noi += n // 总共读取的字节数
            if err != nil {
                if err == io.EOF {
                    break
                } else {
                    c.Data["json"] = map[string]interface{}{
                        "code":    1,
                        "message": "Read file failed",
                    }
                    c.ServeJSON()
                    return
                }
            }
            if _, err = bigFile.Write(buf[:n]); err != nil {
                c.Data["json"] = map[string]interface{}{
                    "code":    1,
                    "message": "Write file failed",
                }
                c.ServeJSON()
                return
            }
        }
    }
    // 返回上传结果
    c.Data["json"] = map[string]interface{}{
        "code":     0,
        "message":  "Upload success",
        "fileSize": noi,
    }
    c.ServeJSON()
}

Dans le code ci-dessus, nous utilisons la classe d'outils MultipartReader pour lire les données du formulaire en morceaux, en lisant 1 Mo de données à chaque fois et en les écrivant dans un fichier temporaire. Enfin, nous fusionnons de manière asynchrone tous les fichiers fragmentés en un fichier complet.

4. Résumé

Dans cet article, nous avons présenté la fonction de téléchargement de pièces jointes dans Beego, et expliqué et optimisé certains problèmes pratiques. En utilisant l'outil de téléchargement de pièces jointes de Beego, nous pouvons facilement implémenter la fonction de téléchargement de pièces jointes de diverses applications Web, améliorant ainsi l'expérience utilisateur et l'efficacité du développement.

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!