Compte rendu Symphony.docx

Compte rendu Symphony
1/17
Présentation
Définition d’un framework
Objectif
Symfony 2
Installation
Architecture
Architecture des fichiers :
Architecture conceptuelle :
BD
Concept des Bundle
Structure des bundles
Création de Bundle
Création d’une page avec Symfony2
Création de route
Création d’un contrôleur :
Création du Template :
Formulaire
Doctrine2
Exemples
2/17
Présentation
Définition d’un framework
Framework signifie en français cadre de travail, c’est un environnement qui met à disposition des
outils pour faciliter le travail, pour le développeur il fournit des librairies, des bases de données, des
codes préconçus par d’autres développeur
Objectif
L’objectif principal est d’améliorer la productivité des développeurs. Le Framework permet
de gagner du temps, il s’occupe de la forme, et les développeur se focalise sur le fond.
Symfony 2
Symfony est un framework php, sa première version est sortie en 2005. La deuxième version est
sortie en 2011. Cette deuxième version est plus rapide et plus souple que la première. Ce framework
Open source est développé par toute une communauté international.
Pour
Contre
- le code
le framework incite à organiser correctement le
code, il fournit des composants, du code pré-écrit
- le travail: utilisation de l’architecture MVC,
utilisation de convention de code
- la communauté: elle fournit des tutoriaux et des
mises à jour du framework.
- Difficulté d’apprentissage (Temps
d’apprentissage long)
-Etre au courant des nouveautés,
connaître le modèle MVC
Installation
Sous Ubuntu :
- Télécharger le fichier Symfony Standard 2.3.6(.tgz) sur http://symfony.com/download
- Décompresser le fichier là où on le souhaite
- renommer le fichier en un nom de projet (ex: recette ou blog)
- modifier les droits de app/cache et app/logs:
sudo setfacl -R -m u:www-data:rwx -m u:user:rwx app/cache app/logs
sudo setfacl -dR -m u:www-data:rwx -m u:user:rwx app/cache app/logs
- il faut créer un virtualHost pour pouvoir accéder au fichier dans un fichier
sudo vi /etc/apache2/sistes-available/<nom du projet>.conf
<VirtualHost *:80>
DocumentRoot "/home/pascal/dev/recette/web/"
ServerName recette.local
DirectoryIndex index.php
3/17
<Directory "/home/pascal/dev/recette/web/">
AllowOverride All
Allow from All
</Directory>
</VirtualHost>
Ensuite pour ajouter le site et qu’il soit pris en compte par apache, il faut taper 2commandes:
- sudo a2ensite recette.conf
- sudo service apache2 reload
- ajouter la ligne suivante au fichier /etc/hosts: 127.0.0.1
<nom du projet>.local
Il est aussi possible d’utiliser Symfony2 dans NetsBeans. Pour cela
-
aller dans Outils->Option->php->Symfony2
Spécifier la localisation du fichier Symfony Standard 2.3.6 .zip
créer un nouveau projet en choissisant le framework Symfony2
Architecture
Architecture des fichiers :
Architecture divisée en plusieurs répertoires:
-
app: de dossier contient les fichiers de configurations, les caches, les fichiers des logs,
les paramétrages...
- src: les codes sources sont contenus dans ce dossier. Le code sera organisé en “bundles”( en
pack). celui-ci contient quelques fichiers d’exemples, fournis par Symfony2 qui pourront être
supprimés.
- vendor: Ce sont les librairies externes à l’application. On y trouveraDoctrine, Twig,
SwiftMailer (pour envoyer des emails)…
Librairie: Chaque librairie remplit une fonction bien précise, et dont on peut se servir dans notre
code. On ne sait pas comment elle fonctionne, mais on sait comment s'en servir. On pourra donc ce
servir très facilement de certaine chose(envoi de mail) simplement en apprenant à utiliser sa
librairie(SwiftMailer).
-
web: Ce sont les fichiers destinés aux visiteurs (images, fichiers css, javascript…) Il contient
également le contrôleur frontal app.php ou app-dev.php (l’équivalent d’index.php). C’est le
seul répertoire accessible aux visiteurs, les autres répertoires ne sont pas censés être
accessibles
. Les fichiers .htaccess interdisant l'accès aux autres dossiers.
Le controleur frontal
C’est le point d’entrée de l’application, toutes les pages y passent. le contrôleur frontal de
symphony2 se situe dans le répertoire web/ (app.php et app-dev.php)
4/17
app.php: controleur pour les visiteurs du site, on affiche pas les erreurs mais renvoie à la page
précédente
app-dev.php: controleur pour le développeur, aide pour le débogage
Ce sont deux environnements de travail.
5/17
Architecture conceptuelle :
Analyse du schéma :
Le visiteur demande la page /blog
Le contrôleur frontal reçoit la requête, charge le Kernel et la lui transmet
Le Kernel demande au Routeur quel contrôleur exécuter pour l'URL /blog. Ce Routeur est
un composant Symfony2 qui fait la correspondance entre URL. Le Routeur indique qu’il fut
exécuté le contrôleur SdzBlog
- Le Kernel exécute le contrôleur, qui demande au modèle article la liste des articles, et la
renvoie à la vue ListeArticle. La vue retourne a page HTML.
Les couleurs du schéma distinguent les points où il faut intervenir : Il faudra coder ce qui est en
vert, le reste est à configurer, on ne touche pas au controleur frontal.
-
6/17
BD
Concept des Bundle
Les bundle sont des sortes de brique, tous ce qui concerne une même fonctionnalité est regroupée
dans un bundle, mais les différents bundle doivent pouvoir coopérer. Un bundle peut être réutilisé
dans plusieurs projets.
Des bundles sont déjà fourni par la communauté sur http://knpbundle.com/
Structure des bundles
Un bundle est structuré en dossier, la structure conventionnelle est la suivante, mais elle peut être
modifiée:
Controller/
| Contient les contrôleurs.
DependencyInjection/ | Contient des informations sur le bundle (chargement automatique de
la configuration par exemple).
Entity/
| Contient les modèles.
Form/
| Contient les éventuels formulaires.
Resources/
-- config/
| Contient les fichiers de configuration du bundle
-- public/
| Contient les fichiers publics de votre bundle : fichiers CSS et JavaScript,
images, etc.
-- views/
| Contient les vues de notre bundle, les templates Twig.
Tests/
| Contient les éventuels tests unitaires et fonctionnels.
7/17
Création de Bundle
Il faut commencer par l’exécution de la commande php app/console generate:bundle
1. Choisir le namespace: la console propose de rentrer un namespace.
sdz correspond au namespace racine, le nom du bundle doit finir par “Bundle” par
convention
2. Choisir le nom: la console propose de rentrer un nom, même chose que le namespace sans le
« \ » le nom donné ar défaut est SdzBlogBundle, qui est à retenir
3. Choisir la destination
4. Choisir le format de configuration
YAML est bien adapté pour un Bundle
5. Choisir si Symfony se charge de générer toute la structure
6. Confirmez
8/17
On peut aussi générer un Bundle à partir de NetBeans : Clic Droit sur le projet Symfony2->Symfony2>Run Command->generate-bundle suivi des paramètre namespace ,dir, bundle-name, format,
structure
Supprimer le Bundle Demo
Supprimer le dossier acme,
supprimer la ligne
$bundles[] = new Acme\DemoBundle\AcmeDemoBundle(); dans le fichier app/AppKernel
suppirmer la ligne:
# AcmeDemoBundle routes (to be removed)
_acme_demo:
resource: "@AcmeDemoBundle/Resources/config/routing.yml"
Dans routing_dev.yml
Création d’une page avec Symfony2
Se situer dans le répertoire source du Bundle
Création de route
Afin de créer une page, il faut créer un fichier de routes, l’objectif d’une route(ou router) est
d’indiquer à Symfony 2 ce qu’il doit se passer quand un URL est appelé.
Un fichier de routes existe déjà dans Resources/config, il faut le compléter pour l’adapter à notre
page.
( ! L’indentation ne se fait pas avec tabulation mais avec 4 espaces.)
Il est possible de contrôler les paramètres d’une route, il faut ajouter la mention : requirements, les
paramètres qui ne rentre pas dans ces critères ne seront pas interprété et la page ne sera pas
trouvée :
Il est possible de mettre un préfixe pour toutes nos URL dans le fichier app/config/routing.yml
9/17
Création d’un contrôleur :
Il faut ensuite créer un contrôleur. Le nom des fichiers des contrôleurs doit respecter une
convention : commencer par le nom du bundle (Blog ici) et être suivi du suffixe « Controller ». Un
contrôleur est créer par défaut mais on peut en créer un autre.
Contenu d’un contrôleur :
Il est possible de générer les URL : dans la fonction indexAction du controleur, on utilise la fonction
generateUrl avec le nom de la route et les paramètres à utiliser si il y en a.
ex :
$url = $this->generateUrl(‘sdzblog_voir’,array(‘id’=>$id)) ;
Dans le controleur il est possible d’utiliser des « services » on les appelle par la fonction get(). ex :
$this->get(‘mailer’) permet l’envoi d’e-mail. Pour les e-mail i faut alors modifier les paramètre dans le
fichier app/config/parameters
Création du Template :
Moteur de template : script qui permet d’utiliser des fichiers qui ont pour but d’afficher le contenu
d’une page html sans php. Le répertoire des templates est Ressources/views.
Dans views : le nom du répertoire sera le même que celui du contrôleur et le nom du fichier
correspondra à une action du contrôleur.
src/Sdz/BlogBundle/Resources/views/Blog/index.html.twig
10/17
Appelle de la vue dans le contrôleur :
On peut rajouter d’autre paramètre dans la fonction render et modeifier la vue en conséquence :
exemple
<h1>Hello {{ nom }} !</h1> dans la vue
return $this->render(‘SdzBlogBundle :Blog :index.html.twing’, array
(‘nom’=>’test’) ) ; dans le contrôleur
On peut aussi générer l’Url à partir de la vue avec la fonction {{ path }}
ex :
<a href="{{ path('sdzblog_voir', { 'id': article_id }) }}">Lien vers l'article d'id {{ article_id }}</a>
Avec Symfony il faut penser à vider le cache régulièrement car des erreurs qui ne sont pas de notre
ressors peuvent apparaître après une modification pour cela il faut utiliser la commande : php
app/console cache :clear (pour la partie dev) , php app/console cache :clear --env=prod (pour la
partie prod)
11/17
Formulaire
Utilisation d’un composant « Form » fournit avec Symfony2 : les formulaires ont besoin d’objet pour
être construit. Il permettent de remplir les attributs de l’objet avec des valeurs entrées par le
visiteur.
On utilise alors un formBuilder(constructeur de formulaire). Tout d’abord on définit l’objet concerné
par le formulaire, puis on définit les attributs qui seront "remplis"
// On crée le FormBuilder grâce à la méthode du contrôleur
$formBuilder = $this->createFormBuilder($article);
// On ajoute les champs de l'entité que l'on veut à notre
formulaire
$formBuilder
->add('date',
'date')
->add('titre',
'text')
->add('contenu',
'textarea')
->add('auteur',
'text')
->add('publication', 'checkbox');
On génère ensuite le formulaire, puis on le transmet à la vue, il est alors visible mais pas
opérationnel.
// À partir du formBuilder, on génère le formulaire
$form = $formBuilder->getForm();
// On passe la méthode createView() du formulaire à la vue afin
qu'elle puisse afficher le formulaire toute seule
return $this->render('SdzBlogBundle:Blog:ajouter.html.twig',
array(
'form' => $form->createView(),));
Dans la vue il faut ajouter de quoi remplir le formulaire :
<form method="post" {{ form_enctype(form) }}>
{{ form_widget(form) }}
<input type="submit" class="btn btn-primary" />
</form>
Les type de champs de formulaire doivent correpondre au types des attributs pour permettre une
bonne insertion dans la base de données.
Pour créer des formulaires on peut aussi utiliser la console pour générer des CRUD.
12/17
Doctrine2
Doctrine 2 est aussi un Framework, il permet de faire le lien entre la base de données et le code sans
utiliser de classe modèle et en minimisant les requête SQL. On utilise des annotations sur les classes
pour définir qu’elles seront les colonnes des tables, le lien entre les table… Les classes deviendront
des tabes. Doctrine emploi le terme d’entité pour définir une table.
Les annotations commence par /** et finissent par */
Annotations à connaître :
/** @Entity */ : à placer avant de définir une classe. Permet d’indiquer que cette table sera une
entité et donc pourra générer une table dans le SGBD
/**
* @Id @Column(type="integer", name="id_adr")
* @GeneratedValue
*
*/ : Il faut créer un attribut dans la classe qui sera la clé primaire de la table
/**
* @Column (type="string", length=200, name="rue_Adr")
*/ : Indique que cet attribut est un champ de la table, à utiliser pour chaque attribut
Il faut aussi représenter les associations qu’il y a entre les classes :
/**
*@OneToOne(targetEntity= "Adresse")
*/ : se place avant l’attribut concerné. Cette annotation traduit une association 1..1 Si l’on rend
l’exemple d’un client qui habite une certaine Adresse. Adresse et Client étant deux objets. Adresse
est un attribut de client. L’annotation sera placer avant l’attribut Adresse dans la classe Client et
l’entité cible sera Adresse.
/**
* ManyToOne(targetEntity=" Article")
*/ : La relation Many-To-One d’associer plusieurs entité à une seule. Si l’on prend l’exemple des
commentaires dans un blog, plusieurs commentaires correspondront à un seul article. Cela se traduit
par cette annotation, située dans la classe Commentaire au-dessus de l’attribut article.
/**
*ManyToMany(targetEntity=" Categorie", cascade={"persist"})
*/ : Many-To-Many traduit une association n..n si l’on prend l’exemple des articles et des catégories
dans un blog, un article peut correspondre à plusieurs catégories et une catégorie peut posséder
plusieurs articles. On met alors cette annotation au-dessus de l’attribut correspondant dans l’une des
deux classes.
Après avoir annoté toutes les classes qui sont maintenant considérées somme des entités par
Doctrine on peut générer la base de données. Il faut d’abord indiquer les paramètres d’accès à la
base de données dans le fichier.
13/17
On peut générer automatiquement des entités avec la commande php app/console
gen:doctrine:entity
Exemples
Création d’un projet Symfony : recette,
Après avoir suivi toute les étapes d’installation de Symfony, configuration pour prise en compte de la
base de données :
14/17
Génération du Bundle recette :
btssio@btssio-VirtualBox:~/NetBeansProjects/recette$ app/console generate:bundle
Welcome to the Symfony2 bundle generator
Your application code must be written in bundles. This command helps
you generate them easily.
Each bundle is hosted under a namespace (like Acme/Bundle/BlogBundle).
The namespace should begin with a "vendor" name like your company name, your
project name, or your client name, followed by one or more optional category
sub-namespaces, and it should end with the bundle name itself
(which must have Bundle as a suffix).
See http://symfony.com/doc/current/cookbook/bundles/best_practices.html#index-1 for more
details on bundle naming conventions.
Use / instead of \
for the namespace delimiter to avoid any problem.
Bundle namespace: Sdz/recetteBundle
In your code, a bundle is often referenced by its name. It can be the
concatenation of all namespace parts but it's really up to you to come
up with a unique name (a good practice is to start with the vendor name).
Based on the namespace, we suggest SdzrecetteBundle.
Bundle name [SdzrecetteBundle]:
The bundle can be generated anywhere. The suggested default directory uses
the standard conventions.
Target directory [/home/btssio/NetBeansProjects/recette/src]:
Determine the format to use for the generated configuration.
Configuration format (yml, xml, php, or annotation): yml
To help you get started faster, the command can generate some
code snippets for you.
Do you want to generate the whole directory structure [no]? yes
Summary before generation
You are going to generate a "Sdz\recetteBundle\SdzrecetteBundle" bundle
in "/home/btssio/NetBeansProjects/recette/src/" using the "yml" format.
Do you confirm generation [yes]? yes
Bundle generation
Generating the bundle code: OK
Checking that the bundle is autoloaded: OK
Confirm automatic update of your Kernel [yes]?
Enabling the bundle inside the Kernel: OK
Confirm automatic update of the Routing [yes]?
Importing the bundle routing resource: OK
You can now start using the generated code!
Suppression du Bundle AcmeDemoBundle et de tous ce qui le concerne
Création d’une base de données recette
15/17
Génération de deux entités avec Doctrine : gen :doctrine :entity, Recette et Ingredient
Génération de la base de données avec les annotations
Génération d’un formulaire pour chaque entité avec la commande app/console
generate :doctrine :crud
Les formulaires sont maintenant créés on peut entrer des informations dans la base de données.
16/17
Il faut ensuite mettre en forme les formulaires pour les rendre plus esthétiques
17/17