Problème avec zend_session [Résolu]

[MaitrePylos]

Bonjour,

dans mon bootstrap, j'initialise une session

Code :

1
2
 
$session = new Zend_Session_Namespace('Default');

dans une Action, j'initialise une valeur

Code :

1
2
 
$session->id=4;

je n'arrive pas à récupérer cette valeur dans une autre action

Code :

1
2
3
4
 
Zend_Debug::dump($session->id);//donne null
 
Zend_Debug::dump($_SESSION['Default']['id'])//donne la réponse;

par contre si je réinstancie la session cela fonctionne

Code :

1
2
3
 
$session = new Zend_Session_Namespace('Default');
Zend_Debug::dump($session->id);//donne la réponse

Est-ce que je dois à chaque fois instancié zend_session?

[Eusebe]

Bonjour,

qu'est-ce que tu obtiens quand tu fais un

Code :

Zend_Debug::dump($session);

Dans l'action dans laquelle tu n'arrives pas à récupérer la valeur ?

[MaitrePylos]

sans instancié de nouveau, j'obtient null

en instanciant

Code :

1
2
3
4
 
object(Zend_Session_Namespace)#35 (1) {
  ["_namespace:protected"] => string(7) "Default"
}

[Eusebe]

Et comment as tu récupéré ton $session dans ton action (alors qu'il est initialiés dans le bootstrap) ?
Est-ce qu'il est passé par le registre ?

[Alexandre T]

Envoyé par MaitrePylos

Est-ce que je dois à chaque fois instancié zend_session?

Tout à fait !

Mais tu peux créer un objet qui retourne cela par une méthode statique. L'idée est de créer ensuite d'autres fonctions statiques qui stocke cela.

Si dessous un exemple de code. Il s'agit d'un jeu en ligne. L'objet Sauvegarde stocke les données de la partie (composant ESD_Partie) en session. Pour l'instant le jeu, en bêta, ne permet pas de stockage en BDD, mais ce n'est pas l'objet du débat.

Code :

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
53
54
55
56
57
58
59
60
61
62
63
 
<?php
 
/**
 * ESD_Sauvegarde
 *
 * chargement de la sauvegarde
 *
 * @version $Id$
 * @license BSD
 * @copyright Alexandre TRANCHANT 2008
 */
 
/**
 * ESD_Sauvegarde
 *
 */
class ESD_Sauvegarde{
    const CLEF_SESSION  = 'ESD_Partie';
 
    /**
     * Retourne la partie sauvegardée
     * @access public
     * @return ESD_Partie
     */
    public static function charger(){
        $namespace = new Zend_Session_Namespace(ESD_Sauvegarde::CLEF_SESSION);
        if (!self::isValide($namespace->partie)){
            $namespace->partie = self::creer();                
        }
        return $namespace->partie;
    }
    /**
     * Sauvegarde la partie
     *
     * @param ESD_Partie $sauvegarde
     */
    public static function sauvegarder(ESD_Partie $sauvegarde){
        $namespace = new Zend_Session_Namespace(ESD_Sauvegarde::CLEF_SESSION);
        $namespace->partie=$sauvegarde;
    }
    /**
     * Crée une nouvelle partie
     *
     * @return ESD_Partie
     */
    public static function creer(){
        $partie = new ESD_Partie();
        self::sauvegarder($partie);
        return $partie;        
    }
    /**
     * Indique si l'objet passé en paramètre est une partie valide
     *
     * @todo gérer les versions en cours
     * @param unknown_type $object
     * @return boolean
     */
    public static function isValide($object=null){
        return $object instanceof ESD_Partie;        
    }
}
?>

[MaitrePylos]

Envoyé par Eusebe

Et comment as tu récupéré ton $session dans ton action (alors qu'il est initialiés dans le bootstrap) ?
Est-ce qu'il est passé par le registre ?

Non, je pensais juste que comme il étais dans le bootstrap, im étais initialise à chaque appel d'Action.

pour la classe statique, je trouve que cela commence à faire beaucoup de code, juste pour moi avoir un $_SESSION['id'].

[Eusebe]

Envoyé par MaitrePylos

Non, je pensais juste que comme il étais dans le bootstrap, im étais initialise à chaque appel d'Action.

pour la classe statique, je trouve que cela commence à faire beaucoup de code, juste pour moi avoir un $_SESSION['id'].

Une variable initialisée dans le bootstrap n'est pas disponible dans les classes. Ca a l'air d'être un problème de portée des variables dans ton cas...

Ce que tu dois pouvoir faire, c'est stocker ta session dans le registre pour pouvoir le récupérer ensuite dans les actions :

Code :

1
2
3
4
5
6
7
// dans le bootstrap
$session = new Zend_Session_Namespace('Default');
Zend_Registry::set('session', $session);
 
// dans les actions
$session = Zend_Registry::get('session');
Zend_Debug::dump($session->id);

Mais je ne comprend même pas comment tu as réussi à initialiser la valeur 'id' dans une action sans récupérer la variable

[MaitrePylos]

N'essaye pas de comprendre, je ne comprend pas moi-même

Merci pour votre aide.

[vg33]

Le passage par le registre ne me semble pas utile ici car il est aussi long (2 lignes de code) que de recréer un Zend_Session_Namespace à chaque fois. De plus, il est déconseillé dans la doc d'utiliser $_SESSION si on utilise Zend_Session.
Donc il me semble (voir la première réponse) qu'il y ait 2 solutions :
1) soit recréer un Zend_Session_Namespace avant chaque utilisation des sessions ;
2) soit étendre Zend_Session avec une méthode My_Session::getData($namespace, $name) et My_Session::setData($namespace, $name, $data) qui utiliseront le registre si besoin pour éviter d'instancier 10 fois le même Zend_Session_Namespace.

[MaitrePylos]

En fait, comme je vais devoir, utiliser pas mal les sessions, je me suis pencher sur cette classe My_Session.

si je fais les fonctions suivantes

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
<?php
class My_Session
{
	public static function setData($nameSpace,$name,$data)
	{
		$session = new Zend_Session_Namespace($nameSpace);
		$session->$name = $data;
	}
 
	public static function getData($nameSpace,$name)
	{
		$session = new Zend_Session_Namespace($nameSpace);
		return $session->$name;
 
}
 
?>

Est-il vraiment nécessaire de le passer dans le registre ?

[vg33]

Non. C'était uniquement pour ne pas créer une nouvelle instance de Zend_Session_Namespace à chaque appel.
J'ai moi-même codé ce My_Session. Autant c'est pratique pour getData(), autant c'est un peu lourd pour setData en cas de modifications multiples de la même session dans le même script. C'est plus simple de manipuler directement l'objet Zend_Session_Namespace... surtout si My_Session en instancie un à chaque fois (dans ce cas-là, le remède est pire que le mal).

[Eusebe]

Envoyé par MaitrePylos

Est-il vraiment nécessaire de le passer dans le registre ?

Bonjour,

sans passer par le registre, si tu crées une classe, pourquoi ne pas y créer un attribut statique $session qui n'est initialisé qu'à la première utilisation ?

[MaitrePylos]

Oui, faudrais repenser cette classe,en rajoutant méthode et constructeur.

ce qui nous permettrais en cas de multiple session d'instancier cette classe et de bénéficier de méthode légère.

et en cas de manipulation simple, de faire appel aux méthodes static.

[Alexandre T]

Envoyé par Eusebe

Mais je ne comprend même pas comment tu as réussi à initialiser la valeur 'id' dans une action sans récupérer la variable

Il m'est avis que cette valeur a été initialisée avant. C'est une variable de session. Elle pouvait trainer là, initialisée.

Il est inutile de passer par le registre et ce serait gâcher la façon dont est codée Zend_Namespace. L'avantage de Zend_Namespace est de ne pas recopier la variable de session dans un autre tableau. Zend_Namespace se contente d'organiser la gestion du tableau $_SESSION. Son avantage est de ne pas multiplier les variables en mémoire comme on le voit avec d'autres FrameWork.

Zend_Namespace étant accessible partout, il est inutile de passer par une variable de registre.

Pour vos dernières remarques, je trouve préférable de mettre le premier argument en seconde place et de paramétrer la valeur par défaut. Ce qui donne :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
class My_Session
{
    public static function setData($name,$data,$nameSpace='default')
    {
        $session = new Zend_Session_Namespace($nameSpace);
        $session->$name = $data;
    }
    
    public static function getData($name,$nameSpace='default')
    {
        $session = new Zend_Session_Namespace($nameSpace);
        return $session->$name;

 
}
 
?>

Vous pouvez même tester avec une variable statique et le dernier paramètre accepterait null au lieu de défaut. Si la namespace est initialisé, alors la variable statique est modifiée.

Bref ça donnerait un truc comme cela :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
class My_Session
{
       private static $nameSpace = 'default';
    public static function setData($name,$data,$nameSpace=null)
    {
        if(isset($nameSpace)){
            self::nameSpace = $nameSpace;
        }
        $session = new Zend_Session_Namespace(self::nameSpace);
        $session->$name = $data;
    }
    
    public static function getData($name,$nameSpace=null)
    {
        if(isset($nameSpace)){
            self::nameSpace = $nameSpace;
        }
        $session = new Zend_Session_Namespace(self::nameSpace);
        return $session->$name;

 
}

J'ai pas du tout testé la dernière méthode.

[MaitrePylos]

Soit, si je fais la classe suivante (a teste)

Code :

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
 
<?php
class My_Session
{
    private static $_nameSpace = 'default';
    private $_session;
    function __construct ($nameSpace = null)
    {
        if (isset($nameSpace))
        {
            self::$_nameSpace = $nameSpace;
        }
        $this->_session = new Zend_Session_Namespace(self::$_nameSpace);
    }
 
    public function get_session ($name)
    {
        return $this->_session->$name;
    }
 
    public function set_session ($data,$name)
    {
        $this->_session->$name = $data;
    }    
 
    public static function setData ($name, $data, $nameSpace = null)
    {
        if (isset($nameSpace))
        {
            $this->_nameSpace = $nameSpace;
            self::$_nameSpace;
        }
        $session = new Zend_Session_Namespace(self::$_nameSpace);
        $session->$name = $data;
    }
    public static function getData ($name, $nameSpace = null)
    {
        if (isset($nameSpace))
        {
            self::$_nameSpace = $nameSpace;
        }
        $session = new Zend_Session_Namespace(self::$_nameSpace);
        return $session->$name;
    }
}
?>

J'ai la possibilité de faire appel aux méthodes statique, pour une session, ou alors j'instancie la classe que je dois faire appel à plusieurs sessions.


Maintenant, puis-je mélanger les méthodes statique et non-statique.

Ne devrais-je pas faire deux classes ?


Edit : les méthodes statiques fonctionnent en tous cas

[Alexandre T]

Je ferais deux classes car là l'usage de la classe est source de confusion. Aujourd'hui, c'est clair, mais dans six mois quand tu repasseras sur ce code, ce ne sera pas le cas. La seconde peut utiliser la première (celle des statiques)

[MaitrePylos]

Ok,

donc voici les classes, pour ma gestion de sessions

Classe avec les méthodes statiques

Code :

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
 
<?php
class My_Session
{
    protected  static $_nameSpace = 'default';
 
    public static function setData ($name, $data, $nameSpace = null)
    {
        if (isset($nameSpace))
        {
            $this->_nameSpace = $nameSpace;
            self::$_nameSpace;
        }
        $session = new Zend_Session_Namespace(self::$_nameSpace);
        $session->$name = $data;
    }
    public static function getData ($name, $nameSpace = null)
    {
        if (isset($nameSpace))
        {
            self::$_nameSpace = $nameSpace;
        }
        $session = new Zend_Session_Namespace(self::$_nameSpace);
        return $session->$name;
    }
}
?>

Classe avec constructeur qui hérite de la classe précedente

Code :

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
 
<?php
class My_Classe_Session extends My_Session 
{
	private $_session;
 
	function __construct ($nameSpace = null)
    {
        if (isset($nameSpace))
        {
            self::$_nameSpace = $nameSpace;
        }
        $this->_session = new Zend_Session_Namespace(self::$_nameSpace);
    }
 
    public function get_session ($name)
    {
        return $this->_session->$name;
    }
 
    public function set_session ($data,$name)
    {
        $this->_session->$name = $data;
    }    
}
?>

[Alexandre T]

Code :

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
 
<?php
class My_Classe_Session extends My_Session 
{
    private $_session;
    protected  $_nameSpace = 'default';    
 
    function __construct ($nameSpace = null)
    {
        if (isset($nameSpace))
        {
            $this->setNameSpace($nameSpace);
        }
        $this->_session = new Zend_Session_Namespace(self::$_nameSpace);
    }
 
    public function get_session ($name)
    {
        return $this->_session->$name;
    }
 
    public function set_session ($data,$name)
    {
        $this->_session->$name = $data;
    }    
 
    /**
     * @todo Ajouter le getter et le setter de nameSpace
     */
}
?>

A mon avis c'est mieux d'utiliser une variable non statique pour namespace dans la seconde méthode. Ajoute du coup un getter et un setter cet je pense que ce sera du tout bon.

[MaitrePylos]

Dans ce cas faisons plutôt 2 classes distinct, c'est plus clair(enfin pour moi)

Code :

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
 
<?php
class My_Classe_Session
{
	private $_session;
	private  $_nameSpace = 'default'; 
 
	function __construct ($nameSpace = null)
    {
        if (isset($nameSpace))
        {
            $this->_nameSpace = $nameSpace;
        }
        $this->_session = new Zend_Session_Namespace($this->_nameSpace);
    }
 
    public function get_session ($name)
    {
        return $this->_session->$name;
    }
 
    public function set_session ($data,$name)
    {
        $this->_session->$name = $data;
    }
 
}
?>

[Alexandre T]

Je n'avais pas remarqué que l'une héritait de l'autre. La dernière solution me semble très bien.