In diesem Tutorial erstellen wir einen leistungsstarken Downloader, der das Herunterladen von Dateien von Google Drive und anderen Cloud-Anbietern ermöglicht. Mit den effizienten Parallelitätsmustern von Golang können Sie mehrere Downloads gleichzeitig verwalten, große Dateien streamen und den Fortschritt in Echtzeit verfolgen. Unabhängig davon, ob Sie ein paar kleine Dateien herunterladen oder große Datenmengen verarbeiten, zeigt dieses Projekt, wie Sie einen skalierbaren und robusten Downloader erstellen, der problemlos erweitert werden kann, um mehrere Cloud-Plattformen zu unterstützen.
Wenn Sie nach einer Möglichkeit suchen, das Herunterladen großer Dateien zu vereinfachen und zu automatisieren, ist dieses Tutorial genau das Richtige für Sie. Am Ende verfügen Sie über einen flexiblen und anpassbaren Go-basierten Downloader, der Ihren Anforderungen entspricht.
Wenn Sie diesen Downloader nur mit einer Benutzeroberfläche verwenden möchten, besuchen Sie evolutionasdev.com, um den vollständigen Artikel zu lesen und Go Downloader's Github zu besuchen. Sie finden die Dokumente, um es schnell zum Laufen zu bringen.
Go-Parallelitätsmuster:
Erfahren Sie, wie Sie Goroutinen, Kanäle und Mutexe verwenden, um mehrere gleichzeitige Dateidownloads effizient abzuwickeln.
Große Downloads streamen:
Erfahren Sie, wie Sie große Dateien streamen und gleichzeitig Speicher und Systemressourcen effektiv verwalten.
Gleichzeitige Dateidownloads:
Erfahren Sie, wie Sie Dateien gleichzeitig herunterladen, den Prozess beschleunigen und die Leistung verbessern.
Fortschrittsaktualisierungen in Echtzeit:
Implementieren Sie eine Fortschrittsverfolgung, um Echtzeit-Feedback zum Download-Status zu geben.
Umgang mit Unterbrechungen und Stornierungen:
Erfahren Sie, wie Sie einen oder alle laufenden Downloads ordnungsgemäß abbrechen können.
Hinweis: Dieses Tutorial konzentriert sich nur auf die Kern-Download-Logik.
Bevor Sie etwas unternehmen, stellen Sie zunächst sicher, dass Sie Ihre Umgebung richtig einrichten, um potenzielle Fehler in Zukunft zu vermeiden.
Erstellen Sie mit Folgendem ein Makefile im Stammverzeichnis des Projekts.
# Load environment variables from .env file
include ./.env
# To run the application
run: build
@./bin/go-downloader
# Build the application
build:
@go build -tags '!dev' -o bin/go-downloader
# Database migration status
db-status:
@GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) status
# Run database migrations
up:
@GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) up
# Roll back the last database migration
down:
@GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) down
# Reset database migrations
reset:
@GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) reset
go-downloader/ ├── api ├── config ├── migrations ├── service ├── setting ├── store ├── types ├── util ├── .env ├── .air.toml ├── Makefile ├── go.mod ├── go.sum └── main.go
Erstellen Sie eine .env-Datei im Stammverzeichnis oder behandeln Sie Umgebungsvariablen nach Ihren Wünschen. Wir verwenden das Paket joho/godotenv.
GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRET SESSION_SECRET=something-super-secret APP_URL=http://localhost:3000 POSTGRES_USER POSTGRES_PASSWORD POSTGRES_DB
Wir beginnen nun mit der Erstellung des Webservers, der alle eingehenden Anfragen verarbeitet.
Achtung! Der Hauptteil dieses Leitfadens beginnt hier. Machen Sie sich bereit zum Eintauchen!
Erstellen Sie zunächst die folgenden Dateien im API-Ordner api.go und route.go
Alle API-Routen werden hierin definiert. Wir erstellen eine NewRouter-Struktur, die die Umgebungskonfiguration übernimmt und allen Routen und Handlern den Zugriff auf Umgebungsvariablen ermöglicht.
package api
import (
"github.com/gofiber/fiber/v2"
"github.com/nilotpaul/go-downloader/config"
)
type Router struct {
env config.EnvConfig
}
func NewRouter(env config.EnvConfig) *Router {
return &Router{
env: env,
}
}
func (h *Router) RegisterRoutes(r fiber.Router) {
r.Get("/healthcheck", func(c *fiber.Ctx) error {
return c.JSON("OK")
})
}
Hier fügen wir alle notwendigen Middlewares wie CORS und Protokollierung hinzu, bevor wir den Server starten.
type APIServer struct {
listenAddr string
env config.EnvConfig
}
func NewAPIServer(listenAddr string, env config.EnvConfig) *APIServer {
return &APIServer{
listenAddr: listenAddr,
env: env,
}
}
func (s *APIServer) Start() error {
app := fiber.New(fiber.Config{
AppName: "Go Downloader",
})
handler := NewRouter()
handler.RegisterRoutes(app)
log.Printf("Server started on http://localhost:%s", s.listenAddr)
return app.Listen(":" + s.listenAddr)
}
Dies ist das Hauptpaket in der Datei main.go, das als Einstiegspunkt für das Ganze fungiert.
func main() {
// Loads all Env vars from .env file.
env := config.MustLoadEnv()
log.Fatal(s.Start())
}
Dies reicht aus, um den Server zu starten und zu testen.
air
das ist es.?
curl http://localhost:3000/healthcheck
Die Antwort sollte OK sein und den Status 200 haben
Wir müssen eine skalierbare Lösung implementieren, um bei Bedarf Unterstützung für mehrere Cloud-Anbieter hinzuzufügen.
// Better to keep it in a seperate folder.
// Specific only to OAuth Providers.
type OAuthProvider interface {
Authenticate(string) error
GetAccessToken() string
GetRefreshToken() string
RefreshToken(*fiber.Ctx, string, bool) (*oauth2.Token, error)
IsTokenValid() bool
GetAuthURL(state string) string
CreateOrUpdateAccount() (string, error)
CreateSession(c *fiber.Ctx, userID string) error
UpdateTokens(*GoogleAccount) error
}
type ProviderRegistry struct {
Providers map[string]OAuthProvider
}
func NewProviderRegistry() *ProviderRegistry {
return &ProviderRegistry{
Providers: make(map[string]OAuthProvider),
}
}
func (r *ProviderRegistry) Register(providerName string, p OAuthProvider) {
r.Providers[providerName] = p
}
func (r *ProviderRegistry) GetProvider(providerName string) (OAuthProvider, error) {
p, exists := r.Providers[providerName]
if !exists {
return nil, fmt.Errorf("Provider not found")
}
return p, nil
}
Die ProviderRegistry dient als zentrale Karte für alle unsere OAuth-Anbieter. Wenn wir unsere Anbieter initialisieren, registrieren wir sie in dieser Karte. Dies ermöglicht uns den einfachen Zugriff auf die Funktionalitäten aller registrierten Anbieter während unseres gesamten Dienstes.
Sie werden diese Aktion später sehen.
Wir registrieren unsere Anbieter basierend auf den bereitgestellten Umgebungsvariablen.
func InitStore(env config.EnvConfig) *ProviderRegistry {
r := NewProviderRegistry()
if len(env.GoogleClientSecret) != 0 || len(env.GoogleClientID) != 0 {
googleProvider := NewGoogleProvider(googleProviderConfig{
googleClientID: env.GoogleClientID,
googleClientSecret: env.GoogleClientSecret,
googleRedirectURL: env.AppURL + "/callback/google",
}, env)
r.Register("google", googleProvider)
}
return r
}
Lesen Sie den vollständigen Artikel hier.
Wir haben den Grundstein für den Google Drive Downloader in Go gelegt und dabei wichtige Komponenten wie die Einrichtung der Projektstruktur, die Handhabung von Google OAuth und die Grundsteinlegung für zukünftige Erweiterungen abgedeckt. Unterwegs haben wir einige wichtige Themen angesprochen:
Das ist mehr als genug für einen Beitrag, da die Dinge ziemlich lang wurden! Wir werden in Teil 2 zurückkommen, um unsere Arbeit abzuschließen, wo wir die Haupt-Download-Funktionalität bearbeiten werden.
Bis dahin können Sie die aktuelle Implementierung gerne auf meinem GitHub erkunden und für die nächsten Schritte gespannt sein. Viel Spaß beim Herunterladen!
Das obige ist der detaillierte Inhalt vonErstellen eines Google Drive Downloaders in Golang (Teil 1). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So lösen Sie das Problem der langsamen Übertragung von Serverdomänennamen
So erstellen Sie Diagramme und Datenanalysediagramme in PPT
So beantragen Sie die Registrierung einer E-Mail-Adresse
So implementieren Sie die JSP-Paging-Funktion
So ändern Sie die Hosts-Datei
So verwenden Sie die Wertfunktion
Multifunktionsnutzung
Der Ordner wird zur Exe
