Golang implementiert eine Netzwerkfestplatte

In der heutigen Internetumgebung benötigen Menschen zunehmend Cloud-Speicherdienste wie Netzwerkfestplatten. Derzeit gibt es auf dem Markt beliebte Cloud-Speicherdienste wie Baidu Cloud, Weiyun, Dropbox usw. Allerdings genießen die Privatsphäre und die Sicherheit dieser Dienste bei den Menschen kein großes Vertrauen. Daher erfreut sich die Entwicklung einer Netzwerkfestplatte selbst zunehmender Beliebtheit.

In diesem Artikel wird erläutert, wie Sie mit Golang einen webbasierten Netzwerkfestplattendienst entwickeln. Golang ist eine von Google entwickelte Open-Source-Programmiersprache. Sie zeichnet sich durch hohe Parallelität, hohe Leistung, Einfachheit und Benutzerfreundlichkeit aus. Durch die Verwendung von Golang zur Entwicklung von Netzwerkfestplatten können schnell stabile und effiziente Dienste aufgebaut werden.

1. Umgebungsvorbereitung

Zuerst müssen wir die Golang-Umgebung installieren. Nach der Installation von Golang müssen wir mehrere notwendige Bibliotheken installieren:

• gin: ein leistungsstarkes Web-Framework für Golang, das zum schnellen Erstellen von RESTful-APIs verwendet wird.
• gorm: Golangs ORM-Bibliothek zur bequemen Datenbankmanipulation.

Nachdem die Installation abgeschlossen ist, können wir fröhlich mit dem Schreiben von Code beginnen.

2. Verwenden Sie das Gin-Framework, um eine RESTful-API zu erstellen.

In diesem Projekt verwenden wir das Gin-Framework, um einen Webdienst zu erstellen. Das Gin-Framework ist einfach und benutzerfreundlich und erfordert nahezu keinen Lernaufwand. Erstellen Sie zunächst eine main.go-Datei und schreiben Sie den folgenden Code:

package main

import "github.com/gin-gonic/gin"

func main() {
  // 创建Gin引擎
  r := gin.Default()

  // 路由
  r.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "pong",
    })
  })

  // 启动服务
  r.Run()
}

Dieser Code erstellt eine Gin-Engine und verwaltet eine /ping-Route. Führen Sie den Code aus: Führen Sie main.go aus und geben Sie dann http://localhost:8080/ping in den Browser ein. Sie können die Ausgabe sehen: {"message": "pong"}.

3. Dateivorgang

Als nächstes müssen wir Dateien hoch- und herunterladen. Um Dateien hoch- und herunterzuladen, müssen Sie zunächst eine Verbindung zur Datenbank herstellen, auf die Metainformationen der entsprechenden Datei zugreifen und dann auf die Datei selbst zugreifen oder sie herunterladen.

1. Datei-Metainformationen

Wir verwenden die MySQL-Datenbank, um Datei-Metainformationen zu speichern, einschließlich Dateiname, Dateigröße, Upload-Zeit, Dateispeicherpfad auf der Festplatte usw. In diesem Projekt verwenden wir die Gorm-Bibliothek, um eine Verbindung zur MySQL-Datenbank herzustellen. Fügen Sie den folgenden Code zu main.go hinzu:

import (
  "fmt"

  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mysql"
)

type File struct {
  ID      uint   `gorm:"primary_key"`
  Name    string `gorm:"type:varchar(255)"`
  Size    int64
  Path    string `gorm:"type:varchar(255)"`
  CreatedAt time.Time
}

var db *gorm.DB
var err error

func init() {
  db, err = gorm.Open("mysql", "root:password@/filestore?charset=utf8&parseTime=True&loc=Local")
  if err != nil {
    fmt.Println("连接数据库失败：", err.Error())
    return
  }

  db.AutoMigrate(&File{})
}

Der obige Code erstellt eine Dateistruktur, die einer Tabelle in der Datenbank entspricht. Verwenden Sie dann gorm.Open, um eine Verbindung zur MySQL-Datenbank herzustellen, und verwenden Sie den Befehl AutoMigrate, um automatisch eine Tabelle mit dem Namen „files“ in der Datenbank zu erstellen.

2. Datei-Upload

Im Gin-Framework können Sie Dateien mit der Post-Methode hochladen. Wir müssen vor dem Routing den folgenden Code hinzufügen, um die Middleware zum Hochladen von Dateien zu aktivieren:

r.Static("/static", "./static")
r.POST("/upload", func(c *gin.Context) {
  file, header, err := c.Request.FormFile("file")
  if err != nil {
    c.JSON(http.StatusBadRequest, gin.H{
      "msg": err.Error(),
    })
    return
  }
  defer file.Close()

  // 保存文件到本地
  filename := header.Filename
  filepath := fmt.Sprintf("./static/%s", filename)
  err = c.SaveUploadedFile(header, filepath)
  if err != nil {
    c.JSON(http.StatusInternalServerError, gin.H{
      "msg": err.Error(),
    })
      return
  }

  // 将文件元信息存入数据库
  size := header.Size
  f := File{
    Name:    filename,
    Size:    size,
    Path:    filepath,
    CreatedAt: time.Now(),
  }
  _,err = f.InsertFile()
  if err !=nil{
    c.JSON(http.StatusInternalServerError, gin.H{
        "msg": err.Error(),
    })
    return
  }
  c.JSON(http.StatusOK, gin.H{
    "msg": "Upload successful",
  })
})

Im obigen Code rufen wir die hochgeladene Datei erfolgreich aus dem Anforderungsformular ab und speichern die Datei dann auf unserem Server. Danach speichern wir die Dateimetainformationen in der Datenbank, wobei InsertFile() die Datenbankoperationsfunktion ist, die wir später erstellen.

3. Datei-Download

Wir schreiben eine einfache Download-Funktion, um den Dateiinhalt in die HTTP-Antwort für den Client-Download auszugeben. Der vollständige Code lautet wie folgt:

func (file File) GetFile() (err error) {
  //打开文件并读取文件内容
  f, err := os.Open(file.Path)
  if err != nil {
      return
  }
  defer f.Close()

  w := bufio.NewWriter(file)

  b := make([]byte, 100)
  n := 0
  for {
      n, err = f.Read(b)
      if err != nil && err != io.EOF{
          return
      }
      w.Write(b[:n])
      if n == 0{
          break
      }
  }
  w.Flush()
  return
}

r.GET("/download", func(c *gin.Context) {
  fileName := c.Query("name")
  if len(fileName) == 0 {
    c.JSON(http.StatusBadRequest, gin.H{
      "msg": "invalid parameter",
    })
    return
  }

  file := File{
    Name: fileName,
  }
  err = file.GetFile()
  if err !=nil{
    c.JSON(http.StatusInternalServerError, gin.H{
      "msg": err.Error(),
    })
    return
  }
  c.Writer.Header().Add("Content-Disposition", fmt.Sprintf("attachment;filename=%s", fileName))
  c.Writer.Header().Add("Content-Type", "application/octet-stream")
  c.File(file.Path)
})

4. Speicheroptimierung

In einer Umgebung mit hoher Parallelität müssen Datei-Upload und -Download effizient sein. Daher können wir verteilten Speicher verwenden, um dieses Problem zu optimieren. Es können CDN-Beschleunigung, Objektspeicherung und andere Methoden verwendet werden.

5. Vollständiger Code

Als nächstes hosten wir den vollständigen Code auf Git.

Erstellen Sie das Projektverzeichnis und führen Sie dann den folgenden Befehl im Terminal aus:

git init
echo "# fileServer" >> README.md
git commit -m "first commit"
git remote add origin git@github.com:username/fileServer.git
git push -u origin master

Den vollständigen Code finden Sie unter: https://github.com/username/fileServer.

Hinweis: Ersetzen Sie den Benutzernamen durch Ihren GitHub-Benutzernamen.

6. Zusammenfassung

In diesem Artikel wird hauptsächlich die Verwendung von Golang zur Entwicklung eines webbasierten Netzwerkfestplattendienstes vorgestellt. Durch diesen Artikel können wir die grundlegende Verwendung des Gin-Frameworks, der Gorm-Bibliothek und der MySQL-Datenbank verstehen und erfahren, wie Vorgänge wie das Hoch- und Herunterladen von Dateien implementiert werden. Der in diesem Artikel bereitgestellte vollständige Code kann den Lesern helfen, den in diesem Artikel beschriebenen Inhalt besser zu verstehen und bei praktischen Anwendungen zu helfen.

Das obige ist der detaillierte Inhalt vonGolang implementiert eine Netzwerkfestplatte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!