Laravel Vs Symfony – concetti chiave e terminologia

Symfony e Laravel sono due framework PHP molto popolari, ciascuno con un approccio e una terminologia unica. In questo articolo, confronto i principali concetti di Laravel con quelli equivalenti in Symfony, offrendo esempi di codice per ciascun caso.

Middleware (Laravel) vs Event Subscriber (Symfony)

Laravel: Middleware
I middleware in Laravel sono classi che filtrano le richieste HTTP. Possono essere utilizzati per compiti come l’autenticazione o la registrazione dei log.

<?php

namespace App\Http\Middleware;

use Closure;

class CheckAge
{
    public function handle($request, Closure $next)
    {
        if ($request->age < 18) {
            return redirect('home');
        }

        return $next($request);
    }
}

Symfony: Event Subscriber
In Symfony, il concetto simile si realizza con gli Event Subscriber o i Kernel Events, che permettono di manipolare le richieste e risposte.

<?php

namespace App\EventSubscriber;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\RequestEvent;

class CheckAgeSubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return [
            RequestEvent::class => 'onKernelRequest',
        ];
    }

    public function onKernelRequest(RequestEvent $event)
    {
        $request = $event->getRequest();
        if ($request->get('age') < 18) {
            $event->setResponse(new RedirectResponse('/home'));
        }
    }
}

Eloquent ORM (Laravel) vs Doctrine ORM (Symfony)

Laravel: Eloquent ORM
Laravel utilizza Eloquent come ORM per interagire con il database tramite Active Record.

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $fillable = ['name', 'email', 'password'];
}

// Query example
$users = User::where('active', true)->get();

Symfony: Doctrine ORM
Symfony utilizza Doctrine come ORM, basato sul pattern Data Mapper.

<?php

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
class User
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: 'integer')]
    private $id;

    #[ORM\Column(type: 'string')]
    private $name;

    #[ORM\Column(type: 'string')]
    private $email;

    // Getters and setters...
}

// Query example
$users = $entityManager->getRepository(User::class)->findBy(['active' => true]);

Routes: Laravel vs Symfony

Laravel: Routes
In Laravel, le rotte vengono definite in file come web.php o api.php.

use App\Http\Controllers\UserController;

Route::get('/users', [UserController::class, 'index']);

namespace App\Controller;

use Symfony\Component\Routing\Annotation\Route;

class UserController
{
    #[Route('/users', name: 'user_index')]
    public function index()
    {
        // ...
    }
}

Policies (Laravel) vs Voter (Symfony)

Laravel: Policies
Le Policies in Laravel vengono utilizzate per gestire l’autenticazione degli utenti.

<?php

namespace App\Policies;

use App\Models\User;
use App\Models\Post;

class PostPolicy
{
    /**
     * Determina se il post specificato può essere aggiornato dall’utente.
     *
     * @param  \App\Models\User  $user
     * @param  \App\Models\Post  $post
     * @return bool
     */
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }
}

Symfony: Voter
In Symfony, il concetto equivalente è realizzato tramite i Voter.

<?php

namespace App\Security\Voter;

use Symfony\Component\Security\Core\Authorization\Voter\Voter;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\Voter\Attribute\Post;

class PostVoter extends Voter
{
    protected function supports(string $attribute, $subject): bool
    {
        return $attribute === 'POST_EDIT' && $subject instanceof Post;
    }

    protected function voteOnAttribute(string $attribute, $subject, TokenInterface $token): bool
    {
        $user = $token->getUser();
        return $user->getId() === $subject->getUserId();
    }
}

Providers (Laravel) vs Symfony Services

Laravel: Providers
I Service Providers in Laravel sono utilizzati per registrare i servizi all’interno dell’applicazione. Ogni provider estende la classe ServiceProvider e contiene metodi per configurare i servizi.

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind('App\Contracts\ExampleContract', function ($app) {
            return new ExampleImplementation();
        });
    }

    public function boot()
    {
        // Code to bootstrap services...
    }
}

Symfony: Services
In Symfony, l’equivalente dei Providers è il sistema di Dependency Injection attraverso il Service Container. I servizi vengono definiti nei file di configurazione (ad esempio, YAML o XML) o tramite attributi nella classe.

# config/services.yaml
services:
    App\Service\ExampleService:
        arguments:
            $dependency: '@App\Service\DependencyService'

<?php

namespace App\Service;

class ExampleService
{
    private $dependency;

    public function __construct(DependencyService $dependency)
    {
        $this->dependency = $dependency;
    }

    public function doSomething()
    {
        // ...
    }
}

Invio Email: Laravel vs Symfony

Laravel: Invio Email
Laravel utilizza una sintassi semplice per inviare email con il supporto integrato per i driver di posta.

Mail::to('user @ example.com')->send(new WelcomeEmail($user));

Symfony: Invio Email
Symfony utilizza il componente Mailer.

use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Email;

$email = (new Email())
    ->from('hello @ example.com')
    ->to('user @ example.com')
    ->subject('Welcome!')
    ->text('Hello and welcome!');

$mailer->send($email);

Conclusione

Laravel e Symfony offrono strumenti potenti per la creazione di applicazioni web, ma si distinguono per approccio e terminologia. Scegliere il framework giusto dipende dalle esigenze specifiche del progetto e dalle preferenze personali del team.