kann nicht Gorilla Sitzungswert von Schlüssel

Question

bekommt ich nicht Wert aus der Session auf diese Weise erhalten kann, ist es nil:

session := initSession(r) 
valWithOutType := session.Values[key] 

Voll Code:

package main 

import (
    "fmt" 
    "github.com/gorilla/mux" 
    "github.com/gorilla/sessions" 
    "log" 
    "net/http" 
) 

func main() { 
    rtr := mux.NewRouter() 
    rtr.HandleFunc("/setSession", handler1).Methods("GET") 
    rtr.HandleFunc("/getSession", handler2).Methods("GET") 
    http.Handle("/", rtr) 
    log.Println("Listening...") 
    http.ListenAndServe(":3000", http.DefaultServeMux) 
} 

func handler1(w http.ResponseWriter, r *http.Request) { 
    SetSessionValue(w, r, "key", "value") 
    w.Write([]byte("setSession")) 
} 

func handler2(w http.ResponseWriter, r *http.Request) { 
    w.Write([]byte("getSession")) 
    value := GetSessionValue(w, r, "key") 
    fmt.Println("value from session") 
    fmt.Println(value) 
} 

var authKey = []byte("secret") // Authorization Key 

var encKey = []byte("encKey") // Encryption Key 

var store = sessions.NewCookieStore(authKey, encKey) 

func initSession(r *http.Request) *sessions.Session { 
    store.Options = &sessions.Options{ 
     MaxAge: 3600 * 1, // 1 hour 
     HttpOnly: true, 
    } 
    session, err := store.Get(r, "golang_cookie") 
    if err != nil { 
     panic(err) 
    } 

    return session 
} 

func SetSessionValue(w http.ResponseWriter, r *http.Request, key, value string) { 
    session := initSession(r) 
    session.Values[key] = value 
    fmt.Printf("set session with key %s and value %s\n", key, value) 
    session.Save(r, w) 
} 

func GetSessionValue(w http.ResponseWriter, r *http.Request, key string) string { 
    session := initSession(r) 
    valWithOutType := session.Values[key] 
    fmt.Printf("valWithOutType: %s\n", valWithOutType) 
    value, ok := valWithOutType.(string) 
    if !ok { 
     fmt.Println("cannot get session value by key: " + key) 
    } 
    return value 
} 

Ausgang:

myMac ~/forStack/session $ go run ./session.go 
2015/01/30 16:47:26 Listening... 

Erste Ich öffne URL http://localhost:3000/setSession und bekomme Ausgabe:

set session with key key and value value 

Dann öffne ich url http://localhost:3000/getSession und bekommen Ausgabe:

valWithOutType: %!s(<nil>) 
cannot get session value by key: key 
value from session 

Warum valWithOutType Null ist, obwohl ich es /setSession anfordernden gesetzt?

aktualisieren

Ich änderte Code nach @isza Antwort, aber Sitzungswert ist noch nil.

package main 

import (
    "fmt" 
    "github.com/gorilla/mux" 
    "github.com/gorilla/sessions" 
    "log" 
    "net/http" 
) 

func main() { 
    rtr := mux.NewRouter() 
    rtr.HandleFunc("/setSession", handler1).Methods("GET") 
    rtr.HandleFunc("/getSession", handler2).Methods("GET") 
    http.Handle("/", rtr) 
    log.Println("Listening...") 
    store.Options = &sessions.Options{ 
     MaxAge: 3600 * 1, // 1 hour 
     HttpOnly: true, 
     Path:  "/", // to match all requests 
    } 
    http.ListenAndServe(":3000", http.DefaultServeMux) 

} 

func handler1(w http.ResponseWriter, r *http.Request) { 
    SetSessionValue(w, r, "key", "value") 
    w.Write([]byte("setSession")) 
} 

func handler2(w http.ResponseWriter, r *http.Request) { 
    w.Write([]byte("getSession")) 
    value := GetSessionValue(w, r, "key") 
    fmt.Println("value from session") 
    fmt.Println(value) 
} 

var authKey = []byte("secret") // Authorization Key 

var encKey = []byte("encKey") // Encryption Key 

var store = sessions.NewCookieStore(authKey, encKey) 

func initSession(r *http.Request) *sessions.Session { 
    session, err := store.Get(r, "golang_cookie") 
    if err != nil { 
     panic(err) 
    } 
    return session 
} 

func SetSessionValue(w http.ResponseWriter, r *http.Request, key, value string) { 
    session := initSession(r) 
    session.Values[key] = value 
    fmt.Printf("set session with key %s and value %s\n", key, value) 
    session.Save(r, w) 
} 

func GetSessionValue(w http.ResponseWriter, r *http.Request, key string) string { 
    session := initSession(r) 
    valWithOutType := session.Values[key] 
    fmt.Printf("valWithOutType: %s\n", valWithOutType) 
    value, ok := valWithOutType.(string) 
    if !ok { 
     fmt.Println("cannot get session value by key: " + key) 
    } 
    return value 
} 

Answer 1

In Ihrer initSession() Funktion können Sie die Speicheroptionen ändern:

store.Options = &sessions.Options{ 
    MaxAge: 3600 * 1, // 1 hour 
    HttpOnly: true, 
} 

Die Options Struktur enthalten auch ein wichtiges Path Feld, der wird das Cookie gelten. Wenn Sie es nicht festlegen, ist der Standardwert der leere String: "". Dies wird höchstwahrscheinlich dazu führen, dass der Cookie nicht mit Ihren URLs/Pfaden übereinstimmt, sodass Ihre bestehende Sitzung nicht gefunden wird.

hinzufügen Pfad so all Urls zum Spiel:

store.Options = &sessions.Options{ 
    Path:  "/",  // to match all requests 
    MaxAge: 3600 * 1, // 1 hour 
    HttpOnly: true, 
} 

Auch sollten Sie in jedem Aufruf von initSession() nicht store.Options ändern, da Sie diese eingehenden Anfrage in jedem Anruf. Gerade gesetzt, sobald diese, wenn Sie Ihre store wie folgt zu erstellen:

var store = sessions.NewCookieStore(authKey, encKey) 

func init() { 
    store.Options = &sessions.Options{ 
     Path:  "/",  // to match all requests 
     MaxAge: 3600 * 1, // 1 hour 
     HttpOnly: true, 
    } 
} 

Answer 2

Da ich keine Antwort gefunden habe ich entschieden, keine Cookie-Speicher zu verwenden, aber redis Speicher für Sitzungen verwenden. Und ich fand volles Arbeitsbeispiel here

package main 

import (
    "fmt" 
    "github.com/aaudis/GoRedisSession" 
    "log" 
    "net/http" 
) 

var (
    redis_session *rsess.SessionConnect 
) 

func main() { 
    // Configurable parameters 
    rsess.Prefix = "sess:" // session prefix (in Redis) 
    rsess.Expire = 1800 // 30 minute session expiration 

    // Connecting to Redis and creating storage instance 
    temp_sess, err := rsess.New("sid", 0, "127.0.0.1", 6379) 
    if err != nil { 
     log.Printf("%s", err) 
    } 

    redis_session = temp_sess // assing to global variable 

    http.HandleFunc("/", Root) 
    http.HandleFunc("/get", Get) 
    http.HandleFunc("/set", Set) 
    http.HandleFunc("/des", Des) 
    http.ListenAndServe(":8888", nil) 
} 

func Root(w http.ResponseWriter, r *http.Request) { 
    w.Header().Add("Content-Type", "text/html") 
    fmt.Fprintf(w, ` 
     Redis session storage example:<br><br> 
     <a href="/set">Store key in session</a><br> 
     <a href="/get">Get key value from session</a><br> 
     <a href="/des">Destroy session</a> 
    `) 
} 

// Destroy session 
func Des(w http.ResponseWriter, r *http.Request) { 
    s := redis_session.Session(w, r) 
    s.Destroy(w) 
    fmt.Fprintf(w, "Session deleted!") 
} 

// Set variable to session 
func Set(w http.ResponseWriter, r *http.Request) { 
    s := redis_session.Session(w, r) 
    s.Set("UserID", "1000") 
    fmt.Fprintf(w, "Setting session variable done!") 
} 

// Get variable from session 
func Get(w http.ResponseWriter, r *http.Request) { 
    s := redis_session.Session(w, r) 
    fmt.Fprintf(w, "Value %s", s.Get("UserID")) 
} 

Answer 3

Was Sie wahrscheinlich mit der get-Methode in Ihrer init Sitzung Funktion machen Sie die ganze Sitzung Neustart wieder so jedes Mal, wenn Sie es tun, die Sitzung ist leer. Ich habe einen kurzen Hack gemacht, um zu zeigen, wo dein Fehler ist. Bitte umgehen Sie dieses Beispiel!

package appSession 

import (  
    "net/http" 
    "fmt" 
    "log" 
    "github.com/gorilla/sessions"  
) 

var appSession *sessions.Session; 

var authKey = []byte("qwer") 
var encKey = []byte("asdf") 

var store = sessions.NewCookieStore(authKey, encKey)  

func initSession(r *http.Request) *sessions.Session { 

    log.Println("session before get", appSession) 

    if appSession == nil {   
    }else{  
     return appSession;  
    } 

    session, err := store.Get(r, "golang_cookie") 
    appSession = session; 

    log.Println("session after get", session) 
    if err != nil { 
     panic(err) 
    } 
    return session 
} 

func SetSessionValue(w http.ResponseWriter, r *http.Request, key, value string) { 
    session := initSession(r) 
    session.Values[key] = value 
    fmt.Printf("set session with key %s and value %s\n", key, value) 
    session.Save(r, w) 
} 

func GetSessionValue(w http.ResponseWriter, r *http.Request, key string) string { 
    session := initSession(r) 
    valWithOutType := session.Values[key] 
    fmt.Printf("valWithOutType: %s\n", valWithOutType) 
    value, ok := valWithOutType.(string) 
    log.Println("returned value: ", value); 

    if !ok { 
     fmt.Println("cannot get session value by key: " + key) 
    } 
    return value 
}