Photoshop
Cinema 4d
Fotografie
Weitere Grafiksoftware
HTML / CSS
JavaScript
Flash
PHP
Webserver
Sonstige
PHP & OOP - Datenbank basiertes Session-Management (PHP Tutorial)
Tutorial erstellt von Andreas W. in 5.x, letzte Änderung am 22.06.2010
In dem nachfolgenden Tutorial möchte ich euch zeigen, wie man eine Klasse programmiert und nutzt, die es einem ermöglicht Sitzungsdaten in einer Datenbank anstatt wie üblich im Dateisystem abzulegen. Am Ende des Tutorials wird wie immer ein kleines, aber dennoch erhellendes Beispiel zu finden sein, das den Einsatz dieser Implementationen in der Praxis demonstriert. Die gezeigten Anwendungen und Methoden werde ich dabei ausführlich erläutern.
Eine Sitzung bezeichnet im Bereich der Informatik im Allgemeinen eine bestehende Verbindung zwischen Client und Host. Da es im World Wide Web aufgrund der eingesetzten zustandslosen Protokolle, wie zum Beispiel HTTP, keine Möglichkeit gibt Benutzer eindeutig zu identifizieren, ist es nötig eine solche Identifizierung in der Applikations-Schicht (siehe OSI-Model) vorzunehmen. PHP nutzt dazu die so genannte Session-ID, die vom Client an den Server übertragen wird. Sie ermöglicht es nicht zusammenhängende Sitzungsdaten zu einer Sitzung zusammen zu fassen und einem Benutzer eindeutig zuzuordnen.
Sitzungsdaten werden serverseitig gespeichert und von diesem nach einer festlegbaren Zeit automatisch gelöscht!
Typische Beispiele für den Einsatz von Sessions sind Systeme, in denen Informationen von einem Seitenaufruf zum nächsten transportierbar sein müssen. Typische Anwendungen wären zum Beispiel ein Online-Shop oder ein kleines Forum. Bleiben wir mal beim Beispiel des Online-Shops. Jeder kennt von solchen Internetseiten einen Warenkorb. Eine echt praktische Sache, die es einem erlaubt verschiedene Artikel zu sammeln, bevor man mit diesen zur Kasse geht. Die Artikel und ihre Anzahl müssen also zwischen den einzelnen Seitenaufrufen erhalten bleiben und einer Anfrage eindeutig zugeordnet werden können. Einige werden es sich wahrscheinlich schon gedacht haben, aber ich möchte dennoch einmal darauf aufmerksam machen. Man kann in vielen Shops den Einkaufswagen oder Warenkorb auch dann verwenden, wenn man sich nicht eingeloggt hat. Das bedeutet, dass eine Sitzung auch ohne vorherige Authentifizierung eines Benutzers angelegt werden kann. Auf diese Weise ist es auch möglich, die Bewegungen eines Benutzers innerhalb eines Webauftritts nachzuvollziehen.
Den meisten wird der Umgang mit Sessions in PHP wohl bekannt sein, dennoch möchte ich kurz darauf eingehen, da es ein paar Dinge dabei zu beachten gibt. Das PHP-Manual weist im Kapitel zu Sessions darauf hin, dass für den Fall, dass man session.auto_start aktiviert hat, Objekte nur in eine Session aufgenommen werden können, indem die Klassendefinition mittels auto_prepend_file geladen oder diese serialisiert wird. Dabei ist zu beachten, dass manche Datentypen nicht serialisiert werden können. Dazu gehören resource-Variablen oder Objekte mit Ringreferenzen. Außerdem ist zu beachten, dass falls eine Session mit session_start() gestartet wurde, ihr Datensatz erst dann angelegt wird, wenn eine Variable mit der Funktion session_register() registriert oder dem superglobalen Array $_SESSION hinzugefügt wurde. Nachfolgend findet ihr ein kleines Beispiel zum Umgang mit Sessions mit PHP.
Code:
<?php
/* start session */
session_start();
/**
* assign some values
* (session will be created if not exists)
*/
$_SESSION['name'] = 'avedo';
$_SESSION['time'] = time();
/* get some session value */
echo $_SESSION['name'] . 'logged in at ' . date('d.m.Y H:i:s', $_SESSION['time']);
/* delete session */
session_destroy();
?>
Sieht doch alles ganz einfach aus. Wollen wir nun also einen Schritt weiter gehen.
Um Sitzungsdaten in einer MySQL-Datenbank verwalten zu können, implementieren wir eine Klasse, die Daten, welche im Cache abgelegt werden sollen, in die Datenbank schreibt. PHP stellt mit der Funktion session_set_save_handler() die Möglichkeit zur Verfügung, die standardgemäß Dateisystem-basierten Session-Funktionen zu überschreiben. Wir schreiben anstatt der im Manual vorgestellten Funktionen eine Klasse, die es uns ermöglichen wird, Sessions in einer Datenbank zu speichern. Um das ganze zu verwenden arbeitet man eigentlich ganz normal mit den Sessions. Man muss zuvor nur eine Instanz der Klasse erzeugen.
Das Speichern von Sessions in der Datenbank hat meiner Meinung nach mehrere Vorteile. Zum einen kann man bei einem Mehrbenutzersystem direkt auf die Session-Daten zugreifen und zum Beispiel alle Benutzer und Gäste ausgeben lassen, die momentan online sind. Außerdem halte ich diese Art des Session-Handlings für deutlich sicherer als die Dateisystem basierte Variante, da es schwerer ist an die Daten zu kommen, wenn man sie nicht einfach mit einem Editor öffnen kann. Jedoch gibt es natürlich auch Fälle, in denen es sinnvoller ist die Session-Daten in einer Datei zu hinterlegen.
Damit einem alle Möglichkeiten bei der Entwicklung eines Systems offen bleiben, ist es sinnvoll, ein einfaches aber hilfreiches Interface zu basteln, dass bei der eventuell später stattfindenden Entwicklung weiterer Cache-Verwaltungsklassen sicher stellt, dass alle notwendigen Informationen eingebunden werden. Ein solches Interface muss wie folgt aussehen.
Code:
interface CacheManager
{
public function open($save_path, $session_name);
public function close();
public function read($id);
public function write($id, $sess_data);
public function destroy($id);
public function gc($maxlifetime);
}
Auf Basis dieses Interfaces könnte man nun zwei verschiedene SessionHandler implementieren, einen Dateisystem-basierten und einen Datenbank-basierten. Wie wir dem Interface bereits entnehmen können benötigen wir sechs Methoden, die das Öffnen, Lesen, Schreiben, Löschen und Schließen der Datenbank zur Verwaltung der Sessiondaten ermöglichen. Damit diese Methoden dann aber auch wirklich genutzt werden, muss ein Datenbank-Objekt (in unserem Fall ein MySQLi-Objekt) an die Klasse übergeben werden. Des weiteren muss dem System mitgeteilt werden, dass es bitte unsere Implementation an Stelle der Standrad-Implementation der Methoden bzw. Funktionen nutzen soll. Dies geschieht, wie bereits erwähnt, mit Hilfe der Funktion session_set_save_handler(), die alternative Funktionen bzw. Methoden deklariert. Damit wir nun mit unserer Implementation arbeiten können, müssen wir eine neue Sitzung starten. Dies geschieht ebenfalls im Konstruktor via session_start(). Abschließend müssen wir sicherstellen, dass die Daten einer Sitzung auf jeden Fall gespeichert werden. Dies geschieht mit Hilfe der Funktion register_shutdown_function(), die die Methoden bzw. Funktionen festlegt, die beim Beenden einer Sitzung aufgerufen werden sollen. Wir legen also fest, dass vor Beenden einer Sitzung erst alle Daten gespeichert und dann die Sitzung beendet werden soll. Da zur Implementierung dieser Klasse im restlichen Verlauf nichts weiter als einfachste SQL-Kenntnisse nötig sind, gehe ich an dieser Stelle nicht auf den weiteren Aufbau der Klasse ein. Ich habe sie dennoch sehr ausführlich dokumentiert, sodass es jedem leicht fallen sollte, alles nachzuvollziehen.
Code:
<?php
/**
* The SessionHandler class implements all methods to use a
* database based session management instead of using text files.
* This has the benefit that all session data can be accessed
* at a central place. This class is supported since the PHP version 5.0.5
* because it uses the register_shutdown_function() function to ensure that
* all session values are stored before the PHP representation is destroyed.
*
* @package CacheManager
* @subpackage SessionHandler
* @version 0.4
* @date 08/03/2009
* @author Andreas Wilhelm <Andreas2209@web.de>
* @copyright Andreas Wilhelm
* @link http://avedo.net
*/
class SessionHandler implements CacheManager
{
/**
* @var mysqli $mysqli The MySQLi object used to access the database
* @access private
*/
private $mysqli = null;
/**
* Sets the user-level session storage functions which are used
* for storing and retrieving data associated with a session.
*
* @access public
* @param mysqli $mysqli The MySQLi object used to access the database
* @return void
*/
public function __construct(mysqli $mysqli)
{
/* assign the mysqli object */
$this->mysqli = $mysqli;
ini_set('session.save_handler', 'user');
/* set session handler to the class methods */
session_set_save_handler(
array(&$this, '_open'),
array(&$this, '_close'),
array(&$this, '_read'),
array(&$this, '_write'),
array(&$this, '_destroy'),
array(&$this, '_gc')
);
/* start a new session */
session_start();
/* make sure that the session values are stored */
register_shutdown_function('session_write_close');
}
/**
* Is called to open a session. The method
* does nothing because we do not want to write
* into a file so we doesn't need to open one.
*
* @access public
* @param String $save_path The save path
* @param String $session_name The name of the session
* @return Boolean
*/
public function _open($save_path, $session_name)
{
return true;
}
/**
* Is called when the reading in a session is
* completed. The method calls the garbage collector.
*
* @access public
* @return Boolean
*/
public function _close()
{
/* call the garbage collector */
$this->_gc(100);
return true;
}
/**
* Is called to read data from a session.
*
* @access public
* @access Integer $id The id of the current session
* @return Mixed
*/
public function _read($id)
{
/* create a query to get the session data */
$select = "SELECT
*
FROM
`sessions`
WHERE
`sessions`.`id` = '" . $id . "'
LIMIT 1;";
/* send select statement */
$result = $this->mysqli->query($select);
/* check for result */
if( !$result )
{
throw new Exception("MySQL error while performing query.");
}
/* a session was found */
if( $result->num_rows > 0 )
{
/* get assoc array */
$ret = $result->fetch_assoc();
return $ret["value"];
}
/* no session found */
return '';
}
/**
* Writes data into a session rather
* into the session record in the database.
*
* @access public
* @access Integer $id The id of the current session
* @access String $sess_data The data of the session
* @return Boolean
*/
public function _write($id, $sess_data)
{
/* check if some data was given */
if( $sess_data == null )
{
return true;
}
/* query to update a session */
$update = "UPDATE
`sessions`
SET
`sessions`.`last_updated` = '" .time() . "',
`sessions`.`value` = '" . $sess_data . "'
WHERE
`sessions`.`id` = '" . $id . "';";
/* send select statement */
$result = $this->mysqli->query($update);
/* database error */
if( $result === false )
{
return false;
}
/* current session was updated */
if( $this->mysqli->affected_rows > 0 )
{
return true;
}
/* session does not exists create insert statement */
$insert = "INSERT INTO
`sessions`
(id, last_updated, start, value)
VALUES
('" . $id . "', '" . time() . "', '" . time() . "', '" . $sess_data . "');";
/* send insert statement */
$result = $this->mysqli->query($insert);
return $result;
}
/**
* Ends a session and deletes it.
*
* @access public
* @access Integer $id The id of the current session
* @return Boolean
*/
public function _destroy($id)
{
/* create a query to delete a session */
$delete = "DELETE FROM
`sessions`
WHERE
`sessions`.`id` = '" . $id . "';";
/* send delete statement */
$result = $this->mysqli->query($delete);
return $result;
}
/**
* The garbage collector deletes all sessions from the database
* that where not deleted by the session_destroy function.
* so your session table will be stay clean.
*
* @access public
* @access Integer $maxlifetime The maximum session lifetime
* @return Boolean
*/
public function _gc($maxlifetime)
{
/* period after that a session pass off */
$maxlifetime = strtotime("-20 minutes");
/* delete statement */
$delete = "DELETE FROM
`sessions`
WHERE
`sessions`.`last_updated` < '" . $maxlifetime . "';";
/* send delete statement */
$result = $this->mysqli->query($delete);
return $result;
}
}
?>
Nun da wir unsere Klasse fertig haben, wollen wir uns doch mal ansehen, wie wir diese in einem Projekt einsetzen könnten. Dazu möchte ich kurz annehmen, dass wir dabei sind ein Administrations- und Benutzer-Bereich zu implementieren, der Teil einer Community werden soll. Wir instanzieren die Session, weisen dieser die "eingegebenen" Benutzerdaten zu und können nun auf diese zugreifen. So ist es nun aber auch möglich, ohne Probleme auf unsere Session-Tabelle in der Datenbank zuzugreifen und alle eingeloggten Benutzter abzufragen.
Code:
<?php
/* get instance of the Registry object */
Registry::getInstance();
/* get database object */
$mysqli = $reg->get('mysqli');
/* instance SessionHandler */
new SessionHandler($mysqli);
/* assign some values to the session */
$_SESSION['name'] = 'avedo';
$_SESSION['mail'] = 'test@avedo.net';
/* get some session value */
echo 'logged in as ' . $_SESSION['name'];
/* delete session */
session_destroy();
?>
Der Quellcode zeigt, wie man eine Instanz des SessionHandlers erzeugt und dann mit Hilfe der uns wohl bekannten Session-Operationen ohne irgendwelche Umstellungen die Klasse nutzen kann. So ist es möglich, ganz zentral den SessionHandler zu instanzieren und schon arbeit eine komplette Applikation mit Datenbank-basierten Sessions.
Fragen und Antworten findet ihr selbstverständlich bei uns im Forum. Ich möchte euch auch darum bitten, keine Fragen an mich persönlich zu senden aus dem einfachen Grund, dass andere Menschen dann nichts von den gegebenen Antworten haben. Zudem können euch im Forum auch viele andere Leute, die echt Ahnung haben, helfen. Natürlich freue ich mich über ein kurzes Feedback zu diesem Tutorial. Ich bedanke mich für eure Aufmerksamkeit und hoffe, dass euch mein kurzer Exkurs gefallen hat.
Liebe Grüße,
Andreas
http://www.avedo.net
>> Allgemeine Fragen oder Probleme mit dem Tutorial? Hier gehts zum Forum!
Sitzungsverwaltung
Eine Sitzung bezeichnet im Bereich der Informatik im Allgemeinen eine bestehende Verbindung zwischen Client und Host. Da es im World Wide Web aufgrund der eingesetzten zustandslosen Protokolle, wie zum Beispiel HTTP, keine Möglichkeit gibt Benutzer eindeutig zu identifizieren, ist es nötig eine solche Identifizierung in der Applikations-Schicht (siehe OSI-Model) vorzunehmen. PHP nutzt dazu die so genannte Session-ID, die vom Client an den Server übertragen wird. Sie ermöglicht es nicht zusammenhängende Sitzungsdaten zu einer Sitzung zusammen zu fassen und einem Benutzer eindeutig zuzuordnen.
Sitzungsdaten werden serverseitig gespeichert und von diesem nach einer festlegbaren Zeit automatisch gelöscht!
Typische Beispiele für den Einsatz von Sessions sind Systeme, in denen Informationen von einem Seitenaufruf zum nächsten transportierbar sein müssen. Typische Anwendungen wären zum Beispiel ein Online-Shop oder ein kleines Forum. Bleiben wir mal beim Beispiel des Online-Shops. Jeder kennt von solchen Internetseiten einen Warenkorb. Eine echt praktische Sache, die es einem erlaubt verschiedene Artikel zu sammeln, bevor man mit diesen zur Kasse geht. Die Artikel und ihre Anzahl müssen also zwischen den einzelnen Seitenaufrufen erhalten bleiben und einer Anfrage eindeutig zugeordnet werden können. Einige werden es sich wahrscheinlich schon gedacht haben, aber ich möchte dennoch einmal darauf aufmerksam machen. Man kann in vielen Shops den Einkaufswagen oder Warenkorb auch dann verwenden, wenn man sich nicht eingeloggt hat. Das bedeutet, dass eine Sitzung auch ohne vorherige Authentifizierung eines Benutzers angelegt werden kann. Auf diese Weise ist es auch möglich, die Bewegungen eines Benutzers innerhalb eines Webauftritts nachzuvollziehen.
Sessions in PHP
Den meisten wird der Umgang mit Sessions in PHP wohl bekannt sein, dennoch möchte ich kurz darauf eingehen, da es ein paar Dinge dabei zu beachten gibt. Das PHP-Manual weist im Kapitel zu Sessions darauf hin, dass für den Fall, dass man session.auto_start aktiviert hat, Objekte nur in eine Session aufgenommen werden können, indem die Klassendefinition mittels auto_prepend_file geladen oder diese serialisiert wird. Dabei ist zu beachten, dass manche Datentypen nicht serialisiert werden können. Dazu gehören resource-Variablen oder Objekte mit Ringreferenzen. Außerdem ist zu beachten, dass falls eine Session mit session_start() gestartet wurde, ihr Datensatz erst dann angelegt wird, wenn eine Variable mit der Funktion session_register() registriert oder dem superglobalen Array $_SESSION hinzugefügt wurde. Nachfolgend findet ihr ein kleines Beispiel zum Umgang mit Sessions mit PHP.
Code:
<?php
/* start session */
session_start();
/**
* assign some values
* (session will be created if not exists)
*/
$_SESSION['name'] = 'avedo';
$_SESSION['time'] = time();
/* get some session value */
echo $_SESSION['name'] . 'logged in at ' . date('d.m.Y H:i:s', $_SESSION['time']);
/* delete session */
session_destroy();
?>
Sieht doch alles ganz einfach aus. Wollen wir nun also einen Schritt weiter gehen.
Einsatz der Datenbank
Um Sitzungsdaten in einer MySQL-Datenbank verwalten zu können, implementieren wir eine Klasse, die Daten, welche im Cache abgelegt werden sollen, in die Datenbank schreibt. PHP stellt mit der Funktion session_set_save_handler() die Möglichkeit zur Verfügung, die standardgemäß Dateisystem-basierten Session-Funktionen zu überschreiben. Wir schreiben anstatt der im Manual vorgestellten Funktionen eine Klasse, die es uns ermöglichen wird, Sessions in einer Datenbank zu speichern. Um das ganze zu verwenden arbeitet man eigentlich ganz normal mit den Sessions. Man muss zuvor nur eine Instanz der Klasse erzeugen.
Das Speichern von Sessions in der Datenbank hat meiner Meinung nach mehrere Vorteile. Zum einen kann man bei einem Mehrbenutzersystem direkt auf die Session-Daten zugreifen und zum Beispiel alle Benutzer und Gäste ausgeben lassen, die momentan online sind. Außerdem halte ich diese Art des Session-Handlings für deutlich sicherer als die Dateisystem basierte Variante, da es schwerer ist an die Daten zu kommen, wenn man sie nicht einfach mit einem Editor öffnen kann. Jedoch gibt es natürlich auch Fälle, in denen es sinnvoller ist die Session-Daten in einer Datei zu hinterlegen.
Damit einem alle Möglichkeiten bei der Entwicklung eines Systems offen bleiben, ist es sinnvoll, ein einfaches aber hilfreiches Interface zu basteln, dass bei der eventuell später stattfindenden Entwicklung weiterer Cache-Verwaltungsklassen sicher stellt, dass alle notwendigen Informationen eingebunden werden. Ein solches Interface muss wie folgt aussehen.
Code:
interface CacheManager
{
public function open($save_path, $session_name);
public function close();
public function read($id);
public function write($id, $sess_data);
public function destroy($id);
public function gc($maxlifetime);
}
Auf Basis dieses Interfaces könnte man nun zwei verschiedene SessionHandler implementieren, einen Dateisystem-basierten und einen Datenbank-basierten. Wie wir dem Interface bereits entnehmen können benötigen wir sechs Methoden, die das Öffnen, Lesen, Schreiben, Löschen und Schließen der Datenbank zur Verwaltung der Sessiondaten ermöglichen. Damit diese Methoden dann aber auch wirklich genutzt werden, muss ein Datenbank-Objekt (in unserem Fall ein MySQLi-Objekt) an die Klasse übergeben werden. Des weiteren muss dem System mitgeteilt werden, dass es bitte unsere Implementation an Stelle der Standrad-Implementation der Methoden bzw. Funktionen nutzen soll. Dies geschieht, wie bereits erwähnt, mit Hilfe der Funktion session_set_save_handler(), die alternative Funktionen bzw. Methoden deklariert. Damit wir nun mit unserer Implementation arbeiten können, müssen wir eine neue Sitzung starten. Dies geschieht ebenfalls im Konstruktor via session_start(). Abschließend müssen wir sicherstellen, dass die Daten einer Sitzung auf jeden Fall gespeichert werden. Dies geschieht mit Hilfe der Funktion register_shutdown_function(), die die Methoden bzw. Funktionen festlegt, die beim Beenden einer Sitzung aufgerufen werden sollen. Wir legen also fest, dass vor Beenden einer Sitzung erst alle Daten gespeichert und dann die Sitzung beendet werden soll. Da zur Implementierung dieser Klasse im restlichen Verlauf nichts weiter als einfachste SQL-Kenntnisse nötig sind, gehe ich an dieser Stelle nicht auf den weiteren Aufbau der Klasse ein. Ich habe sie dennoch sehr ausführlich dokumentiert, sodass es jedem leicht fallen sollte, alles nachzuvollziehen.
Code:
<?php
/**
* The SessionHandler class implements all methods to use a
* database based session management instead of using text files.
* This has the benefit that all session data can be accessed
* at a central place. This class is supported since the PHP version 5.0.5
* because it uses the register_shutdown_function() function to ensure that
* all session values are stored before the PHP representation is destroyed.
*
* @package CacheManager
* @subpackage SessionHandler
* @version 0.4
* @date 08/03/2009
* @author Andreas Wilhelm <Andreas2209@web.de>
* @copyright Andreas Wilhelm
* @link http://avedo.net
*/
class SessionHandler implements CacheManager
{
/**
* @var mysqli $mysqli The MySQLi object used to access the database
* @access private
*/
private $mysqli = null;
/**
* Sets the user-level session storage functions which are used
* for storing and retrieving data associated with a session.
*
* @access public
* @param mysqli $mysqli The MySQLi object used to access the database
* @return void
*/
public function __construct(mysqli $mysqli)
{
/* assign the mysqli object */
$this->mysqli = $mysqli;
ini_set('session.save_handler', 'user');
/* set session handler to the class methods */
session_set_save_handler(
array(&$this, '_open'),
array(&$this, '_close'),
array(&$this, '_read'),
array(&$this, '_write'),
array(&$this, '_destroy'),
array(&$this, '_gc')
);
/* start a new session */
session_start();
/* make sure that the session values are stored */
register_shutdown_function('session_write_close');
}
/**
* Is called to open a session. The method
* does nothing because we do not want to write
* into a file so we doesn't need to open one.
*
* @access public
* @param String $save_path The save path
* @param String $session_name The name of the session
* @return Boolean
*/
public function _open($save_path, $session_name)
{
return true;
}
/**
* Is called when the reading in a session is
* completed. The method calls the garbage collector.
*
* @access public
* @return Boolean
*/
public function _close()
{
/* call the garbage collector */
$this->_gc(100);
return true;
}
/**
* Is called to read data from a session.
*
* @access public
* @access Integer $id The id of the current session
* @return Mixed
*/
public function _read($id)
{
/* create a query to get the session data */
$select = "SELECT
*
FROM
`sessions`
WHERE
`sessions`.`id` = '" . $id . "'
LIMIT 1;";
/* send select statement */
$result = $this->mysqli->query($select);
/* check for result */
if( !$result )
{
throw new Exception("MySQL error while performing query.");
}
/* a session was found */
if( $result->num_rows > 0 )
{
/* get assoc array */
$ret = $result->fetch_assoc();
return $ret["value"];
}
/* no session found */
return '';
}
/**
* Writes data into a session rather
* into the session record in the database.
*
* @access public
* @access Integer $id The id of the current session
* @access String $sess_data The data of the session
* @return Boolean
*/
public function _write($id, $sess_data)
{
/* check if some data was given */
if( $sess_data == null )
{
return true;
}
/* query to update a session */
$update = "UPDATE
`sessions`
SET
`sessions`.`last_updated` = '" .time() . "',
`sessions`.`value` = '" . $sess_data . "'
WHERE
`sessions`.`id` = '" . $id . "';";
/* send select statement */
$result = $this->mysqli->query($update);
/* database error */
if( $result === false )
{
return false;
}
/* current session was updated */
if( $this->mysqli->affected_rows > 0 )
{
return true;
}
/* session does not exists create insert statement */
$insert = "INSERT INTO
`sessions`
(id, last_updated, start, value)
VALUES
('" . $id . "', '" . time() . "', '" . time() . "', '" . $sess_data . "');";
/* send insert statement */
$result = $this->mysqli->query($insert);
return $result;
}
/**
* Ends a session and deletes it.
*
* @access public
* @access Integer $id The id of the current session
* @return Boolean
*/
public function _destroy($id)
{
/* create a query to delete a session */
$delete = "DELETE FROM
`sessions`
WHERE
`sessions`.`id` = '" . $id . "';";
/* send delete statement */
$result = $this->mysqli->query($delete);
return $result;
}
/**
* The garbage collector deletes all sessions from the database
* that where not deleted by the session_destroy function.
* so your session table will be stay clean.
*
* @access public
* @access Integer $maxlifetime The maximum session lifetime
* @return Boolean
*/
public function _gc($maxlifetime)
{
/* period after that a session pass off */
$maxlifetime = strtotime("-20 minutes");
/* delete statement */
$delete = "DELETE FROM
`sessions`
WHERE
`sessions`.`last_updated` < '" . $maxlifetime . "';";
/* send delete statement */
$result = $this->mysqli->query($delete);
return $result;
}
}
?>
Ein praktisches Beispiel
Nun da wir unsere Klasse fertig haben, wollen wir uns doch mal ansehen, wie wir diese in einem Projekt einsetzen könnten. Dazu möchte ich kurz annehmen, dass wir dabei sind ein Administrations- und Benutzer-Bereich zu implementieren, der Teil einer Community werden soll. Wir instanzieren die Session, weisen dieser die "eingegebenen" Benutzerdaten zu und können nun auf diese zugreifen. So ist es nun aber auch möglich, ohne Probleme auf unsere Session-Tabelle in der Datenbank zuzugreifen und alle eingeloggten Benutzter abzufragen.
Code:
<?php
/* get instance of the Registry object */
Registry::getInstance();
/* get database object */
$mysqli = $reg->get('mysqli');
/* instance SessionHandler */
new SessionHandler($mysqli);
/* assign some values to the session */
$_SESSION['name'] = 'avedo';
$_SESSION['mail'] = 'test@avedo.net';
/* get some session value */
echo 'logged in as ' . $_SESSION['name'];
/* delete session */
session_destroy();
?>
Der Quellcode zeigt, wie man eine Instanz des SessionHandlers erzeugt und dann mit Hilfe der uns wohl bekannten Session-Operationen ohne irgendwelche Umstellungen die Klasse nutzen kann. So ist es möglich, ganz zentral den SessionHandler zu instanzieren und schon arbeit eine komplette Applikation mit Datenbank-basierten Sessions.
Fragen und Antworten
Fragen und Antworten findet ihr selbstverständlich bei uns im Forum. Ich möchte euch auch darum bitten, keine Fragen an mich persönlich zu senden aus dem einfachen Grund, dass andere Menschen dann nichts von den gegebenen Antworten haben. Zudem können euch im Forum auch viele andere Leute, die echt Ahnung haben, helfen. Natürlich freue ich mich über ein kurzes Feedback zu diesem Tutorial. Ich bedanke mich für eure Aufmerksamkeit und hoffe, dass euch mein kurzer Exkurs gefallen hat.
Liebe Grüße,
Andreas
http://www.avedo.net
>> Allgemeine Fragen oder Probleme mit dem Tutorial? Hier gehts zum Forum!
