Hochladen von Anhängen in Beego – Machen Sie Ihre Webanwendung reicher

Mit der kontinuierlichen Weiterentwicklung von Webanwendungen werden auch die Anforderungen der Benutzer an umfassendere Funktionen und Erlebnisse immer höher. Unter diesen ist das Hochladen von Anhängen eine grundlegende und wichtige Funktion. Es ermöglicht Benutzern nicht nur das Hochladen und Teilen ihrer eigenen Dateien, sondern ermöglicht Entwicklern auch die einfache Implementierung verschiedener Geschäftsszenarien, wie z. B. das Hochladen von Avataren, die Anzeige von Bildern, das Herunterladen von Dateien usw .

Beego ist ein Web-Framework, das auf der Go-Sprache basiert. Es bietet eine Fülle von Funktionen und Tools, die es Entwicklern ermöglichen, schnell effiziente, skalierbare und sichere Webanwendungen zu erstellen. In Beego können Sie die Funktion zum Hochladen von Anhängen ganz einfach in Webanwendungen implementieren, indem Sie das integrierte Tool zum Hochladen von Anhängen verwenden.

In diesem Artikel stellen wir die Verwendung der Funktion zum Hochladen von Anhängen in Beego vor und geben einige praktische Überlegungen und Optimierungstipps.

1. Beegos Funktion zum Hochladen von Anhängen verwenden

In Beego liegt der Schlüssel zur Implementierung der Funktion zum Hochladen von Anhängen in der Verwendung des integrierten Tools zum Hochladen von Dateien – beego.Context.Input. Dieses Tool bietet zwei Methoden: RetrieveFile (hochgeladene Dateien abrufen) und SaveToFile (hochgeladene Dateien auf der Festplatte speichern).

Das Folgende ist ein einfacher Beispielcode für das Hochladen von Anhängen:

// 控制器代码
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>

Im obigen Code erhalten wir die hochgeladene Datei über die Methode c.GetFile("att_file") im Controller. Wenn die Methode err zurückgibt, ist der Upload fehlgeschlagen. können wir die entsprechenden Fehlerinformationen in der Schnittstelle zurückgeben. Wenn der Upload erfolgreich ist, speichern Sie die Datei über die Methode c.SaveToFile("att_file", header.Filename) auf der Festplatte und geben Sie Erfolgsinformationen zurück.

Es ist zu beachten, dass wir das enctype-Attribut des Formulars über das enctype="multipart/form-data"-Attribut in der Ansicht als mehrteiligen Formulardatentyp angegeben haben. Dies liegt daran, dass das Hochladen von Anhängen mehrere Dateitypen unterstützen muss. Daher ist es erforderlich, diese Eigenschaft zu verwenden.

2. Verwandte Konfigurationen

In der tatsächlichen Entwicklung müssen wir einige Einstellungen für das Hochladen von Anhängen vornehmen, wie z. B. Dateigrößenbeschränkung, Dateitypen, die hochgeladen werden dürfen, Verzeichnis für hochgeladene Dateien usw.

Sie können relevante Konfigurationen in der Konfigurationsdatei in beego.AppConfig vornehmen, zum Beispiel:

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

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

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

In der obigen Konfiguration begrenzen wir die Größe der vom Benutzer hochgeladenen Dateien auf nicht mehr als 10 MB (10<<20 bedeutet in Bytes umgewandelt). ), Zu den Dateitypen, die Benutzer hochladen dürfen, gehören jpg, jpeg, png, gif, txt, doc, docx und pdf, und das Speicherverzeichnis für hochgeladene Dateien ist als static/upload angegeben.

Es ist zu beachten, dass das Lesen von Konfigurationsdateien in Beego auf dem Lesen von Umgebungsvariablen basiert, die über die Methode os.Setenv („Umgebungsvariablenname“, „Variablenwert“) festgelegt werden können. Zum Beispiel:

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

3. Optimierung des Anhang-Uploads

Zusätzlich zur Implementierung der grundlegenden Funktion zum Hochladen von Anhängen müssen wir auch auf einige zusätzliche Probleme achten.

1. Bildskalierung

In praktischen Anwendungen müssen wir normalerweise hochgeladene Bilder skalieren und anpassen. Beego bietet zwei Werkzeugklassen, ImageCropper und ImageFilter, mit denen Bilder problemlos verarbeitet werden können. Zum Beispiel:

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()
}

Im obigen Code verwenden wir die Werkzeugklassen ImageCropper und ImageFilter, um eine gleiche Skalierung bzw. Farbverarbeitung des Bildes zu erreichen.

2. Blockierter Upload

Bei einigen größeren Dateien verursachen einmalige Uploads häufig Verzögerungen und Zeitüberschreitungen. Um das Benutzererlebnis zu verbessern, können wir die Block-Upload-Methode verwenden. Beego stellt die Toolklasse MultipartReader bereit, die Formulardaten analysieren und verarbeiten kann. Zum Beispiel:

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()
}

Im obigen Code verwenden wir die Toolklasse MultipartReader, um die Formulardaten in Blöcken zu lesen, wobei wir jedes Mal 1 MB Daten lesen und sie in eine temporäre Datei schreiben. Schließlich führen wir alle aufgeteilten Dateien asynchron zu einer vollständigen Datei zusammen.

4. Zusammenfassung

In diesem Artikel haben wir die Funktion zum Hochladen von Anhängen in Beego vorgestellt und einige praktische Probleme erläutert und optimiert. Durch die Verwendung des Beego-Tools zum Hochladen von Anhängen können wir die Funktion zum Hochladen von Anhängen verschiedener Webanwendungen einfach implementieren und so die Benutzererfahrung und Entwicklungseffizienz verbessern.

Das obige ist der detaillierte Inhalt vonHochladen von Anhängen in Beego – Machen Sie Ihre Webanwendung reicher. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!