Laravel PHP méthode remplacée avec différents paramètres

Question

Désolé si cette question a été posée plusieurs fois auparavant et que cela n'est tout simplement pas possible en Laravel/PHP.

Dans mon application Laravel, j'ai un PostController，它使用 Laravel 丰富的命名约定。我还有一个 CommentController，它主要以各种方式复制 PostController，因此我决定 CommentController qui devrait étendre PostController.

La seule différence jusqu'à présent est que la méthode store() 方法需要接受不同的 FormRequest 对象，因为它们具有不同的验证规则。因此，我重写了 store() 方法以期望 CommentFormRequest 而不是 PostFormRequest （两者都扩展了 FormRequeststore() doit accepter un objet

FormRequest différent car ils ont des règles de validation différentes. Par conséquent, j'ai remplacé la méthode

store() pour attendre

CommentFormRequest au lieu de

PostFormRequest (les deux étendent

FormRequest).

Cela générera une erreur indiquant que les paramètres de la méthode remplacés doivent correspondre à la méthode de base.

Est-ce prévu ? Existe-t-il une solution raisonnable pour ce que je veux faire ?

Modifié à partir d'iciPost类型。有些与其他模型有关系，例如Poll 可能与 PredefinedAnswer 模型有关系，而通用 Post

Je viens de commencer à concevoir ce projet où les utilisateurs peuvent créer des publications, des questions, des sondages, des publicités, etc. et commenter n'importe lequel d'entre eux. Post 发表评论，但可能永远不允许对 Advert

Ce sont tous des types

Post. Certains ont des relations avec d'autres modèles, par exemple post 表中，但具有不同的 postable_typePoll peut avoir des relations avec le modèle

PredefinedAnswer, alors que le modèle

Post générique peut ne pas l'être.

Certains peuvent nécessiter une logique de validation différente, par exemple un utilisateur peut décider d'autoriser ou non les commentaires sur une PostController 中，我目前有一个非常简单的 store()Post générique, mais peut ne jamais autoriser les commentaires sur une

Annonce.

AdvertControllerDans ma base de données, je pense que tout cela pourrait être stocké dans la table

post, mais avec un

postable_type différent. 🎜 🎜Dans mon contrôleur, je pense que la majeure partie de la logique CRUD est la même entre ces différents types. Dans certains cas, des différences peuvent exister et il faudra peut-être remplacer les méthodes. 🎜 🎜Donc, dans mon 🎜PostController, j'ai actuellement une méthode 🎜store() très simple : 🎜

class PostController extends Controller
{

    protected $postableType;


    public function __construct()
    {
        $this->postableType = PostType::GENERIC;
    }

    public function store(PostStoreRequest $request): RedirectResponse
    {
        $validated = $request->validated();

        $post = new Post();
        $post->message = $validated['message'];
        $post->user_id = $request->user()->id;

        $post->postable_type = $this->postableType;

        $post->save();

        return Redirect::route('feed');
    }
}

🎜Supposons que mon 🎜AdvertController ait la même logique mais des règles de validation différentes, je pense : 🎜

class AdvertController extends PostController
{

    protected $postableType;

    public function __construct()
    {
        $this->postableType = PostType::ADVERT;
    }

    public function store(AdvertStoreRequest $request): RedirectResponse
    {
        $validated = $request->validated();

        $advert= new Advert();
        $advert->message = $validated['message'];
        $advert->user_id = $request->user()->id;

        $advert->postable_type = $this->postableType;
        $advert->save();

        return Redirect::route('feed');
    }

🎜

Answer 1

Au lieu d'impliquer une implémentation spécifique, vous obtiendrez plus d'avantages en impliquant l'interface, par exemple :

interface StoreRequestInterface {
  public function validated(): RedirectResponse;
  public function user();
  // etc
}

class PostStoreRequest implements StoreRequestInterface {/* ... */}
class AdvertStoreRequest  implements StoreRequestInterface {/* ... */}

abstract class Controller {
    protected $postableType;

    public function store(StoreRequestInterface $request): RedirectResponse
    {
        // ...
    }
}

class PostController extends Controller
{
    public function __construct()
    {
        $this->postableType = PostType::GENERIC;
    }
}

class AdvertController extends PostController
{
    public function __construct()
    {
        $this->postableType = PostType::ADVERT;
    }
}

De cette façon, vous :

• Pas besoin de redéfinir le même corps de méthode avec des indications de paramètres légèrement différentes.
• peut être appelé parent::store($request) dans les cas où une manipulation particulière est requise, par exemple : vérifications de type/sanité, mais le reste de la méthode reste le même.
• Vous pouvez éviter l'écueil de la définition d'une classe « dieu », dont la lignée doit être retracée par un grand nombre de classes d'application. Vous pouvez définir des remplacements autonomes en implémentant simplement l'interface attendue.

Vous pouvez connecter davantage d'autres classes référencées ici [par exemple : ControllerInterface、RedirectInterfaceetc.] et simplifier davantage votre code.