Ecco le risposte
perché una classe proxy viene utilizzata in quel caso particolare?
Se dai un'occhiata più da vicino al codice scritto per la classe "SetConversionValueObserver", se Google Adwards non è attivo "return" e se non vi è alcun ordine "return". Significa, l'oggetto Raccolta ordini verrà creato solo quando esistono ID ordine e Google AdWords attivo. se inseriamo la classe di raccolta ordini effettiva, il gestore oggetti crea l'oggetto di raccolta con i suoi oggetti della classe padre senza conoscere le parole d'ordine di Google non attive e rallentare la pagina di successo dell'ordine. quindi, meglio creare oggetto su richiesta che è l'uso del proxy. /vendor/magento/module-google-adwords/Observer/SetConversionValueObserver.php
/**
* Set base grand total of order to registry
*
* @param \Magento\Framework\Event\Observer $observer
* @return \Magento\GoogleAdwords\Observer\SetConversionValueObserver
*/
public function execute(\Magento\Framework\Event\Observer $observer)
{
if (!($this->_helper->isGoogleAdwordsActive() && $this->_helper->isDynamicConversionValue())) {
return $this;
}
$orderIds = $observer->getEvent()->getOrderIds();
if (!$orderIds || !is_array($orderIds)) {
return $this;
}
$this->_collection->addFieldToFilter('entity_id', ['in' => $orderIds]);
$conversionValue = 0;
/** @var $order \Magento\Sales\Model\Order */
foreach ($this->_collection as $order) {
$conversionValue += $order->getBaseGrandTotal();
}
$this->_registry->register(
\Magento\GoogleAdwords\Helper\Data::CONVERSION_VALUE_REGISTRY_NAME,
$conversionValue
);
return $this;
}
quando, in generale, si dovrebbe usare una classe proxy?
- Iniettare la classe proxy quando ritieni che la creazione di oggetti sia costosa e il costruttore della classe disponga di un uso intensivo di risorse. - quando non si desidera un impatto sulle prestazioni non necessario a causa della creazione di oggetti. - quando ritieni che la creazione di oggetti dovrebbe avvenire quando chiami un metodo particolare in una condizione particolare non sempre. Ad esempio, il costruttore del layout richiede molte risorse.
Costruttore layout effettivo vs layout / proxy
public function __construct(
Layout\ProcessorFactory $processorFactory,
ManagerInterface $eventManager,
Layout\Data\Structure $structure,
MessageManagerInterface $messageManager,
Design\Theme\ResolverInterface $themeResolver,
Layout\ReaderPool $readerPool,
Layout\GeneratorPool $generatorPool,
FrontendInterface $cache,
Layout\Reader\ContextFactory $readerContextFactory,
Layout\Generator\ContextFactory $generatorContextFactory,
AppState $appState,
Logger $logger,
$cacheable = true,
SerializerInterface $serializer = null
) {
$this->_elementClass = \Magento\Framework\View\Layout\Element::class;
$this->_renderingOutput = new \Magento\Framework\DataObject();
$this->serializer = $serializer ?: ObjectManager::getInstance()->get(SerializerInterface::class);
$this->_processorFactory = $processorFactory;
$this->_eventManager = $eventManager;
$this->structure = $structure;
$this->messageManager = $messageManager;
$this->themeResolver = $themeResolver;
$this->readerPool = $readerPool;
$this->generatorPool = $generatorPool;
$this->cacheable = $cacheable;
$this->cache = $cache;
$this->readerContextFactory = $readerContextFactory;
$this->generatorContextFactory = $generatorContextFactory;
$this->appState = $appState;
$this->logger = $logger;
}
Costruttore proxy, dai un'occhiata, nessun costruttore principale chiamato così come appena passato il nome della classe di layout in modo che la creazione effettiva dell'oggetto avvenga quando viene chiamato il metodo
/**
* Proxy constructor
*
* @param \Magento\Framework\ObjectManagerInterface $objectManager
* @param string $instanceName
* @param bool $shared
*/
public function __construct(
\Magento\Framework\ObjectManagerInterface $objectManager,
$instanceName = \Magento\Framework\View\Layout::class,
$shared = true
) {
$this->_objectManager = $objectManager;
$this->_instanceName = $instanceName;
$this->_isShared = $shared;
}
La classe proxy ha un metodo per creare oggetti su richiesta, _subject è l'oggetto della classe passata.
/**
* Get proxied instance
*
* @return \Magento\Framework\View\Layout
*/
protected function _getSubject()
{
if (!$this->_subject) {
$this->_subject = true === $this->_isShared
? $this->_objectManager->get($this->_instanceName)
: $this->_objectManager->create($this->_instanceName);
}
return $this->_subject;
}
E metodo chiamato usando _subject.
/**
* {@inheritdoc}
*/
public function setGeneratorPool(\Magento\Framework\View\Layout\GeneratorPool $generatorPool)
{
return $this->_getSubject()->setGeneratorPool($generatorPool);
}