🐘 Laravel – Framework PHP (Artisan, Eloquent & Blade)

Prérequis (Stack AMP)

Vous avez besoin d'une stack PHP complète (ex: WAMP, XAMPP, MAMP) ou d'une installation manuelle (Nginx/Apache + PHP + MariaDB) et de Composer (le "npm" de PHP).

# (Vérifier les prérequis)
php -v       # (PHP 8.1+ requis)
composer -v  # (Gestionnaire de paquets PHP)

1. composer create-project

# Crée un dossier 'mon_projet' avec Laravel
composer create-project laravel/laravel mon_projet

2. (Alternative) Installeur Laravel

# 1. Installer l'installeur (1 fois)
composer global require laravel/installer

# 2. Créer un projet (plus rapide)
laravel new mon_projet

3. Lancer le serveur de dev (artisan)

cd mon_projet
# Lancer le serveur (similaire à 'runserver' Django)
php artisan serve
# Serveur démarré sur http://127.0.0.1:8000

Laravel Sail (Docker)

Sail est l'environnement de développement Docker officiel de Laravel. C'est la méthode la plus simple pour démarrer, car elle gère PHP, Nginx, MariaDB, Redis... pour vous.

Prérequis : Docker Desktop (Windows/macOS) ou Docker (Linux).

1. Installation (Linux/macOS)

# 1. Télécharge l'installeur (script bash)
curl -s "https://laravel.build/mon-projet-sail" | bash

# 2. Entrer dans le dossier
cd mon-projet-sail

# 3. Lancer les conteneurs (Nginx, PHP, MariaDB, Redis...)
./vendor/bin/sail up -d

2. Utiliser sail

sail est un alias pour docker compose exec ....

# Créer un alias (optionnel)
alias sail='./vendor/bin/sail'

# Exécuter 'php artisan migrate' (DANS le conteneur)
sail artisan migrate

# Lancer npm
sail npm install
sail npm run dev

# Lancer composer
sail composer require livewire/livewire

# Arrêter les conteneurs
sail down

Accès : http://localhost (Port 80).

Arborescence (Simplifiée)

mon_projet/
├── app/                  (Le Cœur)
│   ├── Http/
│   │   ├── Controllers/  (Contrôleurs)
│   │   └── Middleware/   (Middleware)
│   ├── Models/           (Eloquent ORM)
│   └── Providers/        (Service Providers)
│
├── bootstrap/            (Cache, Démarrage)
├── config/               (Fichiers de config, ex: database.php)
├── database/
│   ├── migrations/       (Structure BDD)
│   └── seeders/          (Données de test)
│
├── public/               (Racine Web : index.php, assets)
│
├── resources/
│   ├── css/
│   ├── js/
│   └── views/            (Templates Blade)
│       └── welcome.blade.php
│
├── routes/
│   ├── web.php           (Routes Web)
│   └── api.php           (Routes API)
│
├── tests/                (Tests PHPUnit/PEST)
├── vendor/               (Dépendances Composer)
├── .env                  (Variables d'environnement)
└── composer.json         (Dépendances)

Le Fichier .env (Environnement)

C'est le fichier **le plus important** pour la configuration locale. Il surcharge les valeurs de config/.

# .env
APP_NAME="IDEO-Lab"
APP_ENV=local
APP_DEBUG=true
APP_URL=http://localhost

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=ideo_lab_db
DB_USERNAME=root
DB_PASSWORD=secret

# (Pour Sail, DB_HOST=mysql, DB_USERNAME=sail)

CACHE_DRIVER=file
QUEUE_CONNECTION=sync
SESSION_DRIVER=file

⚠️ Ne jamais commiter (git) le fichier .env. Utiliser .env.example comme template.

php artisan

artisan est l'équivalent de manage.py (Django) ou bin/console (Symfony). C'est votre outil pour tout faire.

Commandes de base

# Lister toutes les commandes
php artisan list

# Lancer le serveur de dev
php artisan serve

# Lancer le REPL (console)
php artisan tinker

Générateurs (make)

# Créer un Controller
php artisan make:controller ArticleController

# Créer un Modèle
php artisan make:model Article

# Créer une Migration
php artisan make:migration create_articles_table

# Créer Modèle + Migration + Factory + Seeder + Controller
php artisan make:model Article -mfs -c

Base de données (Migrations)

# Exécuter les migrations
php artisan migrate

# Annuler la dernière migration
php artisan migrate:rollback

# Tout annuler et tout refaire (DEV)
php artisan migrate:fresh

# Lancer les Seeders (données de test)
php artisan db:seed

Cache & Optimisation (Prod)

# Mettre en cache la config (accélère)
php artisan config:cache

# Mettre en cache les routes (accélère)
php artisan route:cache

# Mettre tout en cache
php artisan optimize

routes/web.php (Pour le web)

Ce fichier gère les routes "web" (avec sessions, cookies, CSRF).

Route::get (Closure)

Pour les routes simples, on peut utiliser une "Closure" (fonction anonyme).

use Illuminate\Http\Request;

// GET
Route::get('/', function () {
    return view('welcome'); // (Charge 'resources/views/welcome.blade.php')
});

// POST
Route::post('/contact', function (Request $request) {
    // $request->input('email') ...
    return redirect('/');
});

Route::get (Controller)

(Recommandé) Pour la logique complexe, on pointe vers une méthode de Controller.

use App\Http\Controllers\ArticleController;

// GET -> Méthode 'index'
Route::get('/articles', [ArticleController::class, 'index']);

// GET (ID) -> Méthode 'show'
Route::get('/articles/{id}', [ArticleController::class, 'show']);

// POST -> Méthode 'store'
Route::post('/articles', [ArticleController::class, 'store']);

// Route::put, Route::patch, Route::delete ...

// Groupe de routes
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', ...);
});

Moteur de template (.blade.php)

Blade est le moteur de template de Laravel. Il compile les fichiers .blade.php en PHP pur (très rapide).

Affichage (Échappé)

(Équivalent de htmlspecialchars())

Bonjour, {{ $user->nom }}.

Affichage (Non-échappé)

⚠️ (DANGEREUX - Risque XSS)

{!! $article->contenu_html !!}

Directives ({...)

{-- Conditionnel --}
{if ($user->isAdmin())
  <p>Accès Admin</p>
{elseif ($user->isEditor())
  <p>Accès Editeur</p>
{else
  <p>Accès Visiteur</p>
{endif

{-- Boucles --}
{foreach ($articles as $article)
  <li>{{ $article->titre }}</li>
{endforeach

{-- Sécurité CSRF (Formulaires) --}
<form method="POST">
  {csrf
  ...
</form>

Migrations (Versionning BDD)

Une migration est un fichier PHP qui décrit une modification de la structure de votre BDD (créer/modifier une table, ajouter une colonne...).

# Crée un fichier dans 'database/migrations/'
php artisan make:migration create_articles_table

// ..._create_articles_table.php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateArticlesTable extends Migration {
    public function up(): void {
        Schema::create('articles', function (Blueprint $table) {
            $table->id(); // (BigInt Unsigned Auto-Increment)
            $table->string('titre');
            $table->string('slug')->unique();
            $table->text('contenu')->nullable();
            $table->boolean('publie')->default(false);
            $table->foreignId('user_id')->constrained('users');
            $table->timestamps(); // (Ajoute created_at et updated_at)
        });
    }
    public function down(): void {
        Schema::dropIfExists('articles');
    }
}

Exécuter les Migrations

# (Configurer .env d'abord)
php artisan migrate

Seeders (Données de test)

php artisan make:seeder ArticleSeeder

// database/seeders/ArticleSeeder.php
use App\Models\Article;
use App\Models\User;

class ArticleSeeder extends Seeder {
    public function run(): void {
        Article::create([
            'user_id' => User::first()->id,
            'titre'   => 'Mon Premier Article',
            'slug'    => 'mon-premier-article',
            'contenu' => '...'
        ]);
    }
}

// (Appeler le Seeder depuis DatabaseSeeder.php)
// $this->call(ArticleSeeder::class);

// Lancer le seeding
php artisan db:seed

Active Record

Eloquent est un ORM "Active Record". Chaque Modèle (classe) correspond à une table. Chaque instance du modèle correspond à une ligne.

php artisan make:model Article

// app/Models/Article.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Article extends Model {
    
    // (Par défaut, table = 'articles')
    // protected $table = 'ma_table_custom';
    
    // (Par défaut, Clé primaire = 'id')
    // protected $primaryKey = 'article_id';
    
    // (Par défaut, 'created_at'/'updated_at' sont gérés)
    // public $timestamps = false;
    
    /**
     * (Mass Assignment) Champs autorisés
     * à l'écriture (ex: Article::create([...]))
     */
    protected $fillable = [
        'titre',
        'slug',
        'contenu',
        'user_id'
    ];

    /**
     * Champs à cacher lors de la sérialisation
     * (ex: en JSON pour une API)
     */
    protected $hidden = [
        'user_id'
    ];
}

Conventions (La "magie" de Laravel)

Eloquent repose sur des conventions fortes :

Projet & Dev

composer create-project laravel/laravel .
php artisan serve
php artisan tinker

Générateurs (make)

php artisan make:controller MonController
php artisan make:controller ApiController --api
php artisan make:controller PostController --resource

php artisan make:model Article
php artisan make:model Article -m # (avec migration)
php artisan make:model Article -mfs # (mig, factory, seeder)

php artisan make:migration create_users_table
php artisan make:seeder UserSeeder
php artisan make:factory ArticleFactory
php artisan make:middleware CheckRole
php artisan make:request StoreArticleRequest

Base de Données

php artisan migrate
php artisan migrate:fresh
php artisan migrate:rollback
php artisan db:seed

Production & Cache

php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan optimize # (Fait les 3)

php artisan config:clear
php artisan route:clear
php artisan view:clear
php artisan cache:clear
php artisan optimize:clear

Queues (Files d'attente)

php artisan queue:work
php artisan queue:listen
php artisan queue:retry [id]

Concept (L'Oignon)

Un Middleware est une "couche" (comme un oignon) que la requête HTTP traverse *avant* d'atteindre votre Controller (et *après* avoir quitté le Controller).

Usage : Authentification (auth), vérification CSRF, CORS, ajout de Headers...

Requête -> [Middleware Log] -> [Middleware Auth] -> [Controller] -> Réponse

Créer un Middleware

php artisan make:middleware CheckRole

// app/Http/Middleware/CheckRole.php
use Closure;
class CheckRole {
    public function handle(Request $request, Closure $next, string $role) {
        if (! $request->user()->hasRole($role)) {
            // Stoppe la requête
            return redirect('home');
        }
        
        // 2. Passe à la couche suivante
        return $next($request);
    }
}

Enregistrer & Utiliser

// app/Http/Kernel.php
// (Donner un "alias" au middleware)
protected $middlewareAliases = [
    'auth' => \App\Http\Middleware\Authenticate::class,
    'role' => \App\Http\Middleware\CheckRole::class,
    ...
];

// routes/web.php
// Utiliser l'alias
Route::get('/admin', ...)
    ->middleware('auth', 'role:admin');

// (Ou en groupe)
Route::middleware(['auth', 'role:admin'])->group(function () {
    // ...
});