Les contrats de Laravel sont des interfaces qui définissent les services de base, permettant un code découplé et testable en fonction des abstractions plut?t que des implémentations; 1. Comprenez que des contrats comme illuminate \ contracts \ cache \ le référentiel servent de plans pour les fonctionnalités; 2. Utilisez-les dans des constructeurs ou des méthodes de type hint, permettant au conteneur de service de Laravel d'injecter l'implémentation correcte; 3. Appliquer des contrats dans les fournisseurs de services ou des classes personnalisées pour assurer la réutilisabilité et la testabilité, telles que l'injection du contrat de file d'attente dans un service; 4. Tire de l'injection de dépendance pour une moquerie plus facile dans les tests, améliorant la fiabilité des tests; 5. Remplacer les fa?ades comme Cache :: get () par leurs équivalents contractuels pour améliorer la conception et la maintenabilité; 6. Fendre éventuellement les implémentations personnalisées aux contrats dans les fournisseurs de services pour un comportement personnalisé; En fin de compte, l'utilisation de contrats favorise de meilleures pratiques de codage dans des applications complexes.

Dans Laravel, les ?contrats? se réfèrent à un ensemble d'interfaces qui définissent les services de base fournis par le cadre. Ils vivent dans le package illuminate/contracts et agissent comme un plan pour les fonctionnalités de Laravel - comme la mise en cache, les files d'attente, le courrier, les événements, etc. L'utilisation de contrats vous aide à écrire plus de code découplé et testable en fonction des abstractions (interfaces), et non des implémentations concrètes.

Voici comment utiliser efficacement les contrats à Laravel:

? 1. Comprendre quels sont les contrats

Les contrats de Laravel sont des interfaces. Par exemple:

• Illuminate\Contracts\Cache\Repository
• Illuminate\Contracts\Queue\Queue
• Illuminate\Contracts\Mail\Mailer

Ceux-ci définissent ce qu'un service peut faire, sans préciser comment il le fait. L'implémentation réelle (comme Redis pour Cache, ou SMTP pour le courrier) est injectée lors de l'exécution via le conteneur de service de Laravel.

? Idée clé : au lieu de l'observation de type une classe de béton (qui vous lie à une implémentation), vous appuyez sur l'interface (contrat), permettant à Laravel injecter la bonne implémentation.

? 2. Utiliser des contrats en hentoureuse (contr?leurs, emplois, etc.)

Laravel résout automatiquement les interfaces contractuelles lorsque vous les soulignez dans les constructeurs ou les paramètres de méthode.

Exemple: Utilisation du contrat de cache dans un contr?leur

 <? Php

Namespace App \ Http \ Controllers;

Utiliser illuminate \ http \ request;
Utiliser illuminate \ contracts \ cache \ référentiel comme cache;

Class UserController étend le contr?leur
{
    Cache $ protégé;

    // Type-Hint le contrat
    fonction publique __construct (cache $ cache)
    {
        $ this-> cache = $ cache;
    }

    Index de fonction publique ()
    {
        // Le cache $ est automatiquement résolu au pilote de cache configuré
        $ utilisateurs = $ this-> cache-> reound (&#39;utilisateurs&#39;, 3600, function () {
            RETOUR UTILISATEUR :: All ();
        });

        return View (&#39;Users.Index&#39;, Compact (&#39;Users&#39;));
    }
}

Le conteneur de Laravel sait injecter une classe qui implémente Illuminate\Contracts\Cache\Repository basé sur votre configuration ( config/cache.php ).

? 3. Utiliser des contrats dans les fournisseurs de services et les cours personnalisés

Lorsque vous construisez des services ou des forfaits réutilisables, dépendez des contrats pour séjourner l'agnostique du cadre et testable.

Exemple: un service utilisant le contrat de file d'attente

 <? Php

Namespace App \ Services;

Utiliser illuminate \ contracts \ queue \ file d&#39;attente;

Classe ExportService
{
    PROTéRé $ la file d&#39;attente;

    fonction publique __construct (file d&#39;attente $ file d&#39;attente)
    {
        $ this-> queue = $ file d&#39;attente;
    }

    Fonction publique DispatchExport ($ Job)
    {
        $ this-> file d&#39;attente-> push ($ job);
    }
}

Ensuite, inscrivez-vous et utilisez-le:

 // dans un contr?leur
Exportation des fonctions publiques (service d'exportation $)
{
    $ Service-> DispatchExport (nouveau exportUsersJob ());
    return réponse () -> json (['status' => 'fileate']);
}

? 4. bénéficier de l'injection et des tests de dépendance

Parce que vous utilisez des interfaces, vous pouvez facilement les se moquer des tests.

Exemple: test avec un cache moqué

 /** @test */
fonction publique it_us_cache_contract ()
{
    // se moque du contrat
    $ this-> instance (\ illuminate \ contracts \ cache \ repository :: class, $ mock = mockery :: mock (\ illuminate \ contracts \ cache \ repository :: class));

    $ mock-> omméReceive ('Get') -> avec ('key') -> anTreturn ('value');

    $ réponse = $ this-> get ('/ cached-rote');

    $ Response-> ASSERTSEE ('Value');
}

Ceci est plus propre que de se moquer d'un pilote de cache spécifique.

? 5. Contrats et fa?ades couramment utilisées

Vous pourriez être habitué à utiliser des fa?ades comme Cache::get() ou Mail::send() . Les contrats sont une alternative qui favorise une meilleure conception.

? Vous pouvez passer des fa?ades aux contrats pour rendre votre code plus testable et moins statique.

? 6. Enregistrer les implémentations personnalisées (facultatif)

Vous pouvez lier votre propre mise en ?uvre d'un contrat dans un fournisseur de services:

 $ this-> app-> bind (
    \ Illuminer \ contracts \ mail \ Mailer :: Class,
    \ App \ Services \ CustomMailer :: Classe
));

Maintenant, chaque fois que le contrat est introduit de type, votre mailer personnalisé est injecté.

Résumé: meilleures pratiques

• ? Utilisez des contrats lors de la rédaction de cours qui dépendent des services Laravel.
• ? Type les insuffisant dans les constructeurs ou les arguments de méthode - Laravel gère le reste.
• ? évitez le couplage serré à des implémentations spécifiques (par exemple, redis, file d'attente de base de données).
• ? Utilisez-les dans des packages ou de grandes applications où la testabilité et la flexibilité sont importantes.
• ? Préférez les contrats aux fa?ades dans des services complexes (bien que les fa?ades soient bien pour les cas simples).

L'utilisation de contrats n'est pas obligatoire dans Laravel - les fa?ades sont totalement valables - mais ils sont un outil puissant pour écrire du code propre, testable et maintenable, d'autant plus que votre application se développe.

Fondamentalement, si vous souhaitez écrire du code plus facile à tester et moins lié aux internes de Laravel, les contrats sont la voie à suivre.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!