Click here for real example video
What is Factory
class in Magento 2
Overview
Factory classes are service class that instantiate
non-injectable classes, that is, models that represent a database entity.
They create a layer of abstraction between the ObjectManager and
business code.
Relationship to ObjectManager
The Magento\Framework\ObjectManager is the class responsible for instantiating objects in
the Magento application. Magento prohibits depending on and directly using
the ObjectManager in
your code.
Factories are an exception to this rule because
they require the ObjectManager to instantiate specific models.
The following example illustrates the relationship between a
simple factory and the ObjectManager:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
namespace Magento\Framework\App\Config; class BaseFactory { /** * @var
\Magento\Framework\ObjectManagerInterface */ protected $_objectManager; /** * @param
\Magento\Framework\ObjectManagerInterface $objectManager */ public function __construct(\Magento\Framework\ObjectManagerInterface $objectManager) { $this->_objectManager = $objectManager; } /** * Create config model * @param
string|\Magento\Framework\Simplexml\Element $sourceData * @return
\Magento\Framework\App\Config\Base */ public function create($sourceData = null) { return $this->_objectManager->create(\Magento\Framework\App\Config\Base::class, ['sourceData' => $sourceData]); } } |
Writing factories
Unless you require specific behavior for your factory
classes, you do not need to explicitly define them because they are an automatically generated class type. When you
reference a factory in a class constructor, Magento’s object manager generates the factory class
if it does not exist.
Factories follow the naming convention <class-type>Factory where <class-type> is
the name of the class the factory instantiates.
For example the automatically generated Magento\Cms\Model\BlockFactory class
is a factory that instantiates the class Magento\Cms\Model\Block.
Using factories
You can get the singleton instance of a factory for a
specific model using dependency injection.
The following example shows a class getting the BlockFactory instance
through the constructor:
|
1 2 3 |
function __construct ( \Magento\Cms\Model\BlockFactory $blockFactory)
{ $this->blockFactory = $blockFactory; } |
Calling the create() method on a factory gives you
an instance of its specific class:
|
1 |
$block
= $this->blockFactory->create(); |
For classes that
require parameters, the automatically generated create() function accepts an array of
parameters that it passes on to the ObjectManager to create the target class.
The example below shows the construction of a \Magento\Framework\FlagFactory object
by passing in an array of parameters to a factory:
|
1 2 |
$flag
= $this->flagFactory->create([
'data' => ['flag_code' =>
'something'] |
The Flag class has a $data constructor parameter which
corresponds to the data key in the create array above.
Interfaces
Factories are smart enough to resolve dependencies and allow
you to get the correct instance of an interface as defined in your
module’s di.xml.
For example, in the CatalogInventory module,
the di.xml file
contains the following entry:
|
1 |
<preference for="Magento\CatalogInventory\Api\Data\StockItemInterface" type="Magento\CatalogInventory\Model\Stock\Item" /> |
It instructs Magento to
use the specific Item class wherever
the StockItemInterface is
used. When a class in that module includes the factory StockItemInterfaceFactory as
a dependency, Magento generates a factory that is capable of creating the
specific Item objects.
