Witam,
szukam informacji na temat używania seji w Zend Framework, może ktoś gdzieś widział coś na ten temat, albo wie coś o tym więcej? Może jakiś tutorial z np. systemem logowania?
Z góry wielkie dzięki
Pozdrawiam

Witam,

Zend samego w sobie machanizmu sesji nie ma. Nic nie stoi na przeszkodzie zeby uzywac $_SESSION.
Przyklad mniej wiecej taki:

1. session_start() w index.php
2. Akcja Logowanie:
- sprawdz czy istnieje uzytkownik w bazie (haslo i login poprawne)
- $_SESSION['zalogowany'] = true;

I juz

Bardzo proste i bardzo nieladne.

Napisalem (moim zdaniem) bardzo ciekawy mechanimz obslugi sesji.

Założenia

Framework udostępnia klasę Rapide_Session do obsługi sesji.

[PHP] pobierz, plaintext 
<?php
 
Rapide::loadInterface('Rapide_Session_Interface');
Rapide::loadClass('Rapide_Session_Exception');
 
Rapide::loadInterface('Rapide_Session_Handler_Interface');
 
class Rapide_Session
{
  private
	$_bSessionStarted = false,
	$_sNameSpace;
 
  public function __construct($sNameSpace = null)
  {
	if(isset($sNameSpace))
	{
	  $this->_sNameSpace = $sNameSpace;
 
	  if(!isset($_SESSION[$this->_sNameSpace]))
		$_SESSION[$this->_sNameSpace] = array();
	}
  }
 
  public function getNameSpaceName()
  {
	return $this->_sNameSpace;
  }
 
  public function setHandler(Rapide_Session_Handler_Interface $oHandler)
  {
	if($this->started())
	{
	  $sError = 'Session has already started';
	  throw new Rapide_Session_Exception($sError);
	}
 
	session_set_save_handler
	(
	  array(& $oSessionHandler, 'open'),
	  array(& $oSessionHandler, 'close'),
	  array(& $oSessionHandler, 'read'),
	  array(& $oSessionHandler, 'write'),
	  array(& $oSessionHandler, 'destroy'),
	  array(& $oSessionHandler, 'gc')
	);
  }
 
  public function started()
  {
	return (bool)strlen(session_id());
  }
 
  public function start()
  {
	if(!$this->started())
	{
	  if(headers_sent())
	  {
		$sError = 'Headers has already sent';
		throw new Rapide_Session_Exception($sError);
	  }
 
	  session_start();
	}
  }
 
  public function close()
  {
	if(!$this->started())
	{
	  $sError = 'Session has not started yet';
	  throw new Rapide_Session_Exception($sError);
	}
 
	if(isset($this->_sNameSpace))
	  $_SESSION[$this->_sNameSpace] = array();
	else
	  $this->destroy();
  }
 
  public function destroy()
  {
	if(!$this->started())
	{
	  $sError = 'Session has not started yet';
	  throw new Rapide_Session_Exception($sError);
	}
 
	session_destroy();
  }
 
  public function __get($sParameters)
  {
	if(!$this->started())
	{
	  $sError = 'Session has not started yet';
	  throw new Rapide_Session_Exception($sError);
	}
 
	if(isset($this->_sNameSpace))
	{
	  return isset($_SESSION[$this->_sNameSpace][$sParameters]) ?
			 $_SESSION[$this->_sNameSpace][$sParameters] :
			 null;
	}
	else
	{
	  return isset($_SESSION[$sParameters]) ?
			 $_SESSION[$sParameters] :
			 null;
	}
  }
 
  public function __set($sParameters, $mValue)
  {
	if(!$this->started())
	{
	  $sError = 'Session has not started yet';
	  throw new Rapide_Session_Exception($sError);
	}
 
	if(isset($this->_sNameSpace))
	  $_SESSION[$this->_sNameSpace][$sParameters] = $mValue;
	else
	  $_SESSION[$sParameters] = $mValue;
  }
 
  public function __isset($sParameters)
  {
	if(!$this->started())
	{
	  $sError = 'Session has not started yet';
	  throw new Rapide_Session_Exception($sError);
	}
 
	if(isset($this->_sNameSpace))
	  return isset($_SESSION[$this->_sNameSpace][$sParameters]);
	else
	  return isset($_SESSION[$sParameters]);
  }
 
  public function getNameSpace()
  {
	if(!$this->started())
	{
	  $sError = 'Session has not started yet';
	  throw new Rapide_Session_Exception($sError);
	}
 
	if(isset($this->_sNameSpace))
	  return $_SESSION[$this->_sNameSpace];
	else
	  return $_SESSION;
  }
}
 
?>
[PHP] pobierz, plaintext 

Klasa Rapide_Session jest we frameworku, ale w zasadzie skorzystac z niej powinien tylko sam framework (programista uzyje innej klasy).

Programista ma do uzytku klase Rapide_User

[PHP] pobierz, plaintext 
<?php
 
Rapide::loadInterface('Rapide_User_Interface');
Rapide::loadClass('Rapide_User_Exception');
Rapide::loadClass('Rapide_Session');
 
class Rapide_User implements Rapide_User_Interface
{
  private
	$_oSession,
	$_oDataSession;
 
  public function __construct()
  {
	$this->_oSession	 = new Rapide_Session('Rapide_User');
	$this->_oDataSession = new Rapide_Session('Rapide_User_Data');
 
	$this->_oSession->start();
	$this->_oDataSession->start();
 
	if(!isset($this->_oSession->authenticated))
	  $this->_oSession->authenticated = false;
 
	if(!isset($this->_oSession->groups))
	  $this->_oSession->groups = array();
  }
 
  public function getGroups()
  {
	return $this->_oSession->groups;
  }
 
  public function setGroups($aGroups = array())
  {
	if(!is_array($aGroups))
	{
	  $sError = 'Argument 1 for Rapide_User::setGroups() must be an array';
	  throw new Rapide_User_Exception($sError);
	}
 
	$this->_oSession->groups = $aGroups;
  }
 
  public function hasGroup($sGroup)
  {
	foreach($this->getGroups() as $iKey => $sUserGroup)
	{
	  if($sUserGroup == $sGroup)
		return true;
	}
 
	return false;
  }
 
  public function isAuthenticated()
  {
	return $this->_oSession->authenticated;
  }
 
  public function setAuthenticated($bAuthenticated = true)
  {
	$this->_oSession->authenticated = (bool)$bAuthenticated;
  }
 
  public function __get($sParameter)
  {
	return $this->_oDataSession->$sParameter;
  }
 
  public function __set($sParameters, $mValue)
  {
	$this->_oDataSession->$sParameter;
  }
 
  public function __isset($sParameter)
  {
	return isset($this->_oDataSession->$sParameter);
  }
 
  public function destroy()
  {
	$this->setGroups(array());
	$this->setAuthenticated(false);
 
	$this->_oSession->close();
	$this->_oDataSession->close();
  }
}
 
?>
[PHP] pobierz, plaintext 

Kiedy programista chce zapisac dane w sesji, pisze:

[PHP] pobierz, plaintext 
<?php
$oUser = new Rapide_User;
 
$oUser->zmienna = 'wartosc';
?>
[PHP] pobierz, plaintext 

Ponadto klasa Rapide_User dostarcza metod dajacych mozliwosc kontrole bezpieczenstwa w aplikacji.
Po zalogowaniu sie nalezy zrobic:

[PHP] pobierz, plaintext 
<?php
$oUser->setAuthenticated();
?>
[PHP] pobierz, plaintext 

Pozniej w aby sprawdzic czy uzytkownik zostal zalogowany:

[PHP] pobierz, plaintext 
<?php
if($oUser->isAuthenticated()) {
//cos
}
?>
[PHP] pobierz, plaintext 

Przepraszam, ze post napisany na szybko, ale nie mam duzo czasu

Moze pozniej przedstawie lepszy opis i uzycie.

Pozdrawiam, Adrian.

wielkie dzięki,
Mam jeszcze takie pytanie (ad. sposobu z $_SESSION): jesli tak zrobie to musze w każdej akcji w każdym kontrolerze sprawdzać czy użytkownik jest zalogowany (wpisująć odpowiednią ściazke może sie dostać gdzie nie powinien), a ja chciałbym tego uniknąć. Jakiś pomysł?

PS Twój pomysł obsługi sesji poprzez klasy frameworka napewno przeanalizuje
Pozdrawiam

[ot]@Prph to wszystko przypomina mi Mojavi.. (poza handlerem)[/ot]

@Splatch : Haha, po czesci jest to rozwiazanie z mojavi. W zasadzie jedynie obecnosc klasu User, bo cala reszta raczej na byla wzorowana na mojavi. Nie wiem jak jest z najnowszym mojawi ale chyba jeszcze w 3.0 bylo nieco inaczej. W kazdym bardz razie, widac rozwiazanie calkiem dobre

@1maciek: Nie musisz w kazdej akcji sprawdzac czy uzytkownij jest zalogowany. Od tego sa pluginy. Akurat pluginy w Zend Frameworku uwazam ze sa bardzo, ale to bardzo dobrze przemyslane i ze sa duzo lepsze od tych z mojavi/symphony. Zerknij do dokumentacji. Jak dobrze pamietam, we Front Controlerze mozna zdefiniowac PluginManagera czy jakos tak. W dokumentacji jest to opisane. Pluginy posiadaja bodajze 4 metody, ktore uruchamiane sa w odpowiedniej chwili w czasie wykonywania dispathcingu (pracy dispatchera).

Rozwiazanie to tak bardzo mi sie spodobalo, ze wykorzystalem je w swoim frameworku. Przyklad:

[PHP] pobierz, plaintext 
<?php
 
abstract class Rapide_Plugin implements Rapide_Plugin_Interface
{
 
  // metoda wywolana przed rozpoczeciem dispatchingu
  public function preDispatchLoop(Rapide_Dispatcher_Token_Interface $oToken)
  {
	return $oToken;
  }
 
  // wywolywana po zakonczeniu dispatchingu
  public function postDispatchLoop(Rapide_Dispatcher_Token_Interface $oToken)
  {
	return $oToken;
  }
 
 
  // wywolana przed uruchomieniem akcji
  public function preExecution(Rapide_Dispatcher_Token_Interface $oToken)
  {
	return $oToken;
  }
 
  // po zakonczeniu akcji
  public function postExecution(Rapide_Dispatcher_Token_Interface $oToken)
  {
	return $oToken;
  }
}
 
?>
[PHP] pobierz, plaintext 

Na bazie tej abstrakcyjnej klasy mozna szybko zbudowac wlasne pluginy, miedzy innymi do bezpieczenstwa:

[PHP] pobierz, plaintext 
<?php
 
Rapide_Plugin_Security implements Rapide_Plugin_Interface
{
 
 
  public function preExecution(Rapide_Dispatcher_Token_Interface $oToken)
  {
	if(!isset($_SESSION) || !$_SESSION['zalogowany'])
	{
	  $oToken = new Rapide_Dispatcher_Token('Error', 'Error403');
	}
	return $oToken;
  }
}
 
?>
[PHP] pobierz, plaintext 

W efekcie na ekranie pojawi sie strona z error 403, zamiast np. dodaj newsa.

Oczywiscie zeby to wszystko mialo jakies swoje zastosowanie, nalezy zrobic pliki konfiguracyjne, zeby framework wiedzial, ktore akcjie wymagaja logowania, a ktore nie.

Pozdrawiam, Adrian.

OK, fajnie a gdzie (fizycznie) umieścić klasę implementującą plugin, żeby dispatcher z niej korzystał? - ok z tym jakoś dałem sobie rade (chociaż chętnie zobacze jak powinno być to zrobione fachowo ), ale wywala mi taki błąd



a kod wygląda tak

[PHP] pobierz, plaintext 
<?php
class LoginControl implements Zend_Controller_Plugin_Interface {
 
	public function preDispatch (Zend_Controller_Dispatcher_Token $action) {
		echo 'pD';
		return $action;
	}
}
?>
[PHP] pobierz, plaintext 

include path mam ustawiona na katalog /library/ tam mam też LoginControl.php

Witam,

W dokumentacji Zenda masz gdzie powinienes umieszczac swoje wlasne klasy, ktore budujesz z wykorzystaiem klas Zenda.

Strzelam, ze jest to np: MojaAplikacja_Plugin_LoginControl, wiec powinienes umiescic to w katalogu z plikiem Zend.php w katalogu MojaAplikacja/Plugin/LoginControl.php.

Wtedy mozesz zrobic zaladowanie plaginu przez Zend::loadClass('MojaAplikacja_Plugin_LoginControl');

Nie jestem tego pewien, poniewaz nie uzywam Zenda. Wiem o nim troche, bo pod wieloma wzgledami imponuje mi Zend Framework.

Niebawem ukoncze swojego frameworka Rapide. Z racji, ze bardzo podoba mi sie prostota Zenda i organizacja plikow, moj framework implementuje i jedno i drugie Wtedy moge podeslac Ci kod i zorientujesz sie jak to mniej wiecej wyglada w calosc. Zend Framework dostarcza solidnej platformy do zbudowania aplikacji, ale trzeba sie sporo nameczyc, zeby cos odpalic najmniejszym nakladem pracy.

Rapide przede wszystkim poprawnie implementuje MVC. W ZF model jest, kontroler jest, ale widok jest mowiac krotko - nieporozumieniem. Programisci ZF albo wyszli z zalozenia ze i tak w aplikachach webowych prozentowana tresc to HTML, albo pomylilo im sie pojecie szablonow z widokiem Ponadto w Rapide zintegrowalem kontrole dostepu (ACL) z klasa User, wiec teraz wszystko chodzi zgrabnie, a co najwazniejsze - dziala.

Adrian.

Nic im się nie pomyliło. Po prostu uważają że kolejna warstwa jest zbędna bo php sam w sobie jest świetnym interpreterem szablonów. Ja się z nimi w całej rozciągłości zgadzam. Systemy szablonów z własną składnią to przerost formy - wystarczą wybrane mechanizmy szablonów (helpers, output filters, cache) i czysty php.

Z dokumentacji Zend Framework:
Przykład szablonu - jak dla mnie czytelne wystarczająco, nawet dla laika.

@dragossani: spagetti kod nie jest zbyt ciekawym rozwiązaniem. Mimo, że wydajnym.
W mojej ocenie łatwiej zarządzać i w ogóle odnaleźć się w systemie wzorców niż w przeplatanym kodzie HTML i php, gdzie osoby postronne mogą nie wiedzieć o przeznaczeniu wszystkich zmiennych.

Dodatkowo jest ryzyko, że ktoś wywoła np delete() na danym modelu. Wzorce minimalizują to ryzyko i dają możliwość pewnego ujednolicenia tej warstwy.

A co do templateów z użyciem ZF to ciekawe rozwiązanie zostało przedstawione na ZDZ:
http://devzone.zend.com/node/view/id/120

Kod z posta jednak nie jest kompletny bo brakuje mu przeciążenia metody _script() - ale w komentarzach jest ona podana.

To trochę akademicki spór i mam wrażenie, że może być go trudno rozstrzygnąć bo argumenty są w dużej mierze natury estetycznej, a jak wiadomo o gustach się nie dyskutuje. :roll2:

O spagetti kodzie mówi się raczej w kontekście całkowitego ignorowania podziału na szablon i kod. Tutaj mamy natomiast do czynienia ze świadomym użyciem składni php w konstrukcji szablonu. Nie po to by szablon był czymś więcej niż jest lecz po to by nie wymyślać koła na nowo. Rozumiem odruchowy wstręt do samego pojawienia się php w szablonie (przecież po to jest szablon żeby kodu php tu nie było!) ale to moim zdaniem kompulsywna reakcja, a nie wynik chłodnej kalkulacji. Przecież chodzi nam o uzyskanie określonego efektu, pewnej logicznie wyodrębnionej struktury, a nie na wymyśleniu nowego meta-języka. Smarty i inne systemy szablonów to niestety kolejne warstwy meta-języka, kolejna składnia do opanowania. php użyte w szablonach nie musi skutkować bałaganem w strukturze aplikacji. Osoby postronne faktycznie nie muszą wiedzieć o przeznaczeniu wszystkich zmiennych i dlatego widok w Zend Framework dostaje zmienne tak jak w Smarty i twórca szablonu operuje tylko na nich. Składnia php przy takim zakresie jaki potrzebny jest przy tworzeniu szablonów jest nieskomplikowana i sprawdza się w tej roli.

W sumie racja. Wybor tych czy innych templateow glownie opiera sie o estetyke, ale nie mozna tez zapomniec, ze przeciez chocizaby smarty kompiluje kod do postaci php. Odchodzi nam wiec koniecznosc kazdorazowego otwierania i zamykania tagow php, a to oszczedza troche czasu przy projektowaniu wzorca.

No ale zgodze sie, ze jest to raczej kwestia gustow niz koniecznosci

No to już jest obsługa sesji (w inkubatorze). Jak na razie 0 dokumentacji. Ktoś może już coś na niej działał?