Mein eigenes MVC-Framework: Die Session-Klasse

<< Zurück zur Übersicht

Dieses Kapitel handelt von einem Teil der OOP in PHP, die sehr umstritten ist. Hier wird der Zugang zu Sessions in eine Klasse gepackt. Alles, was mit Sessions gemacht wird, soll über die Klasse laufen. Allerdings kann man den herkömmlichen Zugriff auf die Session nicht verhindern oder kontrollieren. Im Grunde ist die Session-Klasse nur ein Wrapper um die eigentliche Session. Sie übernimmt das Starten, Beenden und Verwalten (Schreiben, Lesen, Neue SID generieren)  der Session.

Anforderungen an die Klasse

Für mich war es wichtig, dass die Klasse folgende Funktionen zuverlässig erledigt:

  • Starten der Session nur, wenn sie auch wirklich benötigt wird
  • Zugang zu den Sessiondaten über eine Singleton-Klasse
  • Zugriff auf die Daten mit den Interzeptoren (__set, __get, __unset, __isset)
  • Auf Wunsch Regenerierung einer Session-ID
  • Beenden der Session
  • Löschen der Session

Code der Klasse

Wenn die Kommentare nicht wären, wäre der Code vllt. 1/4 so lang 😉 Ihr seht schon, die Sache ist nicht so wild.

/**
 * @licence See: /licence.txt
 */ 

/**
 * @author Simon H.
 * @version 0.2
 * @package MVC-Framework
 *
 * Klasse zur Verwaltung der von PHP bereitgestellten $_SESSION
 */
final class FW_Session
{
  /**
   * @access private static
   * @var FW_Session $instance
   *
   * Speichert die einzige Instanz dieser Klasse (Singleton)
   */
  private static $instance = null;

  /**
   * @access private static
   * @var string $sessArrayKey
   *
   * Unter diesem Key werden in $_SESSION alle Daten verwaltet
   */
  private static  $sessArrayKey = "__sessiondata"; //key im $_SESSION-array

  /**
   * @access private
   *
   * Startet die Session und legt das Array an
   */
  private function __construct()
  {
    session_start();
    if(!isset($_SESSION[FW_Session::$sessArrayKey]))
    {
      $_SESSION[FW_Session::$sessArrayKey] = array();
    }
  }  

  /**
   * @access private
   *
   * Kopierkonstruktor verbieten
   */
  private function __clone() {}

  /**
   * @access private
   * @return FW_Session
   *
   * Erzeugt die Instanz von FW_Session
   */
  public static function getInstance()
  {
    if(self::$instance === null)
    {
      self::$instance = new FW_Session();
    }
    return self::$instance;
  } 

  /**
   * @access public
   * @param string $key
   * @param mixed $value
   *
   * Ermöglicht Speichern von Sessionvariablen
   */
  public function __set($key, $value)
  {
    $_SESSION[FW_Session::$sessArrayKey][$key] = $value;
  }

  /**
   * @access public
   * @param string $key
   * @return bool
   *
   * Ermöglicht Löschen von Sessionvariablen
   */
  public function __unset($key)
  {
    if($this->exists($key))
    {
      unset($_SESSION[FW_Session::$sessArrayKey][$key]);
      return true;
    }
    else
    {
      return false;
    }
  }

  /**
   * @access public
   * @param string $key
   * @return mixed|null
   *
   * Ermöglicht Lesen von Sessionvariablen
   */
  public function __get($key)
  {
    if($this->exists($key))
    {
      return $_SESSION[FW_Session::$sessArrayKey][$key];
    }
    else
    {
      return null;
    }
  }

  /**
   * @access public
   * @param string $key
   * @return bool
   *
   * gibt true zurück, wenn $key existiert
   * sonst false
   */
  public function exists($key)
  {
    return (isset($_SESSION[FW_Session::$sessArrayKey][$key]) ? true : false);
  }

  /**
   * @access public
   * @param string $key
   * @return bool
   *
   * ALIAS FÜR FW_Session::exists($key)
   */
  public function __isset($key)
  {
    return $this->exists($key);
  }

  /**
   * @access public
   *
   * Schließt die Session
   */
  public function close()
  {
    session_write_close();
  }

  /**
   * @access public
   * @param bool $del_old
   *
   * Generiert eine neue Session-ID
   */
  public function newID($del_old = false)
  {
    session_regenerate_id($del_old);
  }

  /**
   * @access public
   * @return string
   *
   * Liefert dei aktuelle Session-ID
   */
  public function getID()
  {
    return session_id();
  }

  /**
   * @access public
   *
   * Zerstört die Session
   */
  public function destroy()
  {
    session_destroy();
  }

  /**
   * @access public
   *
   * Destruktor
   */
  public function __destruct()
  {
    $this->close();
  }
}

Anwendung der Klasse

Man kann jetzt, sofern die Datei mit der Klasse eingebunden ist, überall ganz einfach auf die Daten in der Session zugreifen. Man holt sich einfach eine Instanz per Singleton und verwendet dann die gewünschten Methoden. Wenn das erste mal FW_Session::getInstance() aufgerufen wird, wird die Session gestartet. Man sollte darauf achten, dass das vor der ersten Ausgabe geschieht. Aber da unser Controller sowieso vor der Ausgabe abgearbeitet wird, ist das kein großes Problem.

Anwendungsbeispiel

$session = FW_Session::getInstance(); //Starten der Session
$session->test = "hallo";
if(!isset($session->counter))
{
  $session->counter = 0;
}
$session->counter++;

print_r($_SESSION);

Die Ausgabe wird dann so aussehen:

Array ( [__sessiondata] => Array ( [design] => Standart [test] => hallo [counter] => 1 ) )

Wenn die Seite aktualisiert wird, erhöht sich auch counter um 1.

Was eventuell noch nützlich wäre

Wer Spass daran hat, kann ja eine zusätzliche Eigenschaft $destination erstellen, die angibt, wo genau die Daten in der Session abgelegt werden. Momentan ist das $_SESSION[„__sessiondata“].

Im nächsten Teil des Tutorials werden die Models behandelt.

1 Star2 Stars3 Stars4 Stars5 Stars (2 Stimme, durchschnittlich 4,00 / 5)
Loading...


10 Kommentare zu “Mein eigenes MVC-Framework: Die Session-Klasse”

  1. […] Die Session-Klasse […]

  2. Hey, ein sehr interessante Serie, ich habe MVC bis jetzt Hauptsächlich im Zusammenhang mit Java beachtet.

    Mich würde interessieren wie du den Fallback implementierst falls Cookies deaktiviert sind. Wird das im Verlauf der Serie erklärt, oder lässt du das einfach aussen vor?

  3. Hi

    das handhabt PHP automatisch.

    MfG
    Simon

  4. Aber nicht wenn die ID über mehrere Seiten konsistent sein soll. Dann muss die PHPSESSID über einen Parameter in der Url mitgegeben werden… oder habe ich das was falsch verstanden?

  5. Das weiß ich gerade selbst nicht genau.
    Ich habe diesen Fall noch nie beachtet… Ohne Cookies kann man die Seite halt nicht nutzen, so handhabe ich das.

  6. Normalerweise setzt php die Konstante SID wenn keine Cookies verfügbar sind (die hat dann die Form PHPSESSID=“hash“ die man dann an alle links anhängen muss, php wählt dann bei session_start automatisch die vorhandene ID). Problematisch ist halt das eine session nicht beim ersten Request initialisiert ist (resp das Cookie)und daher hat man beim ersten Aufruf der Seite immer diese SID (was auch Suchmaschinentechnisch etwas unschön sein kann). Vielleicht hat ja sonst jemand eine Idee dazu ;).

  7. Ja, Cookies vorraussetzen 😉
    Alles andere ist Gepfusche und kann auch unsicher werden (SID in der URL, einer schickt nem Kumpel einen Link und der ist dann plötzlich eingeloggt)

  8. Das ist unverantwortlich, so einen Code zu veröffentlichen, zumindest müßte darauf hingewiesen werden, daß die Klasse nicht verwendbar ist, weil der Inhalt nicht verschlüsselt ist. Kaum zu glauben, daß ein angeblicher Java-Programmierer so verantwortungslos sein kann.

  9. Was ist daran unverantwortlich?
    Kannst du mir das mal erklären?

    Außerdem bin ich kein Java-Programmierer…

  10. Die aktuellste Version meines HMVC-Frameworks erhaltet ihr ab sofort immer hier: http://www.net-developers.de/blog/2011/02/13/download-info-shfw-hmvc-framework-in-php/

Hinterlasse einen Kommentar!

Time limit is exhausted. Please reload the CAPTCHA.

»Informationen zum Artikel

Autor: Simon
Datum: 04.05.2009
Zeit: 15:52 Uhr
Kategorien: Mein MVC-Framework
Gelesen: 9247x heute: 2x

Kommentare: RSS 2.0.
Diesen Artikel kommentieren oder einen Trackback senden.

»Meta