GoLang sert conditionnellement .js.gz s'il est présent, sinon .js-Golang-php.cn

GoLang sert conditionnellement .js.gz s'il est présent, sinon .js

WBOY

Libérer： 2024-02-09 20:36:09

avant

395 Les gens l'ont consulté

GoLang 有条件地提供 .js.gz（如果存在），否则提供 .js

éditeur php Apple a souligné lors de l'introduction de GoLang que GoLang a une fonctionnalité intéressante et pratique, c'est-à-dire que lors de la fourniture de fichiers JavaScript, il fournira conditionnellement le fichier .js.gz (s'il existe), sinon il le fournira Fichiers .js. Cette fonctionnalité peut réduire efficacement la taille des fichiers, améliorer la vitesse de chargement des pages Web et offrir aux utilisateurs une meilleure expérience. Ce mécanisme intelligent de sélection de fichiers rend GoLang plus efficace et plus flexible dans le développement Web. Qu'il s'agisse de développement front-end ou back-end, GoLang est un excellent langage de programmation qui mérite d'être exploré.

Contenu de la question

Mon expérience est principalement dans React/Frontend, mais j'ai été chargé d'améliorer les performances de notre application Web React, qui est servie à l'aide de GoLang et extraite de S3 à l'aide du document AWS SDK for Go. J'ai configuré Webpack pour faire son travail et utiliser autant de fonctionnalités d'optimisation que possible, notamment en utilisant son plugin de compression pour créer des fichiers .js.gz compressés par gzip ainsi que les fichiers .js dans le bundle déployé sur S3.

Ma question est la suivante : existe-t-il un moyen dans Go et aws sdk, lorsqu'il récupère un fichier d'un compartiment s3, de déterminer d'abord si une forme compressée gzip du fichier existe, puis d'obtenir le fichier, sinon, d'obtenir le fichier normal ? Est-ce la meilleure façon de résoudre ce problème ? Je sais qu'il existe une bibliothèque pour la compression d'exécution dans Go, mais il semble plus efficace d'effectuer la compression à l'avance.

La partie serveur Go est très petite et a une fonction pour obtenir des fichiers de compartiment qui crée essentiellement un client s3, puis utilise la méthode getObject sur ce client pour obtenir le contenu de ce compartiment, puis utilise la méthode .write de http qui contient le corps. de ce contenu.

Solution

Oui, vous pouvez envoyer directement la version compressée.

Voici un exemple :

package main

import (
    "fmt"
    "net/http"
    "strings"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func getFileFromS3(bucket, key string, w http.ResponseWriter, r *http.Request) error {
    sess, err := session.NewSession(&aws.Config{
        Region: aws.String("your-region"),
        // Add other necessary configurations
    })
    if err != nil {
        return err
    }

    client := s3.New(sess)

    // Check if gzipped version exists
    gzKey := key + ".gz"
    _, err = client.HeadObject(&s3.HeadObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(gzKey),
    })
    if err == nil {
        // Gzipped version exists, fetch and serve directly
        obj, err := client.GetObject(&s3.GetObjectInput{
            Bucket: aws.String(bucket),
            Key:    aws.String(gzKey),
        })
        if err != nil {
            return err
        }
        defer obj.Body.Close()

        // Set appropriate headers
        w.Header().Set("Content-Encoding", "gzip")
        w.Header().Set("Content-Type", "application/javascript") // Set the appropriate content type

        // Copy the gzipped content directly to the response
        _, err = fmt.Fprint(w, obj.Body)
        return err
    }

    // Gzipped version doesn't exist, fetch the regular version
    obj, err := client.GetObject(&s3.GetObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(key),
    })
    if err != nil {
        return err
    }
    defer obj.Body.Close()

    // Set appropriate headers
    w.Header().Set("Content-Type", "application/javascript") // Set the appropriate content type

    // Copy the regular content directly to the response
    _, err = fmt.Fprint(w, obj.Body)
    return err
}

func handler(w http.ResponseWriter, r *http.Request) {
    // Extract the file key from the request URL or any other way you have it
    fileKey := "your-file-key"

    // Set appropriate cache headers, handle CORS, etc.

    // Fetch the file from S3
    err := getFileFromS3("your-s3-bucket", fileKey, w, r)
    if err != nil {
        // Handle error, e.g., return a 404 or 500 response
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }
}

func main() {
    http.HandleFunc("/your-endpoint", handler)
    http.ListenAndServe(":8080", nil)
}

Copier après la connexion

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!