Discussion :

[MaitrePylos]

Bonjour,

dans mon bootstrap, j'initialise une session

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

dans une Action, j'initialise une valeur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
$session->id=4;

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

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]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

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]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.