Session Support for the Play Framework

Moritz Thielcke — Wed, 15 Feb 2012 09:57:57 +0000

Am Anfang dieses kleinen Tutorials sollte ich erwähnen, dass Sessions bei den meisten Play-Projekten nicht unbedingt nötig sind. Play basiert auf einem “Share-Nothing”-Prinzip und ist darauf ausgelegt, auf mehreren Server-Instanzen parallel laufen zu können. Durch die integrierte Memcache-Implementierung und dem auf Cookies basierenden Security-Modul sind die meisten Projekte auch ohne Session-Objekte problemlos umsetzbar.
Bei Webseiten, die auf intensive Benutzerinteraktion abzielen, kann ein Session-Object aber durchaus von Nutzen sein. Ausserdem finde ich es nicht besonders elegant, den Benutzernamen in einem Cookie als Plaintext abzuspeichern, wie es das Play Security-Modul macht. Auch wenn der Cookie signiert ist, präferiere ich eine Identifikation über eine Session-ID.
Ziel dieses Tutorials ist es daher, eine serverseitige Sessionverwaltung zu implementieren. Dafür nutzen wir die von Play gelieferte Cache Funktionalität. Dadurch wird die Session, je nach Konfiguration, entweder im Speicher der Anwendung verwaltet, oder über einen externen Memcache.
Falls Ihr Projekt später auf mehren Instanzen laufen soll, sollten Sie auf eine hybride Session-Verwaltung von Memcache und Datenbank setzen, um einen Single Point of Failure zu vermeiden.

( http://dormando.livejournal.com/495593.html )

Example: User Session

Das folgende Beispiel benötigt ein Play Projekt mit konfiguriertem Security-Modul. Des Weiteren nutzte ich ein Model “User” mit den Feldern “Username” und “Password”.

( http://pastebin.com/35vwkB3 )

Um unsere Session zu implementieren, erweitern wir das Security-Modul. Dadurch können wir auf schon vorhandene Funkionalitäten zugreifen. Dafür erzeugen wir im Package “controller” eine neue Java-Klasse, zB. “SessionImpl.java”:

public class SessionImpl extends Secure.Security{
  private static Map scache;
}

Da es sich bei der Secure.Security-Klasse um ein Controller handelt, besitzt jeder Request seine eigene statische Map (“scache”).

Nun machen wir uns an die authenticate() Funktion. Diese wird später aufgerufen, wenn sich ein User über das Security-Modul einloggt:

    static boolean authenticate(String username, String password) {
      User user = null;
      if("admin".equals(username) &&  "admin".equals(password)){
           //for testing purpose
           user = new User(username, password);
      }
      else{
          user = User.login(username, password);
     }
       if(user != null)
         scache = new HashMap();
         scache.put("user",user);
         scache.put("sessionID", session.getId());
         Cache.set("session_"+session.getId(), scache, "30mn");//30 mins session timeout
         Logger.debug("user "+user+" logged in as session "+session.getId());
         return true;
     }      
      return false;
}

Als nächstes implementieren wir eine Funktion, die vor Aufruf eines annotierten Controllers überprüft, ob sich der Benutzer eingeloggt hat:

   @Before(unless={"login", "authenticate", "logout"})
   static void checkUser() throws Throwable{
      Logger.debug("connected session: "+session.getId());
     try{
          scache = (Map) Cache.get("session_"+session.getId());
      }catch(ClassCastException ex){
         Logger.error("cant load session ", ex);
      }
     User u = getUser();
      if( u == null )
           Secure.login();   
      else
           Logger.debug("Logged in as "+u);
  }

   public static User getUser(){
       if(scache!=null &&  scache.get("user") != null){
          return (User) scache.get("user");
      }
     return null;
  }

Damit Änderungen am Session-Objekt auch im Cache landen, benötigen wir zusätzlich noch eine Funktion, die nach Aufruf des annotierten Controllers die Session speichert:

   @After
   static void syncSession(){
       Logger.debug("saving session to cache");
       if(scache!=null)
           Cache.set("session_"+session.getId(), scache, "30mn");
   }

Als Letztes noch eine Getter-Funktion für das Session-Objekt, um den Zugriff von Controllern zu gewährleisten:

  static Map getCache(){
     return scache;
   }

Die komplette Klasse gibt es unter: http://pastebin.com/BqLz0CqU.

Mit der fertigen Implementierung können wir nun Controller-Klassen mit @With annotieren, um sie ausschließlich für eingeloggte User zur Verfügung zu stellen:

@With(SessionImpl.class)
public class Application extends Controller {
  public static void index() {
       User user = SessionImpl.getUser();
       render(user);
  }
}

Wollen wir unsere Implementierung noch um Gruppenrichtlinien erweitern, können wir das mit Hilfe der @Check(“profile”)-Annotation umsetzen:

public class SessionImpl extends Secure.Security {
       //..
   static boolean check(String profile) {   
      User u = getUser();
     if(u != null && u.hasProfile(profile)) {
               return true;
     }

     return false;
  }

code mitte

Session Support for the Play Framework