Golang implémente le disque réseau

Dans l'environnement Internet actuel, les gens ont de plus en plus besoin de services de stockage cloud tels que les disques réseau. Il existe actuellement des services de stockage cloud populaires sur le marché, tels que Baidu Cloud, Weiyun, Dropbox, etc. Cependant, les gens ne font pas vraiment confiance à la confidentialité et à la sécurité de ces services. Par conséquent, développer soi-même un disque réseau est devenu un choix de plus en plus populaire.

Cet article expliquera comment utiliser Golang pour développer un service de disque réseau basé sur le Web. Golang est un langage de programmation open source développé par Google. Il présente les caractéristiques d'une concurrence élevée, de hautes performances, de simplicité et de facilité d'utilisation. L'utilisation de Golang pour développer des disques réseau peut rapidement créer des services stables et efficaces.

1. Préparation de l'environnement

Tout d'abord, nous devons installer l'environnement Golang. Après avoir installé Golang, nous devons installer plusieurs bibliothèques nécessaires :

• gin : un framework web hautes performances pour Golang, utilisé pour créer rapidement des API RESTful.
• gorm : la bibliothèque ORM de Golang pour une manipulation pratique des bases de données.

Une fois l'installation terminée, nous pouvons commencer à écrire du code avec bonheur.

2. Utilisez le framework Gin pour créer une API RESTful

Dans ce projet, nous utilisons le framework Gin pour créer un service Web. Le framework Gin est simple et facile à utiliser, avec presque aucun coût d'apprentissage. Créez d'abord un fichier main.go et écrivez le code suivant :

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

Ce code crée un moteur Gin et gère une route /ping. Exécutez le code : lancez main.go, puis saisissez http://localhost:8080/ping dans le navigateur, vous pouvez voir le résultat : {"message": "pong"}.

3. Opération de fichier

Ensuite, nous devons télécharger et télécharger des fichiers. Pour télécharger et télécharger des fichiers, vous devez d'abord vous connecter à la base de données, accéder aux métainformations du fichier correspondant, puis accéder ou télécharger le fichier lui-même.

1. Méta-informations de fichier

Nous utiliserons la base de données MySQL pour stocker les méta-informations de fichier, y compris le nom du fichier, la taille du fichier, l'heure de téléchargement, le chemin de stockage du fichier sur le disque, etc. Dans ce projet, nous utilisons la bibliothèque Gorm pour nous connecter à la base de données MySQL. Ajoutez le code suivant à main.go :

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

Le code ci-dessus crée une structure File, qui correspond à une table dans la base de données. Utilisez ensuite gorm.Open pour vous connecter à la base de données MySQL et utilisez la commande AutoMigrate pour créer automatiquement une table nommée « fichiers » dans la base de données.

2. Téléchargement de fichiers

Dans le framework Gin, utilisez la méthode Post pour télécharger des fichiers. Nous devons ajouter le code suivant avant le routage pour activer le middleware pour le téléchargement de fichiers :

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",
  })
})

Dans le code ci-dessus, nous obtenons avec succès le fichier téléchargé à partir du formulaire de demande, puis enregistrons le fichier sur notre serveur. Après cela, nous stockons les métainformations du fichier dans la base de données, où InsertFile() est la fonction d'opération de base de données que nous créons plus tard.

3. Téléchargement de fichiers

Nous écrivons une fonction de téléchargement simple pour afficher le contenu du fichier dans la réponse HTTP pour le téléchargement du client. Le code complet est le suivant :

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. Optimisation du stockage

Dans un environnement à forte concurrence, l'upload et le téléchargement de fichiers doivent être efficaces. Par conséquent, nous pouvons utiliser le stockage distribué pour optimiser ce problème. L'accélération CDN, le stockage d'objets et d'autres méthodes peuvent être utilisés.

5. Code complet

Ensuite, nous hébergerons le code complet sur Git.

Créez le répertoire du projet, puis exécutez la commande suivante dans le terminal :

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

Pour le code complet, veuillez vous référer à : https://github.com/username/fileServer.

Remarque : remplacez le nom d'utilisateur par votre nom d'utilisateur GitHub.

6. Résumé

Cet article présente principalement comment utiliser Golang pour développer un service de disque réseau basé sur le Web. Grâce à cet article, nous pouvons comprendre l'utilisation de base du framework Gin, de la bibliothèque Gorm et de la base de données MySQL, ainsi que comment implémenter des opérations telles que le téléchargement et le téléchargement de fichiers. Le code complet fourni dans cet article peut aider les lecteurs à mieux comprendre le contenu décrit dans cet article et faciliter les applications pratiques.

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!