Utilisez le polymorphisme pour renvoyer plusieurs résultats et utiliser plusieurs comportements en même temps

Question

J'utilise Laravel 9 et j'ai une requête qui contient :

• Paramètre nommé SEASON, la valeur peut être array Ainsi, le paramètre SEASON peut être array
• Le paramètre nommé EXPIRY peut être array ou null

J'ai deux classes, une pour la fonctionnalité SEASON et une pour la fonctionnalité EXPIRY, toutes deux issues de l'extension Repository Les deux ont une méthode appelée execute qui renvoie un tableau

Référentiel de classes abstraites
{
     fonction publique abstraite execute() : array ;
}


L'expiration de la classe étend le référentiel
{
   fonction publique exécuter()
   {
       return ['La requête contient un paramètre d'expiration et les comportements saisonniers sont effectués'] ;
   }
}


La saison de classe étend le référentiel
{
   fonction publique exécuter()
   {
       return ['La requête contient le paramètre de saison et les comportements d'expiration sont effectués'] ;
   }
}</pré>
<p>Si ma requête contient SEASON, je souhaite appeler la méthode d'exécution de la classe Season, ou si ma requête contient Expiry, je souhaite appeler la méthode d'exécution d'expiration. Ou appelez-les et fusionnez les retours d'exécution dans un tableau afin que je puisse obtenir les résultats. </p>
<pre class="brush:php;toolbar:false;">['La demande contient un paramètre d'expiration et les comportements saisonniers sont effectués', 'La demande contient un paramètre d'expiration et les comportements d'expiration sont effectués']

;

Voici ce que j'ai essayé dans le contrôleur :

amorçage de la fonction publique ($data)
{
    $parseTopics = Helper::parseTopicsRequest();

    $basicProgram = nouveau BasicProgramRepository();
    $seasonalProgram = new SeasonalProgramRepository($parseTopics['SEASONAL']);


    $object = count($parseTopics['SEASONAL']) $seasonalProgram : $basicProgram;
    // Polymorphisme
    return $object->execute();
}</pré>
<p>Question 1 :
Je ne sais pas si je dois utiliser ceci ou quelque chose de similaire pour résoudre mes besoins : </p>
<pre class="brush:php;toolbar:false;">$employe = new Program(new BasicProgramRepository());

Résultats attendus : Le résultat attendu dépend de la disponibilité ou non des paramètres de saison et de l'heure d'expiration. Ce que je veux réaliser, c'est utiliser un comportement différent (méthode d'exécution)

Answer 1

Si vous souhaitez mettre en œuvre une approche polymorphe, il est préférable de créer un référentiel ou quelque chose juste pour gérer cette logique.

Ceci est un exemple.

class SampleRepository
{
    /**
     * repository instance value
     *
     * @var string[] | null
     */
    private $sampleArray; // maybe here is SEASON or EXPIRY or null

    /**
     * constructor
     *
     * @param string[] | null $sampleArray
     */
    public function __construct($sampleArray)
    {
        $this->sampleArray = $sampleArray;
    }

    /**
     * execute like class interface role
     *
     * @return array
     */
    public function execute()
    {
        return (!$this->sampleArray) ? [] : $this->getResult();
    }

    /**
     * get result
     *
     * @return array
     */
    private function getResult()
    {
        // maybe pattern will be better to manage another class or trait.
        $pattern = [
            "SEASON" => new Season(),
            "EXPIRY" => new Expiry()
        ];
        return collect($this->sampleArray)->map(function($itemKey){
            $requestClass = data_get($pattern,$itemKey);
            if (!$requestClass){ // here is space you don't expect class or canIt find correct class
                return ["something wrong"];
            }
            return $requestClass->execute();
        })->flatten();
    }
}

Vous pouvez l'appeler ainsi.

$sampleRepository  = new SampleRepository($sampleValue); // expect string[] or null like ["SEASON"],["SEASON","EXPIRY"],null
    $result = $sampleRepository->execute(); // [string] or [string,string] or []

Cette méthode ne fonctionne qu'avec les valeurs spécifiées par vos paramètres. Si les résultats de retour de la classe Saison et de la classe Expiration sont quasiment les mêmes, il est préférable de les gérer sur des traits. (c'est-à-dire $pattern dans l'exemple de code)

Essayez-en.

J'ai lu les commentaires, alors suivez..

Par exemple, il préfère simplement obtenir le résultat de getResult(). Par conséquent, certains modèles et tant de logique ne doivent pas être écrits sur getResult();

Si vous utilisez des traits, voici un exemple. Tout d’abord, vous devez créer la classe de comportement de gestion.

behaviour.php

<?php 
namespace App\Repositories;

class Behavior
{
    use Behavior\BehaviorTrait;
    // if you need to add another pattern, you can add trait here.
}

Ensuite, vous devez créer un répertoire Comportement au même niveau. Lorsque vous déplacez ce répertoire, vous créez un tel fichier de signature.

<?php

namespace App\Repositories\Behavior;

trait BehaviorTrait
{
    public static function findAccessibleClass(string $itemKey)
    {
      return data_get([
        "SEASON" => new Season(),
        "EXPIRY" => new Expiry()
      ],$itemKey);
    }
}

La méthode

findAccessibleClass() est chargée de trouver la bonne classe.

Ensuite, vous pouvez appeler cette méthode comme ceci.

private function getResult()
    {
        return collect($this->sampleArray)->map(function($itemKey){
            $requestClass = Behavior::findAccessibleClass($itemKey); // fix here.
            if (!$requestClass){ // here is space you don't expect class or canIt find correct class
                return ["something wrong"];
            }
            return $requestClass->execute();
        })->flatten();
    }

S'il y a trop de code dans getResult(), il est préférable de séparer le code responsable.

Pour créer un trait de comportement, getResult n'a pas besoin d'être responsable de la logique comportementale. Bref, ce sera facile à tester ou à réparer.

J'espère que tout se passe bien.