Est-il possible d'envelopper http.ServeHttp dans Go pour ajouter une session en utilisant alexedwards/scs/v2

Bonjour, éditeur php Zimo ! Concernant votre question sur l'encapsulation de http.ServeHTTP dans Go pour ajouter des sessions à l'aide d'alexedwards/scs/v2, la réponse est oui. Vous pouvez utiliser la bibliothèque alexedwards/scs/v2 pour gérer les sessions et envelopper http.ServeHTTP dans votre code Go. De cette façon, vous pouvez ajouter des fonctionnalités de gestion de sessions pour utiliser des sessions dans votre application lors du traitement des requêtes HTTP. De cette façon, vous pouvez facilement ajouter une authentification, une autorisation et d'autres fonctionnalités liées à la session à votre application. J'espère que cette réponse vous sera utile !

Contenu de la question

J'essaie d'ajouter des sessions à un serveur http existant écrit en go. J'ai le code suivant

type httpserver struct {
    getroutes  map[string]http.handlerfunc // pattern => handler
    postroutes map[string]http.handlerfunc
    server     http.server
}
func (s *httpserver) run() {
    address := "127.0.0.1:8080"
    s.server = http.server{
        addr:           address,
        handler:        s,
        readtimeout:    10 * time.second,
        writetimeout:   10 * time.second,
        maxheaderbytes: 1 << 20,
    }
    log.fatal(s.server.listenandserve())
}
func (s *httpserver) servehttp(writer http.responsewriter, r *http.request) {
     ...
}

Je souhaite utiliser l'ajout de session https://pkg.go.dev/github.com/alexedwards/scs/v2#sessionmanager.loadandsave

L'exemple de code dans le lien est

mux := http.NewServeMux()
    mux.HandleFunc("/put", putHandler)
    mux.HandleFunc("/get", getHandler)

    // Wrap your handlers with the LoadAndSave() middleware.
    http.ListenAndServe(":4000", sessionManager.LoadAndSave(mux))

L'exemple de code transmet mux à loadandsave, puis transmet le nouveau gestionnaire à http.listenandserve (port, newhandler). Dans mon cas, le gestionnaire provenait de la méthode servehttp que j'ai ajoutée à la structure *httpserver. Le gestionnaire dans l'exemple provient d'un multiplexeur.

Je suis nouveau ici. Est-il possible de transmettre ma méthode servehttp à Loadandsave et d'utiliser le gestionnaire renvoyé par Loadandsave ? Sinon, existe-t-il un moyen de transmettre les champs de structure http.server utilisés dans mon exemple dans http.listenandserve(port, handler) ?

Solution

Tout comme le func (s *httpserver) run(sessionmanager *scs.sessionmanager) { de peter adresse := "127.0.0.1:8080" // enveloppez votre serveur http avec le middleware loadandsave. handlerwithsessions := sessionmanager.loadandsave(s) ... }

Cela signifie créer et configurer sessionmanager en dehors de cette méthode (en utilisant scs. new( )sessionmanager （使用 scs.new())，并在调用 run), et transmis lors de l'appel de run.
Là, vous pouvez placer sessionmanager 设置为 httpserver champs dans la structure.
Cela permettra à votre (s *httpserver) servehttp(writer http.responsewriter, r *http.request) de le récupérer.

Par exemple :

package main

import (
    "github.com/alexedwards/scs/v2"
    "log"
    "net/http"
    "time"
)

type HttpServer struct {
    getRoutes     map[string]http.HandlerFunc // pattern => handler
    postRoutes    map[string]http.HandlerFunc
    server        http.Server
    sessionManager *scs.SessionManager
}

func (s *HttpServer) Run(sessionManager *scs.SessionManager) {
    address := "127.0.0.1:8080"
    
    // Set the sessionManager field
    s.sessionManager = sessionManager
    
    // Wrap your HttpServer with the LoadAndSave middleware.
    handlerWithSessions := sessionManager.LoadAndSave(s)
    
    s.server = http.Server{
        Addr:           address,
        Handler:        handlerWithSessions, // Use the wrapped handler
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }
    
    log.Fatal(s.server.ListenAndServe())
}

func (s *HttpServer) ServeHTTP(writer http.ResponseWriter, r *http.Request) {
    // Access the session via the sessionManager field
    session := s.sessionManager.Load(r)
    
    // Use the session, e.g. session.Put, session.Get, etc.
    // ...
}

func main() {
    // Create and configure the session manager
    sessionManager := scs.New()
    sessionManager.Lifetime = 24 * time.Hour
    
    // Create your custom HttpServer
    httpServer := &HttpServer{
        getRoutes:  make(map[string]http.HandlerFunc),
        postRoutes: make(map[string]http.HandlerFunc),
    }
    
    // Start the server with the session manager
    httpServer.Run(sessionManager)
}

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!