{ "href": "/post/2015/07/07/a-factory-should-create-not-retain/", "relId": "2015/07/07/a-factory-should-create-not-retain", "title": "A Factory Should Create, Not Retain", "author": "pmjones", "markup": "html", "tags": [ { "href": "/tag/patterns/", "relId": "patterns", "title": "Patterns", "author": null, "created": null, "updated": [], "markup": "markdown" }, { "href": "/tag/php/", "relId": "php", "title": "PHP", "author": null, "created": null, "updated": [], "markup": "markdown" }, { "href": "/tag/programming/", "relId": "programming", "title": "Programming", "author": null, "created": null, "updated": [], "markup": "markdown" } ], "created": "2015-07-07 18:06:50 UTC", "updated": [ "2015-07-07 18:06:50 UTC" ], "html": "

In a recent Reddit conversation, some of us went off on a tangent about factories. I maintained then, and do now, that a \u201cfactory\u201d always-and-only returns a new instance. If you have a \u201cfactory\u201d that returns anything other than a new instance, it\u2019s not a factory alone. In the case of factory methods, it is a factory + accessor; in the case of factory objects, it is a factory + registry.

\n

A \u201cfactory\u201d (whether a factory method or factory object) is one way to separate object creation from object use.

\n

Let\u2019s say we need to create an object to do some work in a class method:

\n
class Example\n{\n    public function __construct($db)\n    {\n        $this->db = $db;\n    }\n\n    public function doSomething($itemId)\n    {\n        $data = $this->db->fetchOne(\n            \"SELECT * FROM items WHERE id = :id\",\n            ['id' => $itemId]\n        );\n        $item = new Item($data);\n\n        // do some other work with the item,\n        // the return the results of that work.\n        return $results;\n    }\n}\n
\n

The item creation is mixed in with the use of the item. What we want to do is separate the creation from the usage. One way to do that is to use a factory method, or a factory object, to handle object creation for us. Here\u2019s an example of a factory method:

\n
class Example\n{\n    public function __construct($db)\n    {\n        $this->db = $db;\n    }\n\n    public function doSomething($itemId)\n    {\n        $data = $this->db->fetchOne(\n            \"SELECT * FROM items WHERE id = ?\",\n            ['id' => $id]\n        );\n        $item = $this->item($itemId);\n\n        // do some other work with the item,\n        // the return the results of that work.\n        return $results;\n    }\n\n    public function item($data) // factory method\n    {\n        return new Item($data);\n    }\n}\n
\n

Here\u2019s an example of an injected factory object:

\n
class Example\n{\n    public function __construct($db, $factory)\n    {\n        $this->db = $db;\n        $this->factory = $factory;\n    }\n\n    public function doSomethingWithItem($id)\n    {\n        $data = $this->db->fetchOne(\n            \"SELECT * FROM items WHERE id = ?\",\n            ['id' => $id]\n        );\n        $item = $this->factory->item($data);\n\n        // do some other work with the item,\n        // the return the results of that work.\n        return $results;\n    }\n}\n\nclass Factory // factory object\n{\n    public function item($data) // factory method\n    {\n        return new Item($data);\n    }\n}\n
\n

There were some folks in the Reddit thread that believe a factory may additionally retain the created instance for reuse. For example, let\u2019s say we create and the reuse a collaborator object of some sort:

\n
class Example\n{\n    public function doSomething()\n    {\n        $collab = $this->collab();\n        // do stuff, then:\n        return $result;\n    }\n\n    protected function collab() // factory method?\n    {\n        if (! $this->collab) {\n            $this->collab = new Collab();\n        }\n        return $this->collab;\n    }\n}\n
\n

As far as I can tell, that\u2019s not just a factory. There are three things going on there: initializing a property, creating an object, and accessing a property. To split the concerns, one would need two methods:

\n
class Example\n{\n    public function doSomething()\n    {\n        $collab = $this->getCollab();\n        // do stuff, then:\n        return $result;\n    }\n\n    protected function getCollab() // initialize + access\n    {\n        if (! $this->collab) {\n            $this->collab = $this->newCollab();\n        }\n        return $this->collab;\n    }\n\n    protected function newCollab() // factory\n    {\n        return new Collab();\n    }\n}\n
\n

Now the concern of creating the object is represented by newCollab() method, and the concerns of initializing and accessing the property are represented by the getCollab() method. Indeed, splitting out a factory method in this kind of situation is the exact recommendation in the GOF Design Patterns book on page 113; this is the book that defined the term \"factory method\" in the first place, so it seems authoritative on this point.

\n

What happens when you add retention to what would otherwise be a factory object? For example, is the following only a factory object, or does it do more than just create and return new instances?

\n
class WhatIsThatThing\n{\n    public function getService()\n    {\n        if (! $this->service) {\n            $this->service = $this->newService();\n        }\n        return $this->service;\n    }\n\n    public function newService()\n    {\n        return new Service();\n    }\n}\n
\n

It both creates objects, and retains the created objects. That makes it more than just a factory; it looks more like a container at this point.

\n

Finally, regarding method names, it seems like it\u2019s best to indicate what to expect as a return result. I default to newInstance() in factory objects that deal with only a single class, and new<Type>() when the factory object creates many different classes. Using get<Type>() indicates that a pre-existing instance (probably memoized in a property) is being returned.

\n
\n

Read the Reddit discussion about this post here.

\n" }