SESSION in OOP
Is het netjes om met sessies te werken in een classe? Zonee, hoe kun je dit anders aanpakken om dan toch sessies te setten?
Mvg.
Dan kan je het namelijk wel OOP maken... extends DB etc.
Gewijzigd op 01/01/1970 01:00:00 door GaMer B
in je constructor zet je dan zoiets:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
if(!self::$sessionStarted){
session_start();
self::$sessionStarted = true;
}
?>
if(!self::$sessionStarted){
session_start();
self::$sessionStarted = true;
}
?>
die $sessionStarted is natuurlijk een static variabele:
Zoiets:
sess_id
sess_name
value
fingerprint
En ga zo door. In fingerprint maak je een afdruk van de browse-omgeving van de gebruiker: IP, User Agent et cetera en maak daar een (unieke) hash van.
Door alles in een tabel te proppen kun je bij shared hosting ook geen problemen krijgen en je kunt het erg goed uitbreiden met what so ever.
Vraag:
Is het netjes om met sessies te werken in een classe? Zonee, hoe kun je dit anders aanpakken om dan toch sessies te setten?
Antwoord:
Ja het is netjes om sessies te gebruiken in je classes. Let alleen op dat je sessies globaal zijn en het niet de verantwoordelijkheid is van jouw class is om de sessie te beheren (bv. session_start() of session_close() etc). Maar het getten en setten van sessies mag je prima doen in je klasse.
Handig:
Wellicht kan je zelf een Sessie klasse aanmaken. Sessies zijn in principe globaal en er is maar 1 sessie object beschikbaar. Je zou dus het singleton pattern kunnen gebruiken om sessies te beheren. Dat kan als volgt:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<?php
class Session {
private static $instance;
private function __construct() {
session_start();
}
static public function getInstance() {
if( !self::$intsance instanceof self ) {
self::$instance = new self;
}
return self::$instance;
}
public function __set( $key, $value ) {
$_SESSION[$key] = $value;
}
public function __get( $key ) {
return $_SESSION[$key];
}
public function __isset( $key ) {
return array_key_exists( $key, $_SESSION );
}
public function __toString() {
return var_dump( $_SESSION );
}
}
class MyClass {
public function __construct() {
$session = Session::getInstance();
$session->waarde = "waarde van mijn sessie variabele";
}
public function __toString() {
$session = Session::getInstance();
echo $session->waarde;
//of:
echo $_SESSION['waarde'];
}
}
?>
class Session {
private static $instance;
private function __construct() {
session_start();
}
static public function getInstance() {
if( !self::$intsance instanceof self ) {
self::$instance = new self;
}
return self::$instance;
}
public function __set( $key, $value ) {
$_SESSION[$key] = $value;
}
public function __get( $key ) {
return $_SESSION[$key];
}
public function __isset( $key ) {
return array_key_exists( $key, $_SESSION );
}
public function __toString() {
return var_dump( $_SESSION );
}
}
class MyClass {
public function __construct() {
$session = Session::getInstance();
$session->waarde = "waarde van mijn sessie variabele";
}
public function __toString() {
$session = Session::getInstance();
echo $session->waarde;
//of:
echo $_SESSION['waarde'];
}
}
?>
Ik vraag mij enkel 1 ding af.. hoe doe je iets als unset($_SESSION['waarde']) nu dan?
Hipska schreef op 12.05.2009 20:25:
__unset() is ook een magic method. Persoonlijk heb ik het niet zo met dit soort overloading, het wordt er niet overzichtelijker op.Prachtige class Pim!
Ik vraag mij enkel 1 ding af.. hoe doe je iets als unset($_SESSION['waarde']) nu dan?
Ik vraag mij enkel 1 ding af.. hoe doe je iets als unset($_SESSION['waarde']) nu dan?
En inderdaad, die link van Karl is ook wel eens goed om door te lezen.
Gewijzigd op 01/01/1970 01:00:00 door Mark PHP
Ik gebruik ook niet graag singletons, maar voor bv DB kan dat wel handig zijn denk ik, nog niet nodig gehad.
EDIT: heb de class van Pim wat aangepast zodat hij wat meer generiek te gebruiken valt.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<?php
class Session {
protected static $init = false;
public function __construct() {
if(!self:$init) this->start();
}
protected function start() {
// hier kunnen nog andere dingen komen
// session_name(.....) bv.
self:$init = session_start();
}
public function __set( $key, $value ) {
$_SESSION[$key] = $value;
}
public function __get( $key ) {
return $_SESSION[$key];
}
public function __isset( $key ) {
// isset($_SESSION[$key]) kon ook
return array_key_exists( $key, $_SESSION );
}
public function __unset( $key ) {
unset( $_SESSION[$key] );
}
public function __toString() {
// want var_dump returnt niet
return print_r( $_SESSION , true);
}
public function destroy(){
// om alles te wissen van de sessie
return session_destroy();
}
}
?>
class Session {
protected static $init = false;
public function __construct() {
if(!self:$init) this->start();
}
protected function start() {
// hier kunnen nog andere dingen komen
// session_name(.....) bv.
self:$init = session_start();
}
public function __set( $key, $value ) {
$_SESSION[$key] = $value;
}
public function __get( $key ) {
return $_SESSION[$key];
}
public function __isset( $key ) {
// isset($_SESSION[$key]) kon ook
return array_key_exists( $key, $_SESSION );
}
public function __unset( $key ) {
unset( $_SESSION[$key] );
}
public function __toString() {
// want var_dump returnt niet
return print_r( $_SESSION , true);
}
public function destroy(){
// om alles te wissen van de sessie
return session_destroy();
}
}
?>
Gewijzigd op 01/01/1970 01:00:00 door Hipska BE
- __unset was ik inderdaad vergeten. Zie ook: http://ca.php.net/oop5.magic
- Ik zie dat je de getInstance() methode hebt verwijderd, wat betekent dat je nu iedere keer als je een sessie wilt gebruiken een nieuwe instantie van je sessie object moet aanmaken. Lijkt me niet wenselijk, aangezien je maar 1 sessie object hebt en het dus totaal overbodig is om meer dan 1 instantie van een sessie object te hebben. Wat je nog zou kunnen doen is je sessie instantie in een Registry gooien.
@Agirre:
Inderdaad, ik gebruik zelf meestal gewoon $_SESSION en zet in m'n bootstrap file bovenin session_start(), aangezien al mijn requests via die bootstrapper verlopen en ik dus zeker weet dat de sessie is gestart. Dit was puur ter illustratie hoe de TS zijn probleem met "2x een sessie start" of whatever op zou kunnen lossen. (2x een sessie starten zou overigens ook geen problemen hoeven opleveren... dus wat dat betreft is mijn class vrij useless ;-) )
Gewijzigd op 01/01/1970 01:00:00 door Pim Vernooij
Pim Vernooij schreef op 13.05.2009 11:25:
Ik gebruik ook een Session class hoor, wat ik bedoelde met onoverzichtelijk is __get(), __set() etc. Ik gebruik liever get(), set(), dan heb je de zaken meer in de hand....
Verder kan je deze class toch prima als parameter meegeven aan andere objecten. Daarvoor is singleton overbodig.
Bovendien zou je best, als je dat wilt, twee sessie objecten moeten kunnen maken. Gewoon even checken of de sessie al gestart is voordat je session_start() aanroept.
@Hipska
Je aangepaste class kan nu bij __get() en __unset() notices opleveren. Eerst even checken met isset() (of __isset()).
Gewijzigd op 01/01/1970 01:00:00 door Mark PHP
Code (php)
Agirre schreef op 13.05.2009 11:44:
Dat ben ik niet met je eens. De sessie array is van nature 'globaal'. M.a.w: er is er maar 1 van en hij is overal toegankelijk. Omdat dat zo is, stuur je de sessie array nooit mee als parameter. Legitimeert wat mij betreft het gebruik van een Singleton: je implementeerd namelijk de methode die PHP zelf hanteerd, echter op een iets andere manier zodat je wat meer controle hebt.Verder kan je deze class toch prima als parameter meegeven aan andere objecten. Daarvoor is singleton overbodig.
Bovendien zou je best, als je dat wilt, twee sessie objecten moeten kunnen maken. Gewoon even checken of de sessie al gestart is voordat je session_start() aanroept.
Bovendien zou je best, als je dat wilt, twee sessie objecten moeten kunnen maken. Gewoon even checken of de sessie al gestart is voordat je session_start() aanroept.
Pim Vernooij schreef op 13.05.2009 12:02:
Ik ben sowieso tegen singletons en dus vind ik het ook hier onnodig. Meerdere sessie instanties die werken op één enkele global is mijn insziens niets verkeerds aan.Dat ben ik niet met je eens. De sessie array is van nature 'globaal'. M.a.w: er is er maar 1 van en hij is overal toegankelijk. Omdat dat zo is, stuur je de sessie array nooit mee als parameter. Legitimeert wat mij betreft het gebruik van een Singleton: je implementeerd namelijk de methode die PHP zelf hanteerd, echter op een iets andere manier zodat je wat meer controle hebt.
Stel dat we een pluginsysteem hebben, het lijkt mij netjes om elke plugin in een soort van sandbox te laten opereren. Dat betekend m.i. dat het niet netjes is om een singleton instantie op te roepen (en dus te delen). Maar wél om een apart sessie object aan te maken voor privé gebruik. Wat mij betreft net iets netter en vooral overzichtelijker.
Wat meteen betekend dat ik geen probleem zie in het doorgeven van een sessie object als parameter (zelf stel je ook voor om het in een registry op te nemen). Voor de programmeur bestaat $_SESSION immers niet meer, alles gaat via de klasse Session.
Gewijzigd op 01/01/1970 01:00:00 door Mark PHP
@Arian: Aan die manier had ik meteen ook gedacht, maar had het even niet uitgewerkt. Ook dit bewijst dat singletons hier niet handig kunnen zijn.
EDIT: meer zoiets dus? :-)
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<?php
class Session {
protected $namespace;
public function __construct($namespace) {
session_start(); // levert volgens Pim geen problemen op
$this->namespace = $namespace;
if(!array_key_exists( $this->namespace , $_SESSION ))
$_SESSION[$this->namespace] = array();
}
public function __set( $key, $value ) {
$_SESSION[$this->namespace][$key] = $value;
}
public function __get( $key ) {
return $_SESSION[$this->namespace][$key];
}
public function __isset( $key ) {
return array_key_exists( $key, $_SESSION[$this->namespace] );
}
public function __unset( $key ) {
unset( $_SESSION[$this->namespace][$key] );
}
public function __toString() {
return print_r( $_SESSION[$this->namespace] , true);
}
public function destroy(){
// om deze namespace te wissen
unset($_SESSION[$this->namespace]);
}
}
?>
class Session {
protected $namespace;
public function __construct($namespace) {
session_start(); // levert volgens Pim geen problemen op
$this->namespace = $namespace;
if(!array_key_exists( $this->namespace , $_SESSION ))
$_SESSION[$this->namespace] = array();
}
public function __set( $key, $value ) {
$_SESSION[$this->namespace][$key] = $value;
}
public function __get( $key ) {
return $_SESSION[$this->namespace][$key];
}
public function __isset( $key ) {
return array_key_exists( $key, $_SESSION[$this->namespace] );
}
public function __unset( $key ) {
unset( $_SESSION[$this->namespace][$key] );
}
public function __toString() {
return print_r( $_SESSION[$this->namespace] , true);
}
public function destroy(){
// om deze namespace te wissen
unset($_SESSION[$this->namespace]);
}
}
?>
Gewijzigd op 01/01/1970 01:00:00 door Hipska BE
Eventueel zou je die session start dus met een static kunnen zorgen dat je hem maar één keer doet. Zoiets als ik in mijn eerste post zei:
Arian schreef op 05.05.2009 17:09:
Je kunt ook gewoon een session class maken. Dan gebruik je voortaan voor al je sessions de session class.
in je constructor zet je dan zoiets:
die $sessionStarted is natuurlijk een static variabele:
in je constructor zet je dan zoiets:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
if(!self::$sessionStarted){
session_start();
self::$sessionStarted = true;
}
?>
if(!self::$sessionStarted){
session_start();
self::$sessionStarted = true;
}
?>
die $sessionStarted is natuurlijk een static variabele:
Maar Pim vertrouwde ons toe dat 2x session start geen kwaad kon.
Hipska schreef op 12.05.2009 22:40: