request en response
In het verleden ben ik in een framework (of in Joomla... ik weet niet meer precies waar) wel eens een request en een response object tegengekomen. Ik heb toen niet de tijd gehad om me daarin te verdiepen, maar ik vraag me af wat deze objecten precies doen, en wat voor informatie erin zit.
Iemand die dit kan verduidelijken?
Groeten Ozzie
Daar kom ik weer met Symfony, maar goed het is niet anders...
Die zitten in Symfony2 (en 1), over het algemeen in elke HTTP framework. Wat er gebeurd in de front controller is dit:
Code (php)
1
2
3
2
3
<?php
$request = Request::createFromGlobals();
?>
$request = Request::createFromGlobals();
?>
Daarmee wordt de factory aangeroepen die een Request object gaat aanmaken aan de hand van de data van de gebruiker. Hierin zitten bijv. alle parameters (post en get), sessies, cookies, headers, $_SERVER dingen, ect. Die kun je allemaal opvragen:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$request->request->get('foo'); // $_POST['foo']
$request->query->get('bar'); // $_GET['bar']
// ...
?>
$request->request->get('foo'); // $_POST['foo']
$request->query->get('bar'); // $_GET['bar']
// ...
?>
Een Request object bevat dus alle gegevens van de HTTP request en dus die van de Gebruiker
Vervolgens wordt deze in een Controller gestopt. Deze Controller heeft als doel van die Request een Response te maken. Een Response object bevat alle data die wordt teruggegeven aan de browser. Het gaat dan vaak voornamelijk om de content.
In een controller doe je bijv. dit:
Code (php)
Deze geeft een Response object terug met de content 'Hello $_POST['name']'.
Ook de Response kun je data aanpassen, bijv. de headers:
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
// voor een json request
$response = new Response(json_encode(array('name' => $name)));
$response->headers->set('Content-Type', 'application/json');
// een 200 status code
$response = new Response('Hello '.$name, 200);
?>
// voor een json request
$response = new Response(json_encode(array('name' => $name)));
$response->headers->set('Content-Type', 'application/json');
// een 200 status code
$response = new Response('Hello '.$name, 200);
?>
Ik hoop dat het wat duidelijker is? Anders moet je je vraag wat specifieker stellen...
In mijn eerdere versies, als ik dan iets uit sesie moest halen, dan gebruikte ik daar een sessie class voor, bijvoorbeeld:
$name = Session::get('name');
Maar dit zou dan eigenlijk zo moeten?
$name = $request->get('name');
In jouw voorbeeld doe je dit:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$request->request->get('foo'); // $_POST['foo']
$request->query->get('bar'); // $_GET['bar']
// ...
?>
$request->request->get('foo'); // $_POST['foo']
$request->query->get('bar'); // $_GET['bar']
// ...
?>
Waarom gebruik je voor de $_POST waarde $request->request en voor de $_GET waarde $request->query?
Quote:
Maar dat betekent dus dat je een Request class hebt, waarin je eerst al je $_POST, $_GET, $_COOKIE, $_SESSION en header waardes stopt?
Ja, al zou ik het wel lazy-loading doen: Alleen doen als je het ook echt gebruikt:
Code (php)
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
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
<?php
class Request
{
private $query;
private $request;
private $server;
private $sessions;
private $cookies;
// ...
private function setQueryParameters()
{
if (null === $this->query) {
$this->query = new ParameterBag($_POST); // ParameterBag is een Iterator klasse voor parameters (zelf maken)
}
}
private function getQueryParameters()
{
$this->setQueryParameters();
return $this->query;
}
public function __get($name)
{
switch ($name) {
case 'request':
return $this->getQueryParameters();
break;
// ...
}
}
}
$request = new Request(); // nog niks geladen
$request->request; // de POST variabelen worden geladen
$request->request->get('foo'); // de POST variabelen worden niet opnieuw geladen
?>
class Request
{
private $query;
private $request;
private $server;
private $sessions;
private $cookies;
// ...
private function setQueryParameters()
{
if (null === $this->query) {
$this->query = new ParameterBag($_POST); // ParameterBag is een Iterator klasse voor parameters (zelf maken)
}
}
private function getQueryParameters()
{
$this->setQueryParameters();
return $this->query;
}
public function __get($name)
{
switch ($name) {
case 'request':
return $this->getQueryParameters();
break;
// ...
}
}
}
$request = new Request(); // nog niks geladen
$request->request; // de POST variabelen worden geladen
$request->request->get('foo'); // de POST variabelen worden niet opnieuw geladen
?>
Quote:
In mijn eerdere versies, als ik dan iets uit sesie moest halen, dan gebruikte ik daar een sessie class voor, bijvoorbeeld:
$name = Session::get('name');
Maar dit zou dan eigenlijk zo moeten?
$name = $request->get('name');
$name = Session::get('name');
Maar dit zou dan eigenlijk zo moeten?
$name = $request->get('name');
Moeten is natuurlijk het verkeerde woord, in een HTTP framework gebeurd dat zo. En ik zou er eerder dit van maken:
Code (php)
1
2
3
2
3
<?php
$name = $request->getSession()->get('name');
?>
$name = $request->getSession()->get('name');
?>
Quote:
Waarom gebruik je voor de $_POST waarde $request->request en voor de $_GET waarde $request->query?
Je moet alle variabele gescheiden houden, dat is waarom we $_POST en $_GET gebruiken en niet $_REQUEST. Nu is een HTTP framework opgebouwd volgens de HTTP methoden. POST variabelen worden niet via de url mee verzonden, maar komen binnen via de request. Vandaar dat je die via $request->request kan krijgen.
De GET variabelen komen niet mee via de request, maar via de url. Een ander woord voor URL is query en dus kun je deze krijgen via $request->query.
Thanks very much Wouter!!!