具有一对多关系的NSFetchedResultsController(NSFetchedResultsController with one-to-many relationship)

 依赖注入模式中工厂的目的是为另一个实例生成实例，而其他实例不需要知道如何生成它。 
 
 从本质上讲，“工厂”只是一个对象返回者：在调用时返回实例的东西。 
 
 这在更有能力的语言中更容易看到。 例如，在Python中，类是可调用的（没有new运算符），并且调用类会生成类的实例。 因此，如果类不需要参数，那么类可以是它们自己的工厂。 同样，任何返回实例的零参数函数都可以视为工厂。 这使得依赖注入非常清晰，并且没有样板。 
 
 在更严格的语言中（Java / C ++ / C＃静态类型传统，或者类或函数不像PHP那样完全是第一类），你需要隐藏“模式”背后的依赖注入，因为缺少“设计模式”语言功能 。 在PHP 5.3+中，您可以使用闭包作为工厂，或者您可以使用Java / C＃方式并为每个工厂定义FactoryInterface和新类。 
 
 例如，对于您的课程，您可以这样做： 
 
class Aprime extends A
{
    public function setSomeProperty($somePropertyFactory)
    {
        $this->_somePropertyObject = $somePropertyFactory();
    }
}
 
 在这个类中， setSomeProperty需要一个零参数可调用的“工厂”，你可以像这样产生： 
 
$other_dep_factory = function(){ return new SomeOtherClass(); };
 
 或者像这样： 
 
class ClassFactory {
    function __construct($classname, $args=array()) {
        $this->class = new ReflectionClass($classname);
        $this->args = $args;
    }

    function __invoke() {
        return $this->class->newInstanceArgs($this->args);
    }
}

$other_dep_factory = new ClassFactory('SomeOtherClass');
 
 在PHP 5.3之前，你需要像Java一样： 
 
interface IObjectFactory {
    function getObject();
}

// this B-and-D interface is optional
// it has no body because PHP doesn't support
// type-hinting return values
interface ISomeOtherClassFactory {}


class SomeOtherClassFactory implements ISomeOtherClassFactory {
    function getObject() {
        return new SomeOtherClass();
    }
}

class Aprime extends A
{
    public function setSomeProperty(ISomeOtherClassFactory $somePropertyFactory)
    {
        $this->_somePropertyObject = $somePropertyFactory->getObject();
    }
}


$other_dep_factory = new SomeOtherClassFactory();
$myAprimeObject->setSomeProperty($other_dep_factory);
 
 那么你什么时候使用工厂？ 每当一个对象需要创建另一个对象时。 如果对象只需要使用另一个对象，只需传入一个实例。 

The purpose of a factory in dependency injection patterns is to produce instances for another instance, without that other instance needing to know how to produce it.
 
At its core, a "factory" is just an object-returner: something that returns an instance when invoked.
 
This is easier to see in more capable languages. For example in Python classes are callable (there is no new operator), and invoking a class produces an instance of the class. So classes can be their own factories if the class requires no arguments. Likewise any zero-argument function that returns an instance can be considered a factory. This makes dependency injection very clear and free-of-boilerplate.
 
In more rigid languages (Java/C++/C# static-typed tradition, or where classes or functions are not completely first-class like in PHP), you need to obscure dependency injection behind a "pattern", because "design patterns" are missing language features. In PHP 5.3+ you can use a closure as a factory, or you can go the Java/C# way and define a FactoryInterface and a new class per factory.
 
For example, with your class, you could do this:
 
class Aprime extends A
{
    public function setSomeProperty($somePropertyFactory)
    {
        $this->_somePropertyObject = $somePropertyFactory();
    }
}
 
In this class, setSomeProperty requires a zero-argument callable "factory", which you could produce like this:
 
$other_dep_factory = function(){ return new SomeOtherClass(); };
 
Or like this:
 
class ClassFactory {
    function __construct($classname, $args=array()) {
        $this->class = new ReflectionClass($classname);
        $this->args = $args;
    }

    function __invoke() {
        return $this->class->newInstanceArgs($this->args);
    }
}

$other_dep_factory = new ClassFactory('SomeOtherClass');
 
Prior to PHP 5.3, you need to do it like Java would:
 
interface IObjectFactory {
    function getObject();
}

// this B-and-D interface is optional
// it has no body because PHP doesn't support
// type-hinting return values
interface ISomeOtherClassFactory {}


class SomeOtherClassFactory implements ISomeOtherClassFactory {
    function getObject() {
        return new SomeOtherClass();
    }
}

class Aprime extends A
{
    public function setSomeProperty(ISomeOtherClassFactory $somePropertyFactory)
    {
        $this->_somePropertyObject = $somePropertyFactory->getObject();
    }
}


$other_dep_factory = new SomeOtherClassFactory();
$myAprimeObject->setSomeProperty($other_dep_factory);
 
So when do you use a factory? Whenever an object needs to create another object. If the object just needs to use another object, just pass in an instance.