Comment utiliser gRPC pour implémenter le téléchargement de fichiers dans Golang ?

Comment utiliser gRPC pour télécharger des fichiers ? Créez des définitions de service de support, y compris des messages de demande et de réponse. Sur le client, le fichier à télécharger est ouvert et divisé en morceaux, puis diffusé sur le serveur via un flux gRPC. Côté serveur, des fragments de fichiers sont reçus et stockés dans un fichier. Le serveur envoie une réponse une fois le téléchargement du fichier terminé pour indiquer si le téléchargement a réussi.

Comment utiliser gRPC pour implémenter le téléchargement de fichiers dans Golang

gRPC (Google Remote Procedure Call) est un framework d'appel de procédure à distance général, hautes performances et open source qui peut s'exécuter dans n'importe quel environnement. Il constitue un moyen efficace de transférer des données entre différentes machines et est idéal pour les situations où des fichiers volumineux doivent être transférés dans un système distribué.

Service d'assistance

Avant de commencer, vous devez créer un service d'assistance pour gérer les téléchargements de fichiers. Voici un exemple de définition de service :

// 文件上传服务接口
syntax = "proto3";

package file_upload;

service FileUploadService {
  rpc Upload(stream FileChunk) returns (FileUploadResponse);
}

// 文件块信息
message FileChunk {
  bytes data = 1;
}

// 文件上传响应
message FileUploadResponse {
  bool success = 1;
}

Implémentation du client gRPC

L'implémentation client de gRPC utilise le processus de téléchargement de fichiers comme suit :

package main

import (
    "context"
    "io"
    "log"

    file_upload "github.com/example/file-upload"
    "google.golang.org/grpc"
)

func main() {
    // 建立与服务的连接
    conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("连接服务失败: %v", err)
    }
    defer conn.Close()

    // 创建文件上传客户端
    client := file_upload.NewFileUploadServiceClient(conn)

    // 打开要上传的文件
    file, err := os.Open("example.txt")
    if err != nil {
        log.Fatalf("打开文件失败: %v", err)
    }
    defer file.Close()

    // 将文件分成块进行流式传输
    stream, err := client.Upload(context.Background())
    if err != nil {
        log.Fatalf("创建流式传输失败: %v", err)
    }

    // 循环读取文件并发送块
    buf := make([]byte, 1024)
    for {
        n, err := file.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("读取文件失败: %v", err)
        }

        // 发送块
        if err := stream.Send(&file_upload.FileChunk{Data: buf[:n]}); err != nil {
            log.Fatalf("发送块失败: %v", err)
        }
    }

    stream.CloseSend()

    // 接收上传响应
    resp, err := stream.Recv()
    if err != nil {
        log.Fatalf("接收上传响应失败: %v", err)
    }

    log.Printf("上传成功: %v", resp.Success)
}

Prise en charge de l'implémentation du service

Le serveur implémente la logique de réception et de traitement. fichiers téléchargés :

package main

import (
    "context"
    "io"
    "log"

    file_upload "github.com/example/file-upload"
)

func main() {
    // 创建文件上传服务
    server := &FileUploadService{}

    // 创建 gRPC 服务器并注册服务
    s := grpc.NewServer()
    file_upload.RegisterFileUploadServiceServer(s, server)

    lis, err := net.Listen("tcp", "127.0.0.1:50051")
    if err != nil {
        log.Fatalf("监听端口失败: %v", err)
    }

    // 启动 gRPC 服务器
    if err := s.Serve(lis); err != nil {
        log.Fatalf("启动 gRPC 服务器失败: %v", err)
    }
}

// FileUploadService 服务的具体实现
type FileUploadService struct{}

func (s *FileUploadService) Upload(stream file_upload.FileUploadService_UploadServer) error {
    file, err := os.Create("received.txt")
    if err != nil {
        return err
    }

    for {
        chunk, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }

        if _, err := file.Write(chunk.GetData()); err != nil {
            return err
        }
    }

    if err := stream.SendAndClose(&file_upload.FileUploadResponse{Success: true}); err != nil {
        return err
    }

    return nil
}

Le code ci-dessus montre comment utiliser gRPC pour implémenter le téléchargement de fichiers dans Golang. Le client divise le fichier en morceaux et les diffuse vers le serveur, qui est responsable de la réception et du traitement du fichier téléchargé.

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!