Skip to content

Update http fundamentals doc to follow the english doc #777

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 2 commits into
base: master
Choose a base branch
from
Open

Update http fundamentals doc to follow the english doc #777

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
2f2eaee
Updated HTTP Fundamentals part
Nek- Sep 26, 2015
7dcc57f
Removed "Symfony2" to http_fundamentals
Nek- Sep 26, 2015
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
167 changes: 87 additions & 80 deletions book/http_fundamentals.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,12 @@
.. index::
single: Symfony2 Fundamentals
single: Symfony Fundamentals

Les fondamentaux de Symfony2 et HTTP
Les fondamentaux de Symfony et HTTP
====================================

Félicitations! Grâce à l'apprentissage de Symfony2, vous êtes sur la bonne voie pour
Félicitations! Grâce à l'apprentissage de Symfony, vous êtes sur la bonne voie pour
devenir un développeur web plus *productif* et *populaire* (en fait la popularité
ne dépend que de vous). Symfony2 est construit de manière à revenir à
ne dépend que de vous). Symfony est construit de manière à revenir à
l'essentiel : implémenter des outils qui vous aident à développer plus rapidement
et à construire des applications plus robustes, sans pour autant vous gêner dans votre
progression.
Expand All @@ -15,10 +15,10 @@ et concepts que vous êtes sur le point d'apprendre représentent les efforts de
milliers de personnes depuis de nombreuses années. En d'autres termes, vous
n'apprenez pas juste "Symfony", vous apprenez les fondamentaux du web,
les bonnes pratiques de développement, et comment utiliser de nombreuses
nouvelles bibliothèques PHP, internes ou indépendantes de Symfony2. Alors,
nouvelles bibliothèques PHP, internes ou indépendantes de Symfony. Alors,
soyez prêt !

Fidèle à la philosophie de Symfony2, ce chapitre débute par une explication du
Fidèle à la philosophie de Symfony, ce chapitre débute par une explication du
concept fondamental du développement web : HTTP. Quelles que soient vos
connaissances ou votre langage de programmation préféré, ce chapitre **doit
être lu** par tout un chacun.
Expand All @@ -41,9 +41,9 @@ le web, le but de votre serveur est *toujours* de comprendre de simples
requêtes composées de texte, et de retourner de simples réponses composées
elles aussi de texte.

Symfony2 est construit sur les bases de cette réalité. Que vous le
Symfony est construit sur les bases de cette réalité. Que vous le
réalisiez ou non, HTTP est quelque chose que vous utilisez tous les jours.
Avec Symfony2, vous allez apprendre comment le maîtriser.
Avec Symfony, vous allez apprendre comment le maîtriser.

.. index::
single: HTTP; Request-response paradigm
Expand Down Expand Up @@ -103,16 +103,17 @@ requête HTTP pour supprimer une entrée spécifique d'un blog, par exemple:

Il y a en fait neuf méthodes HTTP définies par la spécification HTTP,
mais beaucoup d'entre elles ne sont pas largement utilisées ou supportées.
En réalité, beaucoup de navigateurs modernes ne supportent pas les méthodes
``PUT`` et ``DELETE``.
En réalité, beaucoup de navigateurs modernes ne supportent que ``POST`` et
``GET`` dans les formulaires HTML. Les autres méthodes sont en revanche
supportées dans les requêtes XMLHttpRequests et par le routeur de Symfony.

En plus de la première ligne, une requête HTTP contient invariablement
d'autres lignes d'informations appelées entêtes de requête. Les entêtes
peuvent fournir un large éventail d'informations telles que l'entête ``Host``,
le format de réponse que le client accepte (``Accept``) et
l'application que le client utilise pour effectuer la requête (``User-Agent``).
Beaucoup d'autres entêtes existent et peuvent être trouvés sur la page
Wikipedia `List of HTTP header fields`_ (anglais).
Wikipedia `Liste des headers HTTP`_ (anglais).

Étape 2: Le Serveur retourne une réponse
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Expand Down Expand Up @@ -156,7 +157,7 @@ de réponse HTTP très important. Le corps d'une même ressource peut être reto
dans de multiples formats incluant HTML, XML ou JSON et l'entête ``Content-Type``
utilise les Internet Media Types, comme ``text/html``, pour dire au client quel format
doit être retourné. Une liste des médias types les plus communs peut être trouvée sur
la page Wikipedia `Liste de media type usuels`_.
la page Wikipedia `Liste des types de media usuels`_.

De nombreuses autres entêtes existent, dont quelques-uns sont très puissants.
Par exemple, certains entêtes peuvent être utilisés pour créer un puissant
Expand Down Expand Up @@ -186,12 +187,12 @@ Symfony est conçu pour correspondre à cette réalité.
pour Firefox `Live HTTP Headers`_.

.. index::
single: Symfony2 Fundamentals; Requests and responses
single: Symfony Fundamentals; Requests and responses

Requêtes et réponses en PHP
---------------------------

Alors comment interagissez-vous avec la «requête» et créez-vous la «réponse»
Alors comment interagissez-vous avec la « requête » et créez-vous la « réponse »
quand vous utilisez PHP ? En réalité, PHP vous abstrait une partie du processus
global::

Expand Down Expand Up @@ -279,7 +280,7 @@ est connecté via une connexion sécurisée (c-a-d ``https``).

La classe Request a aussi une propriété publique ``attributes`` qui contient
des données spéciales liées au fonctionnement interne de l'application. Pour
le framework Symfony2, la propriété ``attributes`` contient les valeurs retournées
le framework Symfony, la propriété ``attributes`` contient les valeurs retournées
par la route identifiée, comme ``_controller``, ``id`` (si vous utilisez le joker ``{id}``),
et même le nom de la route (``_route``). La propriété ``attributes`` existe pour
vous permettre d'y stocker des informations spécifiques liées au contexte de
Expand All @@ -295,7 +296,7 @@ au client::
$response = new Response();

$response->setContent('<html><body><h1>Hello world!</h1></body></html>');
$response->setStatusCode(200);
$response->setStatusCode(Response::HTTP_OK);
$response->headers->set('Content-Type', 'text/html');

// affiche les entêtes HTTP suivies du contenu
Expand Down Expand Up @@ -373,7 +374,7 @@ que d'avoir des URLs individuelles exécutant des fichiers PHP différents,
le contrôleur frontal est *toujours* exécuté, et le routage (« routing ») des
différentes URLs vers différentes parties de votre application est effectué
en interne. Cela résoud les deux problèmes de l'approche originale.
Presque toutes les applications web modernes font ça - incluant les
Presque toutes les applications web modernes font ça – incluant les
applications comme WordPress.

Rester Organisé
Expand All @@ -387,15 +388,16 @@ parties de votre code selon cette valeur. Cela peut rapidement devenir moche::
// index.php
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

$request = Request::createFromGlobals();
$path = $request->getPathInfo(); // Le chemin de l'URI demandée

if (in_array($path, array('', '/'))) {
$response = new Response('Bienvenue sur le site.');
} elseif ($path == '/contact') {
} elseif ('/contact' === $path) {
$response = new Response('Contactez nous');
} else {
$response = new Response('Page non trouvée.', 404);
$response = new Response('Page non trouvée.', Response::HTTP_NOT_FOUND);
}
$response->send();

Expand All @@ -412,7 +414,7 @@ Symfony suit un schéma simple et identique pour toutes les requêtes :

.. figure:: /images/request-flow.png
:align: center
:alt: Le déroulement d'une requête Symfony2
:alt: Le déroulement d'une requête Symfony

Les requêtes entrantes sont interprétées par le routing et passées aux
fonctions des contrôleurs qui retournent des objets ``Response``.
Expand All @@ -425,7 +427,7 @@ des outils mis à disposition par le framework. En d'autres termes, le contrôle
est le lieu où *votre* code se trouve : c'est là que vous interprétez la requête et
que vous créez une réponse.

C'est si facile ! Revoyons cela :
C'est aussi simple que cela ! Revoyons cela :

* Chaque requête exécute un même et unique fichier ayant le rôle de contrôleur frontal;

Expand All @@ -451,13 +453,21 @@ fichier de configuration du routing:
# app/config/routing.yml
contact:
path: /contact
defaults: { _controller: AcmeDemoBundle:Main:contact }
defaults: { _controller: AppBundle:Main:contact }

.. code-block:: xml

<route id="contact" path="/contact">
<default key="_controller">AcmeBlogBundle:Main:contact</default>
</route>
<!-- app/config/routing.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<routes xmlns="http://symfony.com/schema/routing"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://symfony.com/schema/routing
http://symfony.com/schema/routing/routing-1.0.xsd">

<route id="contact" path="/contact">
<default key="_controller">AppBundle:Main:contact</default>
</route>
</routes>

.. code-block:: php

Expand All @@ -467,25 +477,20 @@ fichier de configuration du routing:

$collection = new RouteCollection();
$collection->add('contact', new Route('/contact', array(
'_controller' => 'AcmeBlogBundle:Main:contact',
'_controller' => 'AppBundle:Main:contact',
)));

return $collection;

.. note::

Cet exemple utilise :doc:`YAML </components/yaml/yaml_format>` pour définir la configuration de
routage. Cette dernière peut aussi être écrite dans d'autres formats comme XML ou
PHP.

Lorsque quelqu'un visite la page ``/contact``, il y a correspondance avec cette route,
et le contrôleur spécifié est exécuté. Comme vous l'apprendrez dans le
:doc:`chapitre sur le routage</book/routing>`, la chaîne de caractères ``AcmeDemoBundle:Main:contact``
:doc:`chapitre sur le routage</book/routing>`, la chaîne de caractères ``AppBundle:Main:contact``
est une syntaxe raccourcie qui pointe vers une méthode PHP spécifique ``contactAction`` dans la
classe appelée ``MainController``::

// src/Acme/DemoBundle/Controller/MainController.php
namespace Acme\DemoBundle\Controller;
// src/AppBundle/Controller/MainController.php
namespace AppBundle\Controller;

use Symfony\Component\HttpFoundation\Response;

Expand All @@ -498,14 +503,15 @@ classe appelée ``MainController``::
}

Dans cet exemple très simple, le contrôleur crée simplement un objet
:class:`Symfony\\Component\\HttpFoundation\\Response` contenant l'HTML
"<h1>Contactez nous!</h1>". Dans le :doc:`chapitre Contrôleur</book/controller>`, vous allez
:class:`Symfony\\Component\\HttpFoundation\\Response` contenant le HTML
``<h1>Contactez nous!</h1>``. Dans le :doc:`chapitre Contrôleur</book/controller>`, vous allez
apprendre comment un contrôleur peut retourner des templates, permettant à votre code de
« présentation » (c-a-d du code qui retourne du HTML) de se trouver dans un fichier de template
séparé. Cela libère le contrôleur et lui permet de s'occuper seulement des choses complexes :
interagir avec la base de données, gérer les données soumises, ou envoyer des emails.

Symfony2: Construisez votre application, pas vos outils

Symfony: Construisez votre application, pas vos outils
-------------------------------------------------------

Vous savez maintenant que le but de toute application est d'interpréter
Expand All @@ -518,89 +524,90 @@ des emails, valider des entrées d'utilisateurs et gérer la sécurité.

La bonne nouvelle est qu'aucun de ces problèmes n'est unique. Symfony fournit
un framework rempli d'outils qui vous permettent de construire votre
application, mais pas vos outils. Avec Symfony2, rien ne vous est imposé :
application, mais pas vos outils. Avec Symfony, rien ne vous est imposé :
vous êtes libre d'utiliser le framework Symfony en entier, ou juste une partie
de Symfony indépendamment.

.. index::
single: Symfony2 Components
single: Symfony Components


Outils Autonomes: Les *Composants* Symfony2
Outils Autonomes: Les *Composants* Symfony
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Donc *qu'est-ce* que Symfony2? Premièrement, Symfony2 est une collection de plus
Donc *qu'est-ce* que Symfony ? Premièrement, Symfony est une collection de plus
de vingt bibliothèques indépendantes qui peuvent être utilisées dans *n'importe quel*
projet PHP. Ces bibliothèques, appelées les *Composants Symfony2*, contiennent
projet PHP. Ces bibliothèques, appelées les *Composants Symfony*, contiennent
des choses utiles en toute situation, quelle que soit
la manière dont votre projet est développé. Pour en nommer quelques-unes :


* :doc:`HttpFoundation</components/http_foundation/introduction>` - Contient les classes
``Request`` et ``Response``, ainsi que d'autres classes pour la gestion des sessions
et des uploads de fichiers;

* :doc:`Routing</components/routing/introduction>` - Un puissant et rapide système qui vous
permet de lier une URI spécifique (par exemple: ``/contact``) à l'information
lui permettant de savoir comment gérer cette requête (par exemple: exécute la méthode
``contactAction()``);
:doc:`HttpFoundation</components/http_foundation/introduction>`
Contient les classes ``Request`` et ``Response``, ainsi que
d'autres classes pour la gestion des sessions et des uploads
de fichiers.

* `Form`_ - Un framework complet et flexible pour la création de formulaires
et la gestion de la soumission de ces derniers;
:doc:`Routing</components/routing/introduction>`
Un puissant et rapide système qui vous permet de lier une URI
spécifique (par exemple: ``/contact``) à l'information lui permettant
de savoir comment gérer cette requête (par exemple: exécute la
méthode ``contactAction()``).

* `Validator`_ Un système permettant de créer des règles à propos de données
et de valider ou non les données utilisateurs soumises suivant ces règles;
:doc:`Form </components/form/introduction>`
Un framework complet et flexible pour la création de formulaires et
la gestion de la soumission de ces derniers.

* :doc:`ClassLoader</components/class_loader>` Une bibliothèque pour le chargement
automatique (« autoloading ») qui permet aux classes PHP d'être utilisées sans avoir
besoin d'``inclure`` (« require ») manuellement les fichiers contenant ces dernières;
`Validator`_
Un système permettant de créer des règles à propos de données et de
valider ou non les données utilisateurs soumises suivant ces règles.

* :doc:`Templating</components/templating>` Une boîte à outils pour afficher des
templates, gérer leur héritage (c-a-d qu'un template est décoré par un layout)
et effectuer d'autres tâches communes aux templates;
:doc:`Templating</components/templating>`
Une boîte à outils pour afficher des templates, gérer leur héritage
(c-a-d qu'un template est décoré par un layout) et effectuer
d'autres tâches communes aux templates.

* `Security`_ - Une puissante bibliothèque pour gérer tous les types de
sécurité dans une application;
:doc:`Security </components/security/introduction>`
Une puissante bibliothèque pour gérer tous les types de sécurité
dans une application.

* `Translation`_ Un framework pour traduire les chaînes de caractères dans
votre application.
:doc:`Translation </components/translation/introduction>`
Un framework pour traduire les chaînes de caractères dans votre
application.

Chacun de ces composants est découplé et peut être utilisé dans *n'importe quel*
projet PHP, que vous utilisiez le framework Symfony2 ou non.
projet PHP, que vous utilisiez le framework Symfony ou pas.
Chaque partie est faite pour être utilisée en cas de besoin et remplacée quand cela
est nécessaire.

La Solution Complète: Le *Framework* Symfony2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
La Solution Complète: Le *Framework* Symfony
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Donc finalement, *qu'est-ce* que le *Framework* Symfony2 ? Le *Framework Symfony2*
Donc finalement, *qu'est-ce* que le *Framework* Symfony ? Le *Framework Symfony*
est une bibliothèque PHP qui accomplit deux tâches distinctes :

#. Fournir une sélection de composants (les Composants Symfony2) et
#. Fournir une sélection de composants (les Composants Symfony) et
des bibliothèques tierces (ex `Swiftmailer`_ pour envoyer des emails);

#. Fournir une configuration et une bibliothèque « colle » qui lie toutes ces
pièces ensembles.

Le but du framework est d'intégrer plein d'outils indépendants afin de
fournir une expérience substantielle au développeur. Même le framework lui-même
est un bundle Symfony2 (c-a-d un plugin) qui peut être configuré ou remplacé
est un bundle Symfony (c-a-d un plugin) qui peut être configuré ou remplacé
entièrement.

Symfony2 fournit un puissant ensemble d'outils pour développer rapidement des
Symfony fournit un puissant ensemble d'outils pour développer rapidement des
applications web sans pour autant s'imposer à votre application. Les utilisateurs
normaux peuvent commencer rapidement à développer en utilisant une distribution
Symfony2, ce qui fournit un squelette de projet avec des paramètres par défaut.
Symfony, ce qui fournit un squelette de projet avec des paramètres par défaut.
Pour les utilisateurs avancés, le ciel est la seule limite.

.. _`xkcd`: http://xkcd.com/
.. _`HTTP 1.1 RFC`: http://www.w3.org/Protocols/rfc2616/rfc2616.html
.. _`HTTP Bis`: http://datatracker.ietf.org/wg/httpbis/
.. _`Live HTTP Headers`: https://addons.mozilla.org/fr/firefox/addon/live-http-headers/
.. _`Live HTTP Headers`: https://addons.mozilla.org/en-US/firefox/addon/live-http-headers/
.. _`Liste des codes HTTP`: http://fr.wikipedia.org/wiki/Liste_des_codes_HTTP
.. _`List of HTTP header fields`: http://en.wikipedia.org/wiki/List_of_HTTP_header_fields
.. _`Liste de media type usuels`: http://fr.wikipedia.org/wiki/Type_MIME#Liste_de_media_type_usuels
.. _`Form`: https://github.com/symfony/Form
.. _`Validator`: https://github.com/symfony/Validator
.. _`Security`: https://github.com/symfony/Security
.. _`Translation`: https://github.com/symfony/Translation
.. _`Swiftmailer`: http://swiftmailer.org/
.. _`Liste des headers HTTP`: https://en.wikipedia.org/wiki/List_of_HTTP_header_fields
.. _`Liste des types de media usuels`: https://www.iana.org/assignments/media-types/media-types.xhtml
.. _`Validator`: https://github.com/symfony/validator
.. _`Swift Mailer`: http://swiftmailer.org/