18

DI 背后的要点是让一个类从创建和准备它所依赖的对象中解脱出来,然后将它们推入。这听起来很合理,但有时一个类不需要所有被推入其中的对象来执行其功能。这背后的原因是“提前返回”发生在无效的用户输入或所需对象之一较早抛出的异常或在代码块运行之前实例化对象所需的某个值不可用时。

更实际的例子:

  • 注入一个永远不会使用的数据库连接对象,因为用户数据没有通过验证(前提是没有使用触发器来验证这个数据)
  • 注入收集输入的类似excel的对象(例如PHPExcel)(加载和实例化很重,因为整个库被拉入并且从未使用过,因为验证在写入发生之前抛出异常)
  • 在类中确定的变量值,但不是在运行时的注入器;例如,一个路由组件,它确定应该根据用户输入调用的控制器(或命令)类和方法
  • 虽然这可能是一个设计问题,但它是一个实质性的服务类,它依赖于很多组件,但每个请求只使用其中的 1/3(原因,为什么我倾向于使用命令类而不是控制器)

因此,在某种程度上,推入所有必要的组件与创建某些组件但从未使用过的“延迟加载”相矛盾,这有点不切实际并且会影响性​​能。就 PHP 而言 - 加载、解析和编译更多文件。如果被推入的对象有自己的依赖关系,这尤其痛苦。

我看到了 3 种方法,其中 2 种听起来不太好:

  • 注入工厂
  • 注入注射器(一种反模式)
  • 注入一些外部函数,一旦达到相关点就会从类内部调用(smtg,如“数据验证完成后检索 PHPExcel 实例”);由于它的灵活性,这是我倾向于使用的

问题是处理这种情况的最佳方法是什么/你们使用什么?

更新:@GordonM 以下是 3 种方法的示例:

//inject factory example
interface IFactory{
    function factory();
}
class Bartender{
    protected $_factory;

    public function __construct(IFactory $f){
        $this->_factory = $f;
    }
    public function order($data){
        //validating $data
        //... return or throw exception
        //validation passed, order must be saved
        $db = $this->_factory->factory(); //! factory instance * num necessary components
        $db->insert('orders', $data);
        //...
    }
}

/*
inject provider example
assuming that the provider prepares necessary objects
(i.e. injects their dependencies as well)
*/
interface IProvider{
    function get($uid);
}
class Router{
    protected $_provider;

    public function __construct(IProvider $p){
        $this->_provider = $p;
    }
    public function route($str){
        //... match $str against routes to resolve class and method
        $inst = $this->_provider->get($class);
        //...
    }
}

//inject callback (old fashion way)
class MyProvider{
    protected $_db;
    public function getDb(){
        $this->_db = $this->_db ? $this->_db : new mysqli();
        return $this->_db;
    }
}
class Bartender{
    protected $_db;

    public function __construct(array $callback){
        $this->_db = $callback;
    }
    public function order($data){
        //validating $data
        //... return or throw exception
        //validation passed, order must be saved
        $db = call_user_func_array($this->_db, array());
        $db->insert('orders', $data);
        //...
    }
}
//the way it works under the hood:
$provider = new MyProvider();
$db = array($provider, 'getDb');
new Bartender($db);

//inject callback (the PHP 5.3 way)
class Bartender{
    protected $_db;

    public function __construct(Closure $callback){
        $this->_db = $callback;
    }
    public function order($data){
        //validating $data
        //... return or throw exception
        //validation passed, order must be saved
        $db = call_user_func_array($this->_db, array());
        $db->insert('orders', $data);
        //...
    }
}
//the way it works under the hood:
static $conn = null;
$db = function() use ($conn){
    $conn = $conn ? $conn : new mysqli();
    return $conn;
};
new Bartender($db);
4

4 回答 4

7

我最近在计划一个我想尽可能正确地做的主要项目时一直在考虑这个问题(坚持 LoD,没有硬编码的依赖项等)。我的第一个想法也是“注入工厂”方法,但我不确定这是要走的路。来自 Google 的 Clean Code 会谈声称,如果您通过一个对象到达您真正想要的对象,那么您就违反了 LoD。这似乎排除了注入工厂的想法,因为你必须通过工厂才能得到你真正想要的东西。也许我错过了一些让它变得好的点,但直到我确定我正在考虑其他方法。

你如何进行函数注入?我想你正在传递一个回调来实例化你想要的对象,但是一个代码示例会很好。

如果您可以使用代码示例更新您的问题,以说明您提到的三种样式,它可能会很有用。我特别渴望看到“注入注射器”,即使它是一种反模式。

于 2012-05-14T19:26:11.070 回答
5

确实出现的一个想法是代理对象的想法。它实现了与您要传入的实际对象相同的接口,但它没有实现任何东西,它只是保存真实类的实例并将方法调用转发给它。

interface MyInterface 
{
    public function doFoo ();
    public function isFoo ();
    // etc
}

class RealClass implements MyInterface
{
    public function doFoo ()
    {
         return ('Foo!');
    }

    public function isFoo ()
    {
        return ($this -> doFoo () == 'Foo!'? true: false);
    }

    // etc
}

class RealClassProxy implements MyInterface
{
    private $instance = NULL;

    /**
     * Do lazy instantiation of the real class
     *
     * @return RealClass
     */
    private function getRealClass ()
    {
        if ($this -> instance === NULL)
        {
            $this -> instance = new RealClass ();
        }
        return $this -> instance;
    }

    public function doFoo ()
    {
        return $this -> getRealClass () -> doFoo ();
    }

    public function isFoo ()
    {
        return $this -> getRealClass () -> isFoo ();
    }

    // etc
}

因为代理具有与真实类相同的接口,您可以将其作为参数传递给任何类型提示接口的函数/方法。Liskov 替换原则适用于代理,因为它响应与真实类相同的所有消息并返回相同的结果(接口强制执行此操作,至少对于方法签名)。然而,真正的类不会被实例化,除非一条消息真正被发送到代理,代理在幕后对真正的类进行惰性实例化。

function sendMessageToRealClass (MyInterface $instance)
{
    $instance -> doFoo ();
}

sendMessageToRealClass (new RealClass ());
sendMessageToRealClass (new RealClassProxy ());

代理对象涉及一个额外的间接层,这显然意味着您进行的每个方法调用都会对性能造成很小的影响。但是,它确实允许您进行惰性实例化,因此您可以避免实例化不需要的类。这是否值得取决于实例化真实对象的成本与额外间接层的成本。

编辑:我最初写这个答案的想法是对真实对象进行子类化,因此您可以将该技术用于不实现任何接口(如 PDO)的对象。我最初认为接口是执行此操作的正确方法,但我想要一种不依赖于绑定到接口的类的方法。反思这是一个很大的错误,所以我更新了答案以反映我首先应该做的事情。但是,此版本确实意味着您不能直接将此技术应用于没有关联接口的类。您必须将此类类包装在另一个类中,该类确实为代理方法提供了一个接口,这意味着另一个间接层。

于 2012-05-17T13:11:24.140 回答
3

如果你想实现延迟加载,你基本上有两种方法(正如你已经在主题中写的那样):

  1. 不是注入您可能需要的对象实例,而是注入 aFactory或 a Builder。它们之间的区别在于,创建实例Builder是为了返回一种类型的对象(可能具有不同的设置),而Factory创建不同类型的实例(具有相同的生命周期和/或实现相同的接口)。

  2. 利用匿名函数,它将返回一个实例。看起来像这样:

    $provider = function() {
        return new \PDO('sqlite::memory:');
    };
    

    只有当您调用此匿名函数时,PDO才会创建实例并建立与数据库的连接。

我通常在我的代码中做的是结合两者。你可以装备Factory这样的provider。例如,这使您可以为由所述工厂创建的所有对象建立一个连接,并且仅当您第一次从Factory.

结合这两种方法的另一种方法(虽然我没有使用过)是创建完整Provider的类,它在构造函数中接受一个匿名函数。然后工厂可以传递同一个实例,Provider并且昂贵的对象(PHPExcel、Doctrine、SwiftMailer 或其他实例)仅在ProductFactory一次变成Provider (无法想出更好的名称来描述所​​有对象时)创建由同一工厂创建)并请求它。之后,这个昂贵的对象在所有Products.Factory

...我的 2 美分

于 2012-05-17T13:44:36.400 回答
0

我选择了惰性注入(即注入一个代理类):

class Class1 {
    /**
     * @Inject(lazy=true)
     * @var Class2
     */
    private $class2;

    public function doSomething() {
        // The dependency is loaded NOW
        return $this->class2->getSomethingElse();
    }

这里,依赖(class2)不是直接注入的:注入了一个代理类。只有在使用代理类时才会加载依赖项。

这在PHP-DI(依赖注入框架)中是可能的。

免责声明:我在这个项目中工作

于 2012-10-07T09:32:51.723 回答