Magento Enterprise: फुल पेज कैश क्या है और इसकी आवश्यकता क्यों है

Magento Enterprise: फुल पेज कैश क्या है और इसकी आवश्यकता क्यों है।

जो लोग Magento से परिचित हैं, उनके लिए यह कोई रहस्य नहीं है कि यह ई-कॉमर्स इंजन हार्डवेयर की काफी मांग है। लेकिन इस ऑनलाइन स्टोर के डेवलपर्स ने इस समस्या को हल करने की कोशिश की और कई अलग-अलग प्रकार के "त्वरक" के साथ आए, जिसके बिना, शायद, उत्पादन में मैगेंटो इंजन पर एक स्टोर लॉन्च करना इसके लायक नहीं है। बहुत लंबे समय तक, Magento पृष्ठ को अंतिम उपयोगकर्ता को सौंप देगा। ऐसे "त्वरक" में कैश, इंडेक्स, संकलन, जेएस / सीएसएस को एक संपीड़ित फ़ाइल में संयोजित करना, आदि हैं।

Magento Enterprise के मुख्य "ट्रिक" में से एक फुल पेज कैश (इसके बाद FPC) है। यह "ट्रिक" Enterprise_PageCache मॉड्यूल द्वारा कार्यान्वित किया गया है, जो Magento Enterprise पैकेज का हिस्सा है।

लेख लिखने के समय मैगेंटो एंटरप्राइज के नवीनतम संस्करण पर चर्चा करता है: 1.13.1।

एफपीसी आपको मिलिसेकंड के मामले में सर्वर को पेज देने की अनुमति देता है, व्यावहारिक रूप से सर्वर को लोड किए बिना। मैंने सर्वर द्वारा रेंडर करने के लिए उत्पाद पृष्ठ के लिए समय का माप लिया था (जिन परियोजनाओं में मैं काम कर रहा था उनमें से एक में), यहां परिणाम हैं:

• 65 एमएस एफपीसी सक्षम (जब सभी ब्लॉक कैश किए गए हैं) के साथ;
• 1250 एमएस जब एफपीसी बंद है (जबकि अन्य सभी प्रकार के कैश सक्षम हैं);
• सभी प्रकार के कैश के साथ 2500 एमएस अक्षम।

अंतर इतना बड़ा क्यों है? चलिए इसका पता लगाते हैं।

एफपीसी कैश क्या और कब करता है

जैसा कि नाम से पता चलता है, फुल पेज कैश पूरे पेज को कैश करता है। लेकिन सभी पेज कैश नहीं होते हैं। कम से कम क्योंकि इसका कोई मतलब नहीं है। डिफ़ॉल्ट रूप से, केवल उत्पाद पृष्ठ, श्रेणी पृष्ठ, CMS पृष्ठ और 404 त्रुटियों वाले पृष्ठ को कैश किया जाता है (पृष्ठ नहीं मिला)। आप मॉड्यूल कॉन्फ़िगरेशन (config.xml) को देखकर इसे सत्यापित कर सकते हैं:

<frontend> <cache> <requests> <_no_route>enterprise_pagecache/processor_noroute</_no_route> <cms>enterprise_pagecache/processor_default</cms> <catalog> <category> <view>enterprise_pagecache/processor_category</view> </category> </catalog> <catalog> <product> <view>enterprise_pagecache/processor_product</view> </product> </catalog> </requests> </cache> </frontend> 

फ्रंटेंड / कैश / रिक्वेस्ट सेक्शन में, मॉड्यूल कंट्रोलर का फ्रंटनेम यहाँ निर्दिष्ट किया गया है (इसका मान पथ के साथ मॉड्यूल कॉन्फिगर में संग्रहीत है: फ्रंटेंड / राउटर / रूट_नाम / आर्ग्स / फ्रंटनेम), फिर कंट्रोलर और एक्शन (कंट्रोलर और एक्शन वैकल्पिक पैरामीटर हैं)। और प्रेषित मूल्य अनुरोध (अनुरोध) प्रोसेसर है।

आप अपने मॉड्यूल के नियंत्रकों / नियंत्रक / कार्रवाई को उसी तरह कैश करने के लिए बाध्य कर सकते हैं, जिस तरह से Enterprise_PageCache मॉड्यूल करता है, उसी तरह वांछित अनुभाग में डेटा जोड़ें। एक उदाहरण:

 <frontend> <cache> <requests> <productinfo> <index>enterprise_pagecache/processor_default</index> </productinfo> </requests> </cache> </frontend> 

ऐसी कई स्थितियाँ हैं जिनके अंतर्गत FPC पृष्ठों को कैश नहीं करती है। उदाहरण के लिए, HTTPS पृष्ठ, no_cache GET पैरामीटर वाले पृष्ठ कैश नहीं किए गए हैं। CanProcessRequest और Enterprise_PageCache_Model_Processor वर्ग के अलग-अलग तरीके:

 /** * Do basic validation for request to be cached * * @param Zend_Controller_Request_Http $request * @return bool */ public function canProcessRequest(Zend_Controller_Request_Http $request) { $res = $this->isAllowed(); $res = $res && Mage::app()->useCache('full_page'); if ($request->getParam('no_cache')) { $res = false; } if ($res) { $maxDepth = Mage::getStoreConfig(self::XML_PATH_ALLOWED_DEPTH); $queryParams = $request->getQuery(); unset($queryParams[Enterprise_PageCache_Model_Cache::REQUEST_MESSAGE_GET_PARAM]); $res = count($queryParams)<=$maxDepth; } if ($res) { $multicurrency = Mage::getStoreConfig(self::XML_PATH_CACHE_MULTICURRENCY); if (!$multicurrency && !empty($_COOKIE['currency'])) { $res = false; } } return $res; } 

 /** * Check if processor is allowed for current HTTP request. * Disable processing HTTPS requests and requests with "NO_CACHE" cookie * * @return bool */ public function isAllowed() { if (!$this->_requestId) { return false; } if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') { return false; } if (isset($_COOKIE['NO_CACHE'])) { return false; } if (isset($_GET['no_cache'])) { return false; } if (isset($_GET[Mage_Core_Model_Session_Abstract::SESSION_ID_QUERY_PARAM])) { return false; } if (!Mage::app()->useCache('full_page')) { return false; } return true; } 

FPC कैसे काम करती है?

यदि पृष्ठ FPC कैश के साथ कैश किया गया है, तो FPC मानक ब्लॉक कैश अक्षम करता है। Enterprise_PageCache_Model_Observer वर्ग की प्रक्रियाप्रदर्शन विधि देखें, जो तब घटित होती है जब घटना (घटना) कंट्रोलर_अप्रेशन_प्रदर्शनी घटना घटित होती है:

 /** * Check when cache should be disabled * * @param Varien_Event_Observer $observer * @return Enterprise_PageCache_Model_Observer */ public function processPreDispatch(Varien_Event_Observer $observer) { if (!$this->isCacheEnabled()) { return $this; } $action = $observer->getEvent()->getControllerAction(); /* @var $request Mage_Core_Controller_Request_Http */ $request = $action->getRequest(); $noCache = $this->_getCookie()->get(Enterprise_PageCache_Model_Processor::NO_CACHE_COOKIE); if ($noCache) { Mage::getSingleton('catalog/session')->setParamsMemorizeDisabled(false); $this->_getCookie()->renew(Enterprise_PageCache_Model_Processor::NO_CACHE_COOKIE); } elseif ($action) { Mage::getSingleton('catalog/session')->setParamsMemorizeDisabled(true); } /** * Check if request will be cached */ if ($this->_processor->canProcessRequest($request)) { Mage::app()->getCacheInstance()->banUse(Mage_Core_Block_Abstract::CACHE_GROUP); } $this->_getCookie()->updateCustomerCookies(); return $this; } 

प्रत्येक HTTP अनुरोध के लिए, एफपीसी अपना कैश पहचानकर्ता उत्पन्न करता है, जिसका उपयोग कैश में पेज को बचाने के लिए किया जाएगा। कैश पहचानकर्ता कई मापदंडों पर निर्भर करता है: कस्टम मीटर अधिकृत है या नहीं, यह किस सेगमेंट के अंतर्गत आता है, उपयोगकर्ताओं के किस समूह से संबंधित है, आदि। आप देख सकते हैं कि यह पहचान कैसे एंटरप्राइज़ के _createRequestIds पद्धति में उत्पन्न हुई है। PageCache_Model_Processor वर्ग:

 /** * Populate request ids * @return Enterprise_PageCache_Model_Processor */ protected function _createRequestIds() { $uri = $this->_getFullPageUrl(); //Removing get params $pieces = explode('?', $uri); $uri = array_shift($pieces); /** * Define COOKIE state */ if ($uri) { if (isset($_COOKIE['store'])) { $uri = $uri.'_'.$_COOKIE['store']; } if (isset($_COOKIE['currency'])) { $uri = $uri.'_'.$_COOKIE['currency']; } if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_GROUP])) { $uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_GROUP]; } if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_LOGGED_IN])) { $uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_LOGGED_IN]; } if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::CUSTOMER_SEGMENT_IDS])) { $uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::CUSTOMER_SEGMENT_IDS]; } if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::IS_USER_ALLOWED_SAVE_COOKIE])) { $uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::IS_USER_ALLOWED_SAVE_COOKIE]; } $designPackage = $this->_getDesignPackage(); if ($designPackage) { $uri .= '_' . $designPackage; } } $this->_requestId = $uri; $this->_requestCacheId = $this->prepareCacheId($this->_requestId); return $this; } 

एफपीसी प्लेसहोल्डर्स का उपयोग करता है। वे मॉड्यूल के आदि फ़ोल्डर में cache.xml कॉन्फ़िगरेशन फ़ाइल का उपयोग करके Magento में जोड़े जाते हैं। और प्लेसहोल्डर को प्लेसहोल्डर के कंटेनर द्वारा संसाधित किया जाता है। एक कंटेनर एक वर्ग है जिसे एक प्लेसहोल्डर FPC रेंडरिंग के दौरान प्रोसेस करेगा (एक FPC कैश के साथ ब्लॉक रेंडर करने की प्रक्रिया एक ब्लॉक के सामान्य रेंडरिंग से अलग है)। उदाहरण cache.xml फ़ाइल:

 <?xml version="1.0" encoding="UTF-8"?> <config> <placeholders> <turnkeye_popup> <block>turnkeye_popup/popup</block> <placeholder>POPUP</placeholder> <container>Turnkeye_Popup_Model_PageCache_Container_Popup</container> <cache_lifetime>86400</cache_lifetime> </turnkeye_popup> </placeholders> </config> 

प्लेसहोल्डर के कॉन्फ़िगरेशन के बारे में संक्षेप में:

• ब्लॉक - ब्लॉक का प्रकार या वर्ग
• प्लेसहोल्डर - प्लेसहोल्डर नाम
• कंटेनर - प्लेसहोल्डर कंटेनर का प्रकार या वर्ग
• कैश_लाइफटाइम - कैश लाइफटाइम

रेंडरिंग के दौरान, जब FPC सक्षम होती है, तो प्रत्येक ब्लॉक की सामग्री प्लेसहोल्डर और कैश्ड द्वारा लपेटी जाती है: जब core_block_abameter_to_html_after घटना को निकाल दिया जाता है, तो Enterprise_ageCache_Model_Observer वर्ग के रेंडरब्लॉकप्लेहोल्डर विधि को निष्पादित किया जाता है:

 /** * Render placeholder tags around the block if needed * * @param Varien_Event_Observer $observer * @return Enterprise_PageCache_Model_Observer */ public function renderBlockPlaceholder(Varien_Event_Observer $observer) { if (!$this->_isEnabled) { return $this; } $block = $observer->getEvent()->getBlock(); $transport = $observer->getEvent()->getTransport(); $placeholder = $this->_config->getBlockPlaceholder($block); if ($transport && $placeholder && !$block->getSkipRenderTag()) { $blockHtml = $transport->getHtml(); $request = Mage::app()->getFrontController()->getRequest(); /** @var $processor Enterprise_PageCache_Model_Processor_Default */ $processor = $this->_processor->getRequestProcessor($request); if ($processor && $processor->allowCache($request)) { $container = $placeholder->getContainerClass(); if ($container && !Mage::getIsDeveloperMode()) { $container = new $container($placeholder); $container->setProcessor(Mage::getSingleton('enterprise_pagecache/processor')); $container->setPlaceholderBlock($block); $container->saveCache($blockHtml); } } $blockHtml = $placeholder->getStartTag() . $blockHtml . $placeholder->getEndTag(); $transport->setHtml($blockHtml); } return $this; } 

यहाँ $ प्लेसहोल्डर का उपयोग कर प्राप्त किया जा रहा है Enterprise_PageCache_Model_Config getBlockPlaceholder विधि द्वारा:

 /** * Create placeholder object based on block information * * @param Mage_Core_Block_Abstract $block * @return Enterprise_PageCache_Model_Container_Placeholder */ public function getBlockPlaceholder($block) { $this->_initPlaceholders(); $type = $block->getType(); if (isset($this->_placeholders[$type])) { $placeholderData = false; foreach ($this->_placeholders[$type] as $placeholderInfo) { if (!empty($placeholderInfo['name'])) { if ($placeholderInfo['name'] == $block->getNameInLayout()) { $placeholderData = $placeholderInfo; } } else { $placeholderData = $placeholderInfo; } } if (!$placeholderData) { return false; } $placeholder = $placeholderData['code'] . ' container="' . $placeholderData['container'] . '"' . ' block="' . get_class($block) . '"'; $placeholder.= ' cache_id="' . $block->getCacheKey() . '"'; if (!empty($placeholderData['cache_lifetime'])) { $placeholder .= ' cache_lifetime="' . $placeholderData['cache_lifetime'] . '"'; } foreach ($block->getCacheKeyInfo() as $k => $v) { if (is_string($k) && !empty($k)) { $placeholder .= ' ' . $k . '="' . $v . '"'; } } $placeholder = Mage::getModel('enterprise_pagecache/container_placeholder', $placeholder); return $placeholder; } return false; } 

Enterprise_PageCache_Model_Container_Placeholder वर्ग का निर्माता:

 /** * Class constructor. * Initialize placeholder name and attributes based on definition * * @param string $definition */ public function __construct($definition) { if ($definition && array_key_exists($definition, self::$_definitionMap)) { $definition = self::$_definitionMap[$definition]; } $this->_definition = $definition; $definition = explode(' ', $definition); $this->_name = $definition[0]; $count = count($definition); if ($count>1) { for ($i=1; $i_attributes[$info[0]] = isset($info[1]) ? trim($info[1], '"\'') : null; } } } 

भविष्य में, कंटेनर क्लास में गेटएट्रिब्यूट विधि का उपयोग करके ब्लॉक विशेषताओं को प्राप्त करना संभव होगा:

 /** * Get attribute by specific code * @param $code string * @return string */ public function getAttribute($code) { return isset($this->_attributes[$code]) ? $this->_attributes[$code] : null; } 

सामग्री ब्लॉक में प्लेसहोल्डर को लपेटने के तरीके:

 /** * Retrieve placeholder definition hash * * @return string */ protected function _getDefinitionHash() { $definition = $this->getDefinition(); $result = array_search($definition, self::$_definitionMap); if ($result === false) { $result = $this->getName() . '_' . md5($definition); self::$_definitionMap[$result] = $definition; } return $result; } /** * Get placeholder start tag for block html generation * * @return string */ public function getStartTag() { return '<!--{' . $this->_getDefinitionHash() . '}-->'; } /** * Get placeholder end tag for block html generation * * @return string */ public function getEndTag() { return '<!--/{' . $this->_getDefinitionHash() . '}-->'; } 

ब्लॉक सामग्री लपेटने वाले प्लेसहोल्डर का एक उदाहरण:

 < !--{TOPMENU_21c7f778e21d072d331836703b6295f5}--> < div class="nav-container"> < ul id="nav"> < li class="level0 nav-1 first last level-top"> < a class="level-top" href="http://example.com/test-category.html"> < span>Test category</span> </a> </li> </ul> </div> < !--/{TOPMENU_21c7f778e21d072d331836703b6295f5}--> 

अनुरोध पर प्रतिक्रिया भेजने से पहले, कंट्रोलर_फ्रंट_सेंड_रस्पॉन्स_बेफर्स इवेंट उठाया जाता है और एंटरप्राइज_पेजेज_मॉडल_ऑब्जर्वर क्लास की कैश रीसेंट विधि को अंजाम दिया जाता है, जो आवश्यक होने पर कैश में पेज को बचाता है। CacheResponse विधि कोड:

 /** * Save page body to cache storage * * @param Varien_Event_Observer $observer * @return Enterprise_PageCache_Model_Observer */ public function cacheResponse(Varien_Event_Observer $observer) { if (!$this->isCacheEnabled()) { return $this; } $frontController = $observer->getEvent()->getFront(); $request = $frontController->getRequest(); $response = $frontController->getResponse(); $this->_saveDesignException(); $this->_processor->processRequestResponse($request, $response); return $this; } 

यदि आवश्यक हो, तो यहां प्रक्रियाप्रकाशात्मक विधि पूरे पृष्ठ और आवश्यक डेटा को कैश में सहेजती है:

 /** * Process response body by specific request * * @param Zend_Controller_Request_Http $request * @param Zend_Controller_Response_Http $response * @return Enterprise_PageCache_Model_Processor */ public function processRequestResponse(Zend_Controller_Request_Http $request, Zend_Controller_Response_Http $response ) { // we should add original path info tag as another way we can't drop some entities from cron job $this->addRequestTag(Enterprise_PageCache_Helper_Url::prepareRequestPathTag($request->getOriginalPathInfo())); $cacheInstance = Enterprise_PageCache_Model_Cache::getCacheInstance(); /** * Basic validation for request processing */ if ($this->canProcessRequest($request)) { $processor = $this->getRequestProcessor($request); if ($processor && $processor->allowCache($request)) { $this->setMetadata('cache_subprocessor', get_class($processor)); $cacheId = $this->prepareCacheId($processor->getPageIdInApp($this)); $content = $processor->prepareContent($response); /** * Replace all occurrences of session_id with unique marker */ Enterprise_PageCache_Helper_Url::replaceSid($content); Enterprise_PageCache_Helper_Form_Key::replaceFormKey($content); if (function_exists('gzcompress')) { $content = gzcompress($content); } $contentSize = strlen($content); $currentStorageSize = (int) $cacheInstance->load(self::CACHE_SIZE_KEY); if (Mage::getStoreConfig(Enterprise_PageCache_Model_Processor::XML_PATH_CACHE_DEBUG)) { $response->setBody(implode(', ', $this->getRequestTags()) . $response->getBody()); } $maxSizeInBytes = Mage::getStoreConfig(self::XML_PATH_CACHE_MAX_SIZE) * 1024 * 1024; if ($currentStorageSize >= $maxSizeInBytes) { Mage::app()->getCacheInstance()->invalidateType('full_page'); return $this; } $cacheInstance->save($content, $cacheId, $this->getRequestTags()); $cacheInstance->save( $currentStorageSize + $contentSize, self::CACHE_SIZE_KEY, $this->getRequestTags() ); /* * Save design change in cache */ $designChange = Mage::getSingleton('core/design'); if ($designChange->getData()) { $cacheInstance->save( serialize($designChange->getData()), $this->getRequestCacheId() . self::DESIGN_CHANGE_CACHE_SUFFIX, $this->getRequestTags() ); } // save response headers $this->setMetadata('response_headers', $response->getHeaders()); // save original routing info $this->setMetadata('routing_aliases', Mage::app()->getRequest()->getAliases()); $this->setMetadata('routing_requested_route', Mage::app()->getRequest()->getRequestedRouteName()); $this->setMetadata('routing_requested_controller', Mage::app()->getRequest()->getRequestedControllerName()); $this->setMetadata('routing_requested_action', Mage::app()->getRequest()->getRequestedActionName()); $this->setMetadata('sid_cookie_name', Mage::getSingleton('core/session')->getSessionName()); Mage::dispatchEvent('pagecache_processor_metadata_before_save', array('processor' => $this)); $this->_saveMetadata(); } if (isset($_GET[Mage_Core_Model_Session_Abstract::SESSION_ID_QUERY_PARAM])) { Mage::getSingleton('enterprise_pagecache/cookie')->updateCustomerCookies(); Mage::getModel('enterprise_pagecache/observer')->updateCustomerProductIndex(); } } return $this; } 

यहां, एक बहुत महत्वपूर्ण बिंदु यह है कि पृष्ठ कैश को सहेजने से पहले, प्लेसहोल्डर के साथ ब्लॉक की सामग्री को ब्लॉक के विवरण के साथ बदल दिया जाता है: $ सामग्री = $ प्रोसेसर-> तैयारकंटेंट ($ प्रतिक्रिया); तैयार विधि:

 /** * Prepare response body before caching * * @param Zend_Controller_Response_Http $response * @return string */ public function prepareContent(Zend_Controller_Response_Http $response) { return $this->replaceContentToPlaceholderReplacer($response->getBody()); } 

प्रतिस्थापनकंटपूलर धारकपुलिस विधि:

 /** * Replace block content to placeholder replacer * * @param string $content * @return string */ public function replaceContentToPlaceholderReplacer($content) { $placeholders = array(); preg_match_all( Enterprise_PageCache_Model_Container_Placeholder::HTML_NAME_PATTERN, $content, $placeholders, PREG_PATTERN_ORDER ); $placeholders = array_unique($placeholders[1]); try { foreach ($placeholders as $definition) { $this->_placeholder = Mage::getModel('enterprise_pagecache/container_placeholder', $definition); $content = preg_replace_callback($this->_placeholder->getPattern(), array($this, '_getPlaceholderReplacer'), $content); } $this->_placeholder = null; } catch (Exception $e) { $this->_placeholder = null; throw $e; } return $content; } 

परिणामस्वरूप, पृष्ठ कैश में ब्लॉक की सामग्री के बजाय ब्लॉक के बारे में जानकारी होगी। यह जानकारी भविष्य में ब्लॉक को रेंडर करने में मदद करेगी। इस तरह की जानकारी का एक उदाहरण यहां दिया गया है कि FPC अपने रेंडरिंग के दौरान ब्लॉक की सामग्री से बदलेगी:

 < !--{POPUP container="Turnkeye_Popup_Model_PageCache_Container_Popup" block="Turnkeye_Popup_Block_Popup" cache_id="c3b32091a1ebd3b276a8fd70496a8e6da20865d0" cache_lifetime="86400" template="turnkeye/popup/popup.phtml" handles="a:2:{i:0;s:15:"cms_index_index";i:1;s:8:"cms_page";}" customer_segment_ids="a:1:{i:0;i:0;}" popup_ids="a:1:{i:0;s:1:"1";}" excluded_popup_ids="a:1:{i:0;i:1;}"}--> 

अगली बार जब यह पृष्ठ लोड होगा, तो Magento इस पृष्ठ को कैश से लोड करेगा (एंटरप्राइज़_पेजकॉच_मॉडल_प्रोसेसर वर्ग का एक्सट्रैक्ट विधि) देखें। यदि कैश खाली है, तो सामान्य रेंडर मैगेंटो आरंभीकरण के साथ है (जैसे कि कोई एफपीसी नहीं था) और फिर पेज कैश में सहेजा गया। यदि पेज कैश में है, तो एफपीसी इस कैश से सामग्री को संसाधित करेगा।

_ProcessContent और _processContainers एंटरप्राइज के तरीके_पेज Cache_Model_Processor वर्ग:

 /** * Determine and process all defined containers. * Direct request to pagecache/request/process action if necessary for additional processing * * @param string $content * @return string|false */ protected function _processContent($content) { $containers = $this->_processContainers($content); $isProcessed = empty($containers); // renew session cookie $sessionInfo = Enterprise_PageCache_Model_Cache::getCacheInstance()->load($this->getSessionInfoCacheId()); if ($sessionInfo) { $sessionInfo = unserialize($sessionInfo); foreach ($sessionInfo as $cookieName => $cookieInfo) { if (isset($_COOKIE[$cookieName]) && isset($cookieInfo['lifetime']) && isset($cookieInfo['path']) && isset($cookieInfo['domain']) && isset($cookieInfo['secure']) && isset($cookieInfo['httponly']) ) { $lifeTime = (0 == $cookieInfo['lifetime']) ? 0 : time() + $cookieInfo['lifetime']; setcookie($cookieName, $_COOKIE[$cookieName], $lifeTime, $cookieInfo['path'], $cookieInfo['domain'], $cookieInfo['secure'], $cookieInfo['httponly'] ); } } } else { $isProcessed = false; } if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_FORM_KEY])) { $formKey = $_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_FORM_KEY]; } else { $formKey = Enterprise_PageCache_Helper_Data::getRandomString(16); Enterprise_PageCache_Model_Cookie::setFormKeyCookieValue($formKey); } Enterprise_PageCache_Helper_Form_Key::restoreFormKey($content, $formKey); /** * restore session_id in content whether content is completely processed or not */ $sidCookieName = $this->getMetadata('sid_cookie_name'); $sidCookieValue = $sidCookieName && isset($_COOKIE[$sidCookieName]) ? $_COOKIE[$sidCookieName] : ''; // XSS vulnerability protection provided by htmlspcialchars call - escape & " ' < > chars Enterprise_PageCache_Helper_Url::restoreSid($content, htmlspecialchars($sidCookieValue, ENT_QUOTES)); if ($isProcessed) { return $content; } else { Mage::register('cached_page_content', $content); Mage::register('cached_page_containers', $containers); Mage::app()->getRequest() ->setModuleName('pagecache') ->setControllerName('request') ->setActionName('process') ->isStraight(true); // restore original routing info $routingInfo = array( 'aliases' => $this->getMetadata('routing_aliases'), 'requested_route' => $this->getMetadata('routing_requested_route'), 'requested_controller' => $this->getMetadata('routing_requested_controller'), 'requested_action' => $this->getMetadata('routing_requested_action') ); Mage::app()->getRequest()->setRoutingInfo($routingInfo); return false; } } 

 /** * Process Containers * * @param $content * @return array */ protected function _processContainers(&$content) { $placeholders = array(); preg_match_all( Enterprise_PageCache_Model_Container_Placeholder::HTML_NAME_PATTERN, $content, $placeholders, PREG_PATTERN_ORDER ); $placeholders = array_unique($placeholders[1]); $containers = array(); foreach ($placeholders as $definition) { $placeholder = new Enterprise_PageCache_Model_Container_Placeholder($definition); $container = $placeholder->getContainerClass(); if (!$container) { continue; } $container = new $container($placeholder); $container->setProcessor($this); if (!$container->applyWithoutApp($content)) { $containers[] = $container; } else { preg_match($placeholder->getPattern(), $content, $matches); if (array_key_exists(1,$matches)) { $containers = array_merge($this->_processContainers($matches[1]), $containers); $content = preg_replace($placeholder->getPattern(), str_replace('$', '\\$', $matches[1]), $content); } } } return $containers; } 

जैसा कि आप इन विधियों के कोड से देख सकते हैं, केवल वे ब्लॉक जिनके पास प्लेसहोल्डर हैं वे संसाधित होते हैं। यदि आपके ब्लॉक के लिए कोई प्लेसहोल्डर नहीं है, तो इसकी सामग्री नहीं बदली जाएगी। इसलिए, यदि आप गतिशील रूप से बदलते ब्लॉक प्रदर्शित करना चाहते हैं, तो आपको उनके लिए प्लेसहोल्डर बनाने की आवश्यकता है।

प्लेसहोल्डर कंटेनरों को पहले applyWithoutApp विधि द्वारा नियंत्रित किया जाता है। यह विधि कैश की गई सामग्री में ब्लॉक की सामग्री को हमारे द्वारा आवश्यक सामग्री से बदलने की कोशिश करती है। ApplicationWithoutApp विधि का एक उदाहरण, Enterprise_PageCache_Model_Container_Abstract वर्ग के सभी कंटेनरों के लिए सार:

 /** * Generate placeholder content before application was initialized and apply to page content if possible * * @param string $content * @return bool */ public function applyWithoutApp(&$content) { $cacheId = $this->_getCacheId(); if ($cacheId === false) { $this->_applyToContent($content, ''); return true; } $block = $this->_loadCache($cacheId); if ($block === false) { return false; } $block = Enterprise_PageCache_Helper_Url::replaceUenc($block); $this->_applyToContent($content, $block); return true; } 

कोड से यह स्पष्ट है कि यदि आप ब्लॉक को गतिशील रूप से बदलना चाहते हैं, तो आपको अपने ब्लॉक के तर्क के आधार पर कंटेनर का तरीका _getCacheId निर्धारित करना होगा। यदि कम से कम एक कंटेनर को संसाधित नहीं किया गया है (applyWithoutApp झूठे वापस आ गया है), तो इसे रेंडर किया जाना चाहिए (एंटरप्राइज़_पेजकॉच_मॉडल_प्रोसेसर वर्ग के _processContent विधि देखें), और Magento को प्रारंभ किया जाएगा (Mage :: app () निष्पादित किया जाएगा)। इस स्थिति में, अनुरोध प्रक्रिया कार्रवाई के साथ Enterprise_PageCache_RequestController नियंत्रक द्वारा संसाधित किया जाता है। प्रक्रिया के लिए क्रिया कोड:

 /** * Request processing action */ public function processAction() { $processor = Mage::getSingleton('enterprise_pagecache/processor'); $content = Mage::registry('cached_page_content'); $containers = Mage::registry('cached_page_containers'); $cacheInstance = Enterprise_PageCache_Model_Cache::getCacheInstance(); foreach ($containers as $container) { $container->applyInApp($content); } $this->getResponse()->appendBody($content); // save session cookie lifetime info $cacheId = $processor->getSessionInfoCacheId(); $sessionInfo = $cacheInstance->load($cacheId); if ($sessionInfo) { $sessionInfo = unserialize($sessionInfo); } else { $sessionInfo = array(); } $session = Mage::getSingleton('core/session'); $cookieName = $session->getSessionName(); $cookieInfo = array( 'lifetime' => $session->getCookie()->getLifetime(), 'path' => $session->getCookie()->getPath(), 'domain' => $session->getCookie()->getDomain(), 'secure' => $session->getCookie()->isSecure(), 'httponly' => $session->getCookie()->getHttponly(), ); if (!isset($sessionInfo[$cookieName]) || $sessionInfo[$cookieName] != $cookieInfo) { $sessionInfo[$cookieName] = $cookieInfo; // customer cookies have to be refreshed as well as the session cookie $sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER] = $cookieInfo; $sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_GROUP] = $cookieInfo; $sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_LOGGED_IN] = $cookieInfo; $sessionInfo[Enterprise_PageCache_Model_Cookie::CUSTOMER_SEGMENT_IDS] = $cookieInfo; $sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_MESSAGE] = $cookieInfo; $sessionInfo = serialize($sessionInfo); $cacheInstance->save($sessionInfo, $cacheId, array(Enterprise_PageCache_Model_Processor::CACHE_TAG)); } } 

प्रत्येक अनुपचारित कंटेनर के लिए, applyInApp विधि शुरू की गई है, जिसे ब्लॉक को प्रस्तुत करना चाहिए और सामग्री में प्लेसहोल्डर की सामग्री को प्रतिस्थापित करना चाहिए। Enterprise_PageCache_Model_Container_Abstract वर्ग के कंटेनर के लिए applyInApp विधि सार के लिए कोड:

 /** * Generate and apply container content in controller after application is initialized * * @param string $content * @return bool */ public function applyInApp(&$content) { $blockContent = $this->_renderBlock(); if ($blockContent === false) { return false; } if (Mage::getStoreConfig(Enterprise_PageCache_Model_Processor::XML_PATH_CACHE_DEBUG)) { $debugBlock = new Enterprise_PageCache_Block_Debug(); $debugBlock->setDynamicBlockContent($blockContent); $debugBlock->setTags($this->_getPlaceHolderBlock()->getCacheTags()); $debugBlock->setType($this->_placeholder->getName()); $this->_applyToContent($content, $debugBlock->toHtml()); } else { $this->_applyToContent($content, $blockContent); } $subprocessor = $this->_processor->getSubprocessor(); if ($subprocessor) { $contentWithoutNestedBlocks = $subprocessor->replaceContentToPlaceholderReplacer($blockContent); $this->saveCache($contentWithoutNestedBlocks); } return true; } 

यहां, जैसा कि हम देखते हैं, सामग्री कंटेनर वर्ग के _renderBlock विधि द्वारा प्राप्त की जाती है। यह विधि, एक नियम के रूप में, प्रत्येक कंटेनर के लिए अद्वितीय है और इसमें कुछ विशेष तर्क शामिल हैं। कंटेनर के लिए अमूर्त वर्ग Enterprise_PageCache_Model_Container_Abstract में, यह विधि गलत है। कि यह ब्लॉक की HTML सामग्री को लौटा दे।

हालांकि, कंटेनरों को प्रस्तुत करते समय एक समस्या है। कंटेनर ब्लॉक के लिए, पेरेंट रेंडर नहीं कर सकता है और कंट्रोलर अलग तरीके से चलता है। इसका मतलब है कि ब्लॉक के अंदर कोई डेटा नहीं हो सकता है और इस मामले को प्रदान किया जाना चाहिए (उदाहरण के लिए, आपको इस तरह से उत्पाद मिलता है: $ उत्पाद = दाना :: रजिस्ट्री ('current_product'), या कुछ संपत्ति को मूल ब्लॉक में सेट करें: $ यह-> getChild ('block_alias') -> setProduct ($ _ उत्पाद))।

लेकिन, जैसा कि हम याद करते हैं, एफपीसी प्रतिपादन के लिए आवश्यक सभी जानकारी को बचाता है। इसलिए, यदि आपने बचत के लिए अपने ब्लॉक के getCacheKeyInfo पद्धति में जानकारी पारित की है, तो आप इसे FPC रेंडरिंग के दौरान सेट कर सकते हैं। आपको कंटेनर के _renderBlock विधि में ऐसा करने की आवश्यकता है। आप इसमें _getPlaceHolderBlock विधि का उपयोग करके एक ब्लॉक उदाहरण प्राप्त कर सकते हैं:

 /** * Get Placeholder Block * * @return Mage_Core_Block_Abstract */ protected function _getPlaceHolderBlock() { if (null === $this->_placeholderBlock) { $blockName = $this->_placeholder->getAttribute('block'); $this->_placeholderBlock = new $blockName; $this->_placeholderBlock->setTemplate($this->_placeholder->getAttribute('template')); $this->_placeholderBlock->setLayout(Mage::app()->getLayout()); $this->_placeholderBlock->setSkipRenderTag(true); } return $this->_placeholderBlock; } 

जैसा कि आप देख सकते हैं, हमें स्थापित टेम्पलेट के साथ ब्लॉक क्लास का एक उदाहरण मिलता है। _RenderBlock विधि का एक उदाहरण:

 /** * Render block content from placeholder * * @return string|false */ protected function _renderBlock() { /** * @var $block Turnkeye_Popup_Block_Popup */ $block = $this->_getPlaceHolderBlock(); $placeholder = $this->_placeholder; $serializedParameters = array('handles', 'popup_ids'); foreach ($serializedParameters as $parameter) { $value = unserialize($placeholder->getAttribute($parameter)); $block->setDataUsingMethod($parameter, $value); } return $block->toHtml(); } 

यहां, जैसा कि आप कोड से देख सकते हैं, हमने ब्लॉक में हैंडल और पॉपअप_िड पैरामीटर पारित किए हैं। उसी ब्लॉक में, आपको उन्हें इस तरह प्राप्त करने की आवश्यकता है:

 public function getPopupIds() { if (!$this->hasData('popup_ids')) { $popupIds = ... ... $this->setData('popup_ids', $popupIds); } return $this->getData('popup_ids'); } 

मुझे आशा है कि इस लेख ने एफपीसी कार्यक्षमता पर गोपनीयता का पर्दा उठा दिया है, और आपने सीखा कि एफपीसी तंत्र अंदर से कैसे काम करता है।

कैश वास्तव में कुशल है और सर्वर पर लोड को कम करने और उच्च यातायात के साथ इलेक्ट्रॉनिक स्टोर के तेजी से संचालन को सुनिश्चित करने के लिए महान काम करता है।

एफपीसी पर अपने अगले लेख में, मैं वर्णन करूंगा कि एफपीसी सक्षम के साथ अतिरिक्त गतिशील कार्यक्षमता के सही संचालन के लिए मैगेंटो एंटरप्राइज में अपने स्वयं के गतिशील ब्लॉक कैसे सेट करें।