32

我正在使用 Laravel 4 构建一个 CMS，并且我有一个用于管理页面的基本管理控制器，看起来像这样：

class AdminController extends BaseController {

    public function __construct(UserAuthInterface $auth, MessagesInterface $message, ModuleManagerInterface $module)
    {
        $this->auth = $auth;
        $this->user = $this->auth->adminLoggedIn();
        $this->message = $message;
        $this->module = $module;
    }
}

我使用 Laravel 的 IOC 容器将类依赖项注入到构造函数中。然后，我有各种控制器类来控制构成 CMS 的不同模块，并且每个类都扩展了管理类。例如：

class UsersController extends AdminController {

    public function home()
    {
        if (!$this->user)
        {
            return Redirect::route('admin.login');
        }
        $messages = $this->message->getMessages();
        return View::make('users::home', compact('messages'));
    }
}

现在这可以完美地工作，但是当我向类中添加构造函数时，会出现我的问题，这不是问题而是效率问题UsersController。例如：

class UsersController extends AdminController {

    public function __construct(UsersManager $user)
    {
        $this->users = $users;
    }

    public function home()
    {
        if (!$this->user)
        {
        return Redirect::route('admin.login');
        }
        $messages = $this->message->getMessages();
        return View::make('users::home', compact('messages'));
    }
}

由于子类现在有一个构造函数，这意味着父类的构造函数没有被调用，因此子类所依赖的东西，例如this->user不再有效，导致错误。但是，我可以通过调用管理控制器的构造函数，parent::__construct()因为我需要将类依赖项传递给它，我需要在子构造函数中设置这些依赖项，结果如下所示：

class UsersController extends AdminController {

    public function __construct(UsersManager $user, UserAuthInterface $auth, MessagesInterface $message, ModuleManagerInterface $module)
    {
        parent::__construct($auth, $messages, $module);
        $this->users = $users;
    }

    // Same as before
}

现在，就其功能而言，这可以正常工作；但是，在每个具有构造函数的子类中都必须包含父类的依赖项，这对我来说似乎不是很有效。它看起来也很乱。Laravel 是否提供了解决此问题的方法，或者 PHP 是否支持调用父构造函数和子构造函数而无需parent::__construct()从子构造函数调用的方法？

我知道这是一个很长的问题，实际上什么不是问题，但更多的是我只是对效率很感兴趣，但我很欣赏任何想法和/或解决方案。

提前致谢！

4

6 回答 6

10

没有完美的解决方案，重要的是要明白这不是 Laravel 本身的问题。

要管理此问题，您可以执行以下三件事之一：

  1. 将必要的依赖项传递给父级（这是您的问题）

    // Parent
public function __construct(UserAuthInterface $auth, MessagesInterface $message, ModuleManagerInterface $module)
{
    $this->auth = $auth;
    $this->user = $this->auth->adminLoggedIn();
    $this->message = $message;
    $this->module = $module;
}

// Child
public function __construct(UsersManager $user, UserAuthInterface $auth, MessagesInterface $message, ModuleManagerInterface $module)
{
    $this->users = $users;
    parent::__construct($auth, $message, $module);
}

  2. 自动解析父构造中的依赖关系，如@piotr_cz 在他的回答中所述

  3. 在父构造中创建实例，而不是将它们作为参数传递（因此您不使用依赖注入）：

    // Parent
public function __construct()
{
    $this->auth = App::make('UserAuthInterface');
    $this->user = $this->auth->adminLoggedIn();
    $this->message = App::make('MessagesInterface');
    $this->module = App::make('ModuleManagerInterface');
}

// Child
public function __construct(UsersManager $user)
{
    $this->users = $users;
    parent::__construct();
}

如果你想测试你的类，第三种解决方案将更难测试。我不确定您是否可以使用第二种解决方案来模拟这些类，但您可以使用第一种解决方案来模拟它们。

于 2015-05-14T11:17:04.283 回答
5

我知道这是一个非常古老的问题，但我刚刚完成了对我当前项目的一个类似问题的研究，并对手头的问题有所了解。

这里的基本问题是：

如果我正在扩展一个具有构造函数的父类。该构造函数已注入依赖项，并且它的所有依赖项都已记录在父级本身中。为什么我必须在我的子类中再次包含父级的依赖项？

我遇到了同样的问题。

我的父类需要 3 个不同的依赖项。它们是通过构造函数注入的：

<?php namespace CodeShare\Parser;

use CodeShare\Node\NodeRepositoryInterface as Node;
use CodeShare\Template\TemplateRepositoryInterface as Template;
use CodeShare\Placeholder\PlaceholderRepositoryInterface as Placeholder;

abstract class BaseParser {

    protected $node;
    protected $template;
    protected $placeholder;


    public function __construct(Node $node, Template $template, Placeholder $placeholder){
        $this->node           = $node;
        $this->template       = $template;
        $this->placeholder    = $placeholder;
    }

该类是一个抽象类，因此我永远无法自己实例化它。use当我扩展类时，我仍然需要在子构造函数中包含所有这些依赖项及其引用：

<?php namespace CodeShare\Parser;

// Using these so that I can pass them into the parent constructor
use CodeShare\Node\NodeRepositoryInterface as Node;
use CodeShare\Template\TemplateRepositoryInterface as Template;
use CodeShare\Placeholder\PlaceholderRepositoryInterface as Placeholder;
use CodeShare\Parser\BaseParser;

// child class dependencies
use CodeShare\Parser\PlaceholderExtractionService as Extractor;
use CodeShare\Parser\TemplateFillerService as TemplateFiller;


class ParserService extends BaseParser implements ParserServiceInterface {

    protected $extractor;
    protected $templateFiller;

    public function __construct(Node $node, Template $template, Placeholder $placeholder, Extractor $extractor, TemplateFiller $templateFiller){
        $this->extractor      = $extractor;
        $this->templateFiller = $templateFiller;
        parent::__construct($node, $template, $placeholder);
    }

在每个类中包含use3 个父依赖项的语句似乎是重复代码，因为它们已经在父构造函数中定义。我的想法是删除父use语句，因为它们总是需要在扩展父的子类中定义。

我意识到在父类中use包含依赖项并在父类的构造函数中包含类名只需要在父类中进行类型提示。

如果从父构造函数中删除use语句并从父构造函数中删除类型提示的类名，则会得到：

<?php namespace CodeShare\Parser;

// use statements removed

abstract class BaseParser {

    protected $node;
    protected $template;
    protected $placeholder;

    // type hinting removed for the node, template, and placeholder classes
    public function __construct($node, $template, $placeholder){
        $this->node           = $node;
        $this->template       = $template;
        $this->placeholder    = $placeholder;
    }

如果没有use来自父级的语句和类型提示，它就不能再保证传递给它的构造函数的类的类型，因为它无法知道。您可以使用任何东西从您的子类构建，并且父母会接受它。

看起来确实像双重输入代码，但实际上在您的父母中，您不是在使用父项中布置的依赖项进行构建，而是在验证子项是否发送了正确的类型。

于 2014-12-29T22:23:34.193 回答
3

有办法。当 BaseController 自动解析它的依赖项时。

use Illuminate\Routing\Controller;
use Illuminate\Foundation\Application;

// Dependencies
use Illuminate\Auth\AuthManager;
use Prologue\Alerts\AlertsMessageBag;

class BaseController extends Controller {

    protected $authManager;
    protected $alerts;

    public function __construct(
        // Required for resolving
        Application $app,

        // Dependencies
        AuthManager $authManager = null,
        AlertsMessageBag $alerts = null
    )
    {
        static $dependencies;

        // Get parameters
        if ($dependencies === null)
        {
            $reflector = new \ReflectionClass(__CLASS__);
            $constructor = $reflector->getConstructor()
            $dependencies = $constructor->getParameters();
        }

        foreach ($dependencies as $dependency)
        {
            // Process only omitted optional parameters
            if (${$dependency->name} === null)
            {
                // Assign variable
                ${$dependency->name} = $app->make($dependency->getClass()->name);
            }
        }


        $this->authManager = $authManager;
        $this->alerts = $alerts;

        // Test it
        dd($authManager);
    }
}

所以在子控制器中你只传递应用程序实例：

class MyController extends BaseController {

    public function __construct(
        // Class dependencies resolved in BaseController
        //..

        // Application
        Application $app
    )
    {
        // Logic here
        //..


        // Invoke parent
        parent::__construct($app);
    }
}

当然，我们可以使用 Facade 进行应用

于 2014-06-28T13:08:13.747 回答
0

您必须将依赖项传递给父构造函数才能使它们在子构造函数中可用。当您通过子构造实例化父构造时，无法将依赖项注入到父构造中。

于 2014-01-19T06:12:30.070 回答
0

在扩展我的基本控制器时，我遇到了同样的问题。

我选择了与此处显示的其他解决方案不同的方法。我不是依赖依赖注入，而是在父构造函数中使用 app()->make()。

class Controller
{
    public function __construct()
    {
        $images = app()->make(Images::class);
    }
}

这种更简单的方法可能有缺点——可能会使代码的可测试性降低。

于 2017-12-02T14:22:30.187 回答
0

我也解决了这个问题，并通过不在子类中调用构造函数并在函数参数中使用额外需要的依赖项来清除这个混乱。

它将与控制器一起使用，因为您不需要手动调用这些函数，并且可以在那里注入所有内容。因此，常见的依赖项转到父项，而较少需要的将添加到方法本身。

于 2020-10-13T20:27:57.920 回答