Nous avons vu que nous pouvons nous contenter de routes et de vues pour créer un site. C'est parfait tant qu'on doit faire des choses simples mais avec une application un peu lourde on peut se retrouver avec beaucoup de code dans le fichier des routes, ce qui n'est pas très judicieux. Une autre option consiste à créer des contrôleurs (schéma MVC). Cette solution permet aussi l'injection automatique de dépendances comme nous le verrons plus tard.
Créer un contrôleur
Si vous regardez dans le dossier app/controllers vous trouvez le fichier HomeController.php :
class HomeController extends BaseController { /* |-------------------------------------------------------------------------- | Default Home Controller |-------------------------------------------------------------------------- | | You may wish to use controllers instead of, or in addition to, Closure | based routes. That's great! Here is an example controller method to | get you started. To route to this controller, just add the route: | | Route::get('/', 'HomeController@showWelcome'); | */ public function showWelcome() { return View::make('hello'); } }
On vous explique que c'est un exemple pour réaliser vos propres contrôleurs. La syntaxe est simple : on crée une classe qui hérite de BaseController. Notez que le nom de la classe, conformément au PSR-1 adopte le principe du StudlyCaps, c'est à dire que chaque mot commence par une majuscule, y compris le premier (contrairement au camelCase). Le fichier de cette classe se trouve dans le même dossier app/controllers/BaseController.php :
class BaseController extends Controller { /** * Setup the layout used by the controller. * * @return void */ protected function setupLayout() { if ( ! is_null($this->layout)) { $this->layout = View::make($this->layout); } } }
Cette classe hérite de la classe Controller qui est la classe générique de Laravel pour les contrôleurs. Vous pouvez donc placer ici du code qui concerne tous vos contrôleurs. Il y a d'ailleurs déjà une méthode pour générer un template. Nous allons pour le moment laisser de côté la classe BaseController et voir comment on active un contrôleur avec une route. Puisqu'on a déjà un contrôleur on va l'utiliser. En plus on nous explique gentiment dans le commentaire comment on doit faire . Entrez donc ce code dans le fichier des routes :
Route::get('/', 'HomeController@showWelcome');
Si vous n'avez pas supprimé le fichier app/views/hello.php vous devez obtenir cet affichage :
Si vous l'avez supprimé il suffit de le recréer avec ce code :
<h1>Hello World!</h1>
Avec ce que nous avons vu jusqu’à présent l'utilisation de contrôleur n'apporte pas grand chose si ce n'est d'organiser le code différemment. Au lieu de le mettre directement dans la route on le déporte dans le contrôleur. Tout cela prendra son sens avec des fonctionnalités plus avancées que nous verrons ultérieurement.
Un contrôleur "RESTful"
Vous pouvez avec Laravel créer un contrôleur qui réponde aux conventions de nommage de la norme REST. Voyons un exemple simple de contrôleur :
class GuestController extends BaseController { /** * Affiche le formulaire de login * * @return View */ public function getLogin() { // ... } /** * Traitement du formulaire de login * * @return Redirect */ public function postLogin() { // ... } }
On a deux actions login, une avec la méthode GET et l'autre la méthode POST. Au niveau des routes on se contente de cette ligne de code :
Route::controller('guest', 'GuestController');
Avec l'URL http://localhost/blog/public/guest/login on active l'action login qui correspond à la méthode getLogin. Avec la même URL mais la méthode POST on active l'action login qui correspond à la méthode postLogin. Il suffit donc de bien préfixer les action avec get et post. Je montrerai un exemple complet d'application dans un article ultérieur.
Créer un contrôleur de ressource avec artisan
Laravel possède un outil en ligne nommé artisan. Il permet de faire bien des choses. Pour vous en rendre compte entrez php artisan en ligne de commande :
Vous pouvez voir qu'il y a pas mal de commandes disponibles. Nous allons nous intéresser pour le moment à la commande controller:make qui sert justement à créer un contrôleur. Voyons les options de cette commande :
Nous allons commencer par une création simple :On nous dit que le contrôleur a été créé, nous le trouvons effectivement dans app/controllers/mon_controleur.php :
<?php class mon_controleur extends BaseController { /** * Display a listing of the resource. * * @return Response */ public function index() { // } /** * Show the form for creating a new resource. * * @return Response */ public function create() { // } /** * Store a newly created resource in storage. * * @return Response */ public function store() { // } /** * Display the specified resource. * * @return Response */ public function show($id) { // } /** * Show the form for editing the specified resource. * * @return Response */ public function edit($id) { // } /** * Update the specified resource in storage. * * @return Response */ public function update($id) { // } /** * Remove the specified resource from storage. * * @return Response */ public function destroy($id) { // } }
Laravel se conforme à l'architecture RESTful ce qui explique la présence de toutes ces méthodes. Pour clarifier un peu tout ça voilà le code modifié avec un retour évocateur :
<?php class mon_controleur extends BaseController { public function index() { return "Réponse de base"; } // GET /ma_ressource/create public function create() { return "La ressource doit être créée ici"; } // POST /ma_ressource public function store() { return "Ressource mémorisée"; } // GET /ma_ressource/{id} public function show($id) { return "C'est ici qu'on montre la ressource ".$id; } // GET /ma_ressource/{id}/edit public function edit($id) { return "C'est ici qu'on modifie la ressource ".$id; } // PUT /ma_ressource/{id} public function update($id) { return "C'est ici qu'on met à jour la ressource ".$id; } // DELETE /ma_ressource/{id} public function destroy($id) { return "C'est ici qu'on supprime la ressource ".$id; } }On va aussi déclarer la ressource dans le fichier des routes, ce qui va avoir pour effet de créer toutes les routes correspondant à cette ressource avec une seule ligne de code :
Route::resource('ma_ressource', 'mon_controleur');
En réponse à http://localhost/laravel/public/ma_ressource j'obtiens donc :
Réponse de base En réponse à http://localhost/laravel/public/ma_ressource/toto j'obtiens donc : C'est ici qu'on montre la ressource toto En réponse à http://localhost/laravel/public/ma_ressource/toto/edit j'obtiens donc : C'est ici qu'on modifie la ressource totoPour les autres commandes il faut un peu plus d'intendance puisqu'on a les verbes POST, PUT et DELETE.
Par exemple pour l'enregistrement d'une ressource créez ce formulaire :
<form action="ma_ressource" method="post"> <input name="Valider" type="submit"> </form>
Quand vous cliquez sur le bouton vous devez obtenir :
Ressource mémorisée
Pour ce qui concerne les méthode PUT et DELETE la mise en œuvre est un peu plus délicate.
Si vous ne voulez pas toutes les fonctionnalités vous pouvez créer un contrôleur limité à vos besoins. La commande d'artisan comprend les options --only et --except. Mais il faut aussi le signaler dans l'appel de la ressource. Par exemple si vous ne voulez que show et edit :
Route::resource('ma_ressource', 'mon_controleur', array('only' => array('show', 'edit')));
Vous avez donc la possibilité d'utiliser ce type de contrôleur dans vos applications si vous voulez coller à l'architecture REST ou tout simplement partir sur une base cohérente.
Je donne un exemple complet d'une ressource avec un générateur dans un article ultérieur.
Par bestmomo
Nombre de commentaires : 10