Utilisation du pattern repository dans Laravel : Avantages et Exemples

Dans le développement avec Laravel, il est fréquent de manipuler des modèles Eloquent directement dans les contrôleurs. Cependant, à mesure que votre application grandit, cette approche peut rendre le code plus difficile à maintenir. C’est là qu’intervient le Repository Pattern, qui permet de structurer et d’organiser la logique d’accès aux données.

Pourquoi utiliser un Repository dans Laravel ?

L’utilisation d’un repository présente plusieurs avantages :

• Séparation des responsabilités : Le contrôleur se concentre sur la logique métier et délègue l’accès aux données au repository.
• Facilité de maintenance : Les modifications sur les requêtes Eloquent se font dans un seul fichier au lieu de multiples endroits.
• Réutilisabilité : Un repository peut être réutilisé dans plusieurs contrôleurs ou services.
• Testabilité améliorée : Il est plus simple de mocker un repository lors des tests unitaires.

Utilisation des interfaces avec les Repositories

Créer une interface pour un repository permet d’améliorer encore plus la maintenabilité du code. Cela permet de définir un contrat clair sur les méthodes à implémenter et facilite le remplacement ou la modification de l’implémentation sans affecter le reste du code.

Exemple d’interface Repository

namespace App\Repositories;

interface UserRepositoryInterface
{
    public function getAllActiveUsers();
    public function createUser(array $data);
}

Implémentation de l’interface

namespace App\Repositories;

use App\Models\User;

class UserRepository implements UserRepositoryInterface
{
    public function getAllActiveUsers()
    {
        return User::where('active', true)->orderBy('name')->get();
    }

    public function createUser(array $data)
    {
        return User::create($data);
    }
}

Enregistrement du binding dans le Service Provider

use App\Repositories\UserRepository;
use App\Repositories\UserRepositoryInterface;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(UserRepositoryInterface::class, UserRepository::class);
    }
}

Grâce à ce binding, Laravel injectera automatiquement l’implémentation UserRepository lorsque UserRepositoryInterface sera requis.

Exemple sans Repository

Prenons un exemple simple d’un contrôleur qui gère les utilisateurs sans repository :

use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index()
    {
        $users = User::where('active', true)->orderBy('name')->get();
        return response()->json($users);
    }

    public function store(Request $request)
    {
        $user = User::create($request->only(['name', 'email', 'password']));
        return response()->json($user, 201);
    }
}

Dans ce cas, la logique de récupération et de création d’un utilisateur est directement dans le contrôleur, ce qui peut vite devenir problématique lorsque l’on multiplie les requêtes similaires.

Exemple avec un Repository

Nous allons maintenant structurer le code en utilisant un repository.

Création du Repository

namespace App\Repositories;

use App\Models\User;

class UserRepository implements UserRepositoryInterface
{
    public function getAllActiveUsers()
    {
        return User::where('active', true)->orderBy('name')->get();
    }

    public function createUser(array $data)
    {
        return User::create($data);
    }
}

Utilisation dans le Contrôleur

use App\Repositories\UserRepositoryInterface;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function __construct(protected UserRepositoryInterface $userRepository) {}

    public function index()
    {
        $users = $this->userRepository->getAllActiveUsers();
        return response()->json($users);
    }

    public function store(Request $request)
    {
        $user = $this->userRepository->createUser($request->only(['name', 'email', 'password']));
        return response()->json($user, 201);
    }
}

Comparaison et Conclusion