Quelle est l'utilisation des référentiels et des interfaces dans Laravel?

je vais essayer d'expliquer le plus clairement possible les deux concepts.

Interfaces\Contrats

en général, les interfaces OOP sont utilisées pour décrire les méthodes/fonctionnalités que la classe qui implémente cette interface offre sans se soucier de la mise en œuvre effective.

Laravel utilise Contracts principalement pour séparer un service de la mise en oeuvre effective. Pour être plus claire nous allons faire un exemple

<?php

namespace App\Orders;

class OrdersCache
{

    protected $cache;

    public function __construct(\SomePackage\Cache\Memcached $cache)
    {
        $this->cache = $cache;
    }


    public function find($id)
    {
        if ($this->cache->has($id))    {
            //
        }
    }
}

comme vous pouvez le voir dans cette classe le code est étroitement couplé à une implémentation de cache (i.e. \SomePackage\Cache\Memcached) donc si L'API de cette classe Cache change notre code doit aussi être modifié en conséquence. La même chose se produit si nous voulons changer l'implémentation du Cache avec une autre (par exemple redis).

au lieu de faire cela, notre code pourrait dépendre d'une interface qui est agnostique de l'implémentation:

<?php

namespace App\Orders;

use Illuminate\Contracts\Cache\Repository as Cache;

class OrdersCache
{

    public function __construct(Cache $cache)
    {
        $this->cache = $cache;
    }


    public function find($id)
    {
        if ($this->cache->has($id))    {
            //
        }
    }
}

Maintenant notre code n'est pas associé à une implémentation spécifique car Cache est en fait une interface. Donc, fondamentalement, dans notre classe, nous avons nécessitant une instance d'une classe qui se comporte comme décrit dans la Cache interface, mais nous ne sommes pas vraiment intéressés par comment il fonctionne en interne. Faire cela si nous voulons changer l'implémentation du cache Nous pourrions écrire une classe qui implémente l'interface Cache sans changer aucune ligne de code dans notre OrdersCache classe. Faire que notre code est plus facile à comprendre et à maintenir et vos colis sont beaucoup plus réutilisable. Voir la sectionCouplage Lâche dans la documentation de Laravel pour d'autres exemples.

Interfaces et conteneur de Service

une des principales caractéristiques de Laravel est son Conteneur De Service, il est utilisé pour gérer les dépendances et effectuer l'injection de dépendances. Veuillez prendre un coup d'oeil à Conteneur De Service définition tirée de la documentation de Laravel.

L'Injection de dépendances est largement utilisée par Laravel pour lier interfaces mise en oeuvre. Nous allons faire un exemple:

$app->bind('App\Contracts\EventPusher', 'App\Services\RedisEventPusher');

Et laissez notre classe

<?php

namespace App\Http\Controllers;

use App\Contracts\EventPusher;

class EventsController extends Controller 
{

    protected $pusher;

    public function __construct(EventPusher $pusher) 
    {

        $this->pusher = $pusher;        

    }

}

sans rien déclarer d'autre, nous disons simplement à chaque fois que quelqu'un a besoin d'un EventPusher instance, veuillez Laravel, fournir une instance de RedisEventPusher classe. Dans ce cas, à chaque fois que votre controller est instancié, Laravel passera une instance de RedisEventPusher à votre contrôleur sans rien spécifier d'autre.

Vous pouvez creuser qu'en regardant lier les Interfaces à la mise en oeuvre section sur la documentation Laravel.

dépôts

les dépôts sont un concept applicable au modèle MVC indépendamment de tout cadre spécifique. Généralement, vous avez votre modèle qui est le couche de données (par ex. interagit directement avec la base de données), votre Controller qui gère la logique d'accès à la couche de données et votre vue qui montre les données fournies par le contrôleur.

à la place, les dépôts pourraient être définis comme suit:

pour le dire simplement, le motif de dépôt est une sorte de conteneur où la logique d'accès aux données est stockée. Il cache les détails de la logique d'accès aux données de la logique d'entreprise. En d'autres termes, nous permettre à Business logic d'accéder à l'objet de données sans avoir connaissance de l'architecture d'accès aux données sous-jacente.

Soruce: https://bosnadev.com/2015/03/07/using-repository-pattern-in-laravel-5

Pour savoir comment les utiliser au sein de Laravel, veuillez jeter un oeil à ce excellent article.

C'est tout, j'espère que cela aidera à éclaircir votre esprit.

les Interfaces sont ce que toute classe d'implémentation devrait appeler.

interface CanFlyInterface
{
    public function fly();
}

pensez-y comme programmer sans se soucier de logique.

if ($object instanceof CanFlyInterface) {
    $obj->fly();
}

nous aurions pu passer devant un objet oiseau, ou un objet avion! PHP S'en fout, tant qu'il implémente l'interface!

class Bird implements CanFlyInterface
{
    public function fly()
    {
        return 'flap flap!';
    }
}

class Aeroplane implements CanFlyInterface
{
    public function fly()
    {
        return 'roar! whoosh!';
    }
}

votre autre question, ce qu'est une classe de dépôt. C'est juste une classe qui garde toutes vos requêtes au même endroit. Vérifiez cette interface comme un exemple:

interface RepositoryInterface
{
    public function insert(array $data);
    public function update(array $data);
    public function findById($id);
    public function deleteById($id);
}

espérons que cela vous éclairera! Bonne chance avec tous vos codes PHP: - D

tout d'abord, l'utilisation du dépôt et de L'Interface dans une application plus grande est non seulement bénéficiaire dans Laravel, mais dans toutes les technologies pour la norme de codage ainsi que pour la séparation des préoccupations.

selon Microsoft (j'ai trouvé la meilleure explication ici)

Pourquoi utiliser le dépôt:

utiliser un dépôt pour séparer la logique qui récupère les données et les cartes à l'entité de modèle de la logique d'entreprise qui agit sur le modèle. La logique commerciale doit être agnostique au type de données qui comprend la couche source de données. Le dépôt sert d'intermédiaire entre les la couche source de données et les couches commerciales de l'application. Il recherche la source de données pour les données, cartographie les données à partir des données source à une entité commerciale, et persiste changements dans l'entreprise entité à la source de données.

Un référentiel sépare la logique métier d'après les interactions avec la source de données sous-jacente ou d'un service Web. La séparation entre les données et les affaires niveaux a trois avantages: Il centralise la logique des données ou la logique d'accès aux services Web. Il fournit un point de substitution pour les tests unitaires. Il offre un cadre souple l'architecture qui peut être adapté que la conception globale de la l'application évolue. Il y a deux façons que le dépôt peut interroger les entités commerciales. Il peut soumettre un objet de requête au client la logique d'affaires ou il peut utiliser des méthodes qui spécifient l'entreprise critère. Dans ce dernier cas, le dépôt forme la requête sur le au nom de son client. Le référentiel renvoie un ensemble d'entités qui satisfont la requête.

Pour l'Interface, vous avez beaucoup de réponses ci-dessus, j'espère que vous avez comprendre.

commençons par le plus facile, l'interface:

vous utilisez normalement des interfaces pour implémenter des classes avec les méthodes requises: http://php.net/manual/en/language.oop5.interfaces.php

Les contrats de Laravel sont un ensemble d'interfaces qui définissent les services de base fournis par le cadre. Par exemple, un contrat Illuminate\Contracts\Queue\Queue définit les méthodes nécessaires pour faire la file d'attente des travaux, tandis que le contrat Illuminate\Contracts\Mail\Mailer le contrat définit les méthodes nécessaires à l'envoi du courrier électronique. https://laravel.com/docs/5.4/contracts#introduction

lorsque Laravel est en cours d'exécution, il peut vérifier si une classe implémente une interface spéciale:

if ($cls instanceof IInterface) {
    $cls->interfaceFunction();
}

puisque Laravel est capable de travailler avec des files d'attente, il vérifiera si l'événement doit être mis en file d'attente ou non en vérifiant l'existence d'une interface de sortie.

pour informer Laravel qu'un événement donné devrait être diffusé, mettre en œuvre le Illuminate\Contracts\Broadcasting\ShouldBroadcast interface sur la classe d'événements. https://laravel.com/docs/5.4/broadcasting#defining-broadcast-events

dépôt:

je n'ai pas trouvé que beaucoup à ce sujet:

notre dépôt ne devrait pas avoir autant de connaissances sur qui leur fournit des données ou comment ils les fournissent. https://laravel.com/docs/5.4/contracts#loose-coupling

Mais j'ai trouvé quelques informations sur une page web:

Un dépôt connectera des usines avec des passerelles https://code.tutsplus.com/tutorials/the-repository-design-pattern--net-35804

le lien vous donnera plus d'informations sur les détails.

j'Espère que je pourrais vous aider :)

tout d'abord, les référentiels et les interfaces ne sont pas spécifiques à Laravel mais des standards de codage communs dans la plupart des langues.

ci-dessous, les vidéos de Laracasts seront utiles pour comprendre les bases si vous ne vous gênez pas de dépenser quelques dollars.

https://laracasts.com/lessons/repositories-and-inheritance

https://laracasts.com/series/object-oriented-bootcamp-in-php