Comment contrôler efficacement les en-têtes HTTP dans Go Middleware ?

Contrôle des en-têtes HTTP avec un middleware Go externe

Problème : remplacement des en-têtes de serveur dans le middleware

Vous êtes confronté à un scénario dans lequel vous avez un middleware dans Go qui tente de définir un en-tête "Serveur" personnalisé. Cependant, les en-têtes « Serveur » existants définis par l'application ou un autre middleware persistent, ce qui entraîne plusieurs en-têtes « Serveur » dans la réponse.

Modification d'en-tête non autorisée

Conformément à la sémantique HTTP, modification des en-têtes de réponse après le retour de la méthode ServeHTTP est interdit. Cette restriction vise à établir des limites claires entre le traitement des demandes et la finalisation de la réponse.

Solutions proposées

1. Custom ResponseWriter :

Définissez un wrapper ResponseWriter personnalisé qui intercepte les opérations de modification d'en-tête. Avant d'écrire des en-têtes, le wrapper insère votre en-tête "Serveur" personnalisé. Cette approche ajoute une couche supplémentaire d'indirection mais fournit un contrôle précis sur la gestion des en-têtes.

Voici un exemple d'implémentation d'un ResponseWriter personnalisé :

type serverWriter struct {
    w           http.ResponseWriter
    name        string
    wroteHeader bool
}

func (s serverWriter) WriteHeader(code int) {
    if s.wroteHeader == false {
        s.w.Header().Set("Server", s.name)
        s.wroteHeader = true
    }
    s.w.WriteHeader(code)
}

func (s serverWriter) Write(b []byte) (int, error) {
    return s.w.Write(b)
}

func (s serverWriter) Header() http.Header {
    return s.w.Header()
}

Dans le middleware, vous pouvez utiliser ceci ResponseWriter personnalisé pour contrôler l'insertion d'en-tête :

func Server(h http.Handler, serverName string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        sw := serverWriter{
            w:           w,
            name:        serverName,
            wroteHeader: false,
        }
        h.ServeHTTP(sw, r)
    })
}

2. Inversion de l'ordre des middlewares :

Une approche alternative consiste à inverser l'ordre des middlewares de telle sorte que votre middleware de définition d'en-tête « Serveur » soit exécuté après tous les autres middlewares. Cela garantit que votre modification d'en-tête est la dernière opération avant que la réponse ne soit finalisée.

3. Middleware le plus interne :

Si possible, placez votre middleware de configuration d'en-tête « Serveur » comme couche la plus interne du middleware. Cela élimine la possibilité qu'un middleware externe modifie l'en-tête "Serveur" après l'avoir défini.

4. Modification de la réponse :

En dernier recours, vous pouvez envisager d'utiliser un http.Handler personnalisé qui intercepte la réponse et modifie l'en-tête « Serveur » en conséquence. Cette approche nécessite une manipulation prudente pour éviter de casser d'autres fonctionnalités de votre application.

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!