Ik ben een Request class aan het maken. Via deze class kan ik bijv. het domein van de opgevraagde URL opvragen, of het subdomein, en of het een beveiligde (https) verbinding betreft. De gegevens haal ik op uit de $_SERVER array. Nu had ik gewoon allemaal public funtcions gemaakt. Echter... ik realiseer me ineens dat gedurende 1 request de $_SERVER array altijd hetzelfde is. Het zou dan raar zijn als ik telkens als ik de Request class nodig heb "new Request()" zou doen.
Nu vraag ik me af wat volgens jullie de beste oplossing is. Ik zou een singleton kunnen maken, zodat je niet "$request = new Request()" doet, maar "$request = Request::getInstance()". Wat ik ook kan doen is iedere functie in de Request class static maken, zodat ik het domein bijv. als volgt opvraag: $domain = Request::getDomain();
Ah oké, nu snap ik wat je bedoelt. In mijn voorgaande websites werkte ik altijd alleen maar met de huidige sessie, en niet met de overige sessies.
Voor mijn beeldvorming... de sessie class is de huidige sessie, en de session manager gebruik je om sessies aan te maken, updaten en te verwijderen... maar dus ook om de huidige sesie uit te lezen.
Maar je bestuurt je huidige sessie dus ook met de session manager? Dan vraag ik me wel af wat voor functies er zitten in die session class? Moet ik me die session class dan voorstellen als een soort opslag container met een set en een get functie? En dat je dan via de session manager de set en get functie van de session class aanspreekt?
Die klassen hebben zo'n lay-out:
<?php
class Session
{
/**
* Sets the identifier of this session.
*
* @param int $id
*/
public function setId($id)
{}
/**
* Gets the identifier of this session.
*
* @return int
*/
public function getId()
{}
/**
* Sets the value of this session.
*
* @param string $value
*/
public function setValue($value)
{}
/**
* Gets the value of this session.
*
* @return string
*/
public function getValue()
{}
}
class SessionManager
{
/**
* Creates a session.
*
* @param int $id
* @param string $value
*/
public function create($id, $value)
{}
/**
* Gets a session by identifier.
*
* @param int $id
*/
public function read($id)
{}
/**
* Updates a session.
*
* @param Session $session
*/
public function update(Session $session)
{}
/**
* Deletes a session.
*
* @param Session $session
*/
public function delete(Session $session)
{}
}
?>
Het mooie hiervan is dat je veel verschillende soorten SessionManagers kunt gebruiken, eentje die de sessies in de Response class instelt, eentje die ze in de database opslaat, ect. Met DI is het een kwestie van 1 regeltje aanpassen en klaar ben je!
>> setId($id): wat bedoel je hiermee... een session krijgt toch automatisch een session_id?
Dat komt door een benamings verschil tussen jou en mij, jij zal het waarschijnlijk Session::setName($name) noemen.
>> update: wat bedoel je hiermee. Wat versta je onder het "updaten" van een sessie?
<?php
$session = $sessionManager->get('foo');
"Dat komt door een benamings verschil tussen jou en mij, jij zal het waarschijnlijk Session::setName($name) noemen."
Maar je hebt het hier toch over de sessie_naam? Dus de naam van het sessiebestand? Die geef ik namelijk nooit een naam omdat dat vanzelf gebeurt als je session_start uitvoert. Waarom zou je die naam aanpassen? Maar waarschijnlijk begrijp ik je verkeerd.
<?php
$session = $sessionManager->get('foo');
$session->setValue('new value');
$sessionManager->update($session);
?>
$session = $sessionManager->get('foo');
Wat haal je hier nu precies op? Haal je een complete S_SESSION array op? Of haal je nu $_SESSION['foo'] op?
Sorry, ben even de weg kwijt.
$session->setValue('new value');
Voer je hier een waarde toe aan de $_SESSION array, of wijzig je hier de waarde van $_SESSION['foo']?
De naam is de key in de sessie array of de naam van de sessie in de database tabel met sessies.
En met get haal je slechts een enkele sessie (dus array item) uit de $_SESSION array die overeenkomt met de sessie naam (foo) die opgegeven wordt, tenzij je een database als sessie gebruikt dan wordt een database item opgehaald die overeen komt met 'foo'.
Oké... laten we dat database verhaal even buiten beschouwing laten.
$session = $sessionManager->get('foo');
Dit haalt dus de waarde 'foo' op uit de sessie die actief is in de session manager. Echter, ik zie in het codevoorbeeld hierboven geen 'get' functie in de session manager class.
$session->setValue('new value');
Dit begrijp ik niet. Eerst stop je een waarde in de variabele $session en vervolgens laat je daar een functie op los?
Klopt, ik heb de read functie van de SessionManager get genoemd in het voorbeeld (dat maakt het waarschijnlijk een beetje onduidelijk).
>> Dit begrijp ik niet. Eerst stop je een waarde in de variabele $session en vervolgens laat je daar een functie op los?
Nee, je geeft een Session object terug, geen sessie waarde.
Haal de sessie 'foo' op (dit geeft een sessie object terug, waarbij foo de identifier van de sessie is), stel een waarde in in het sessio object. En dan update je de sessie in de session manager. Hoe werkt die laatste functie, die update functie. Hoe zou die er in het echt uitzien? (Houdt dit dan in dat je telkens als je iets wijzigt in de sessie dat je de update functie moet uitvoeren?)
Zoiets zal het eruit zien. En ja elke keer als jij iets wijzigt in de sessie (hoe vaak komt dat nou voor?) moet je hem updaten. Je zal misschien zeggen, ik kan ook dit doen
$sessionManager->update('key', 'value');
wat in principe niet fout is. Het is alleen wel mooier om een aparte sessie (sessie is tenslotte een zelfstandig naamwoord) class te maken. Je moet zo ver gaan als je zelf wilt
