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();
Er komt weer een nieuwe request, alleen gebeurd het intern.
Mijn laatste poging tot uitleggen:
Ik heb 2 controllers:
<?php
class PageBackendController extends Controller
{
public function editAction($id)
{
// ... heel veel form maken en form afhandeling
if ($form->isValid()) {
// ... gegevens opslaan in db
$this->forward('PageBackend:success', array('page' => $page->getName());
}
}
public function successAction($page)
{
// ...
return $this->render(...);
}
}
?>
Als ik nu het formulier invul en op submit klik wordt de edit action aangeroepen, die slaat de gegevens op en het tonen van de success message laat hij over aan de success action.
Intern wordt nu de success controller aangeroepen met de parameters, de forward functie zou er zo uitzien:
<?php
public function forward($controller, array $parameters = array())
{
// ...
return call_user_func(explode(':', $controller), $parameters);
}
?>
Het is dus eigenlijk gewoon een method call in PHP, alleen wordt er een andere controller aangeroepen en wordt er op de plaats van de 3 stippen een nieuw Request object aangemaakt.
Wouter, maar zover ik het in jouw code kan zien wordt er geen nieuwe pagina aangeroepen. Er wordt dus niet daadwerkelijk een nieuwe request uitgevoerd. Ik zie een request als zijnde een URL-aanroep. Jij ziet een interne doorverwijzing ook als een request. Verschil van interpretatie denk ik.
By the way 1) Waarom forward je naar een functie in dezelfde class, ipv gewoon $this->successAction() te doen?
By the way 2) Ik gebruik PHP 5.4.9 en merk dat het niet meer uitmaak hoe ik een class-/functienaam aanroep.
$boe = new Boe(); $boe->doeIets(); levert hetzelfde resultaat op als $boe = new bOe(); $boe->DOEietS();
Dat was vroeger toch niet zo?
Een request is in het geval waar we nu over praten het opnieuw aanmaken van een request object.
1) Waarom forward je naar een functie in dezelfde class, ipv gewoon $this->successAction() te doen?
Omdat de success action recht heeft op een eigen request. Dat is in dit geval natuurlijk zinloos, maar ik kan nu even op geen beter voorbeeld komen.
Dat was vroeger toch niet zo?
Getest met PHP5.2.7 en dan werkt het ook, maar het lijkt erop alsof het een configuratie optie is (denk ik). Ik raad het in elk geval niet aan te doen.
Oké, ik bedoel met een request dus een pagina request / aanroep. Vandaar wellicht onze verschillende visie.
"...maar ik kan nu even op geen beter voorbeeld komen."
Lekker is dat :)
"Getest met PHP5.2.7 en dan werkt het ook, maar het lijkt erop alsof het een configuratie optie is (denk ik). Ik raad het in elk geval niet aan te doen."
Hmmm, ik ben er ook geen voorstander van eerlijk gezegd, maar ik weet ook niet of (en zo ja hoe) ik dit gedrag kan uitzetten. Ik vind het maar raar. Kan me niet herinneren dat ik het eerder gezien heb... maar als het bij jou ook gebeurt?? Vreemd...
Raoul, uit jouw vraagstelling leid ik af dat jij de aparte request mooier vind.
Maar dan ben ik ook wel benieuwd waarom?
Waarom zou je een method, die in dezelfde class staat, laten aanroepen door een andere class? Wat ook nog eens vertragend werkt? Ik zie het nut er op dit moment (nog) niet van in, maar jij blijkbaar wel... dus vertel...
Dat heb je goed. Als je bezig bent met OO moet je alles vanuit een logisch oogpunt zien, $this->successAction() callen kan wel. Maar als je met requests werkt is het altijd logischer om een aparte request aan te maken en die te forwarden, want je laad als het ware een andere pagina in, en een andere pagina inladen, is dan ook weer een nieuwe request.
