RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.yiiframework.com/doc/api/2.0/yii-filters-pagecache below:

PageCache, yii\filters\PageCache | API Documentation for Yii 2.0

Class yii\filters\PageCache

PageCache implements server-side caching of whole pages.

It is an action filter that can be added to a controller and handles the beforeAction event.

To use PageCache, declare it in the behaviors() method of your controller class. In the following example the filter will be applied to the index action and cache the whole page for maximum 60 seconds or until the count of entries in the post table changes. It also stores different versions of the page depending on the application language.

public function behaviors()
{
    return [
        'pageCache' => [
            'class' => 'yii\filters\PageCache',
            'only' => ['index'],
            'duration' => 60,
            'dependency' => [
                'class' => 'yii\caching\DbDependency',
                'sql' => 'SELECT COUNT(*) FROM post',
            ],
            'variations' => [
                \Yii::$app->language,
            ]
        ],
    ];
}

Property Details

Hide inherited properties

The cache object or the application component ID of the cache object. After the PageCache object is created, if you want to change this property, you should only assign it with a cache object. Starting from version 2.0.2, this can also be a configuration array for creating the object.

A boolean value indicating whether to cache all cookies, or an array of cookie names indicating which cookies can be cached. Be very careful with caching cookies, because it may leak sensitive or private data stored in cookies to unwanted users.

The dependency that the cached content depends on. This can be either a yii\caching\Dependency object or a configuration array for creating the dependency object. For example,

[
    'class' => 'yii\caching\DbDependency',
    'sql' => 'SELECT MAX(updated_at) FROM post',
]

would make the output cache depend on the last modified time of all posts. If any post has its modification time changed, the cached content would be invalidated.

If $cacheCookies or $cacheHeaders is enabled, then yii\caching\Dependency::$reusable should be enabled as well to save performance. This is because the cookies and headers are currently stored separately from the actual page content, causing the dependency to be evaluated twice.

Number of seconds that the data can remain valid in cache. Use 0 to indicate that the cached data will never expire.

Whether to enable the page cache. You may use this property to turn on and off the page cache according to specific setting (e.g. enable page cache only for GET requests).

List of factors that would cause the variation of the content being cached. Each factor is a string representing a variation (e.g. the language, a GET parameter). The following variation setting will cause the content to be cached in different versions according to the current application language:

[
    Yii::$app->language,
]

Since version 2.0.48 you can provide an anonymous function to generate variations. This is especially helpful when you need to access the User component, which is resolved before the PageCache behavior:

'variations' => function() {
    return [
        Yii::$app->language,
        Yii::$app->user->id
    ];
}

The callable should return an array.

Whether the content being cached should be differentiated according to the route. A route consists of the requested controller ID and action ID. Defaults to true.

The view component to use for caching. If not set, the default application view component yii\web\Application::$view will be used.

Method Details

Hide inherited methods

Defined in: yii\base\BaseObject::__call()

Calls the named method which is not a class method.

Do not call this method directly as it is a PHP magic method that will be implicitly called when an unknown method is being invoked.

Source code

                public function __call($name, $params)
{
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

Defined in: yii\base\BaseObject::__construct()

Constructor.

The default implementation does two things:

Initializes the object with the given configuration $config.
Call init().

If this method is overridden in a child class, it is recommended that

the last parameter of the constructor is a configuration array, like $config here.
call the parent implementation at the end of the constructor.

public void __construct ( $config = [] ) $config array

Name-value pairs that will be used to initialize the object properties

Source code

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

Defined in: yii\base\BaseObject::__get()

Returns the value of an object property.

Do not call this method directly as it is a PHP magic method that will be implicitly called when executing $value = $object->property;.

See also __get().

Source code

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter($value);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    } else {
        throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
    }
}

Defined in: yii\base\BaseObject::__unset()

Sets an object property to null.

Do not call this method directly as it is a PHP magic method that will be implicitly called when executing unset($object->property).

Note that if the property is not defined, this method will do nothing. If the property is read-only, it will throw an exception.

Source code

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Unsetting read-only property: ' . get_class($this) . '::' . $name);
    }
}

public void addDynamicPlaceholder ( $name, $statements ) $name string

The placeholder name.

$statements string

The PHP statements for generating the dynamic content.

Source code

                public function addDynamicPlaceholder($name, $statements)
{
    $this->_dynamicPlaceholders[$name] = $statements;
}

public mixed afterAction ( $action, $result ) $action yii\base\Action

The action just executed.

$result mixed

The action execution result

return mixed

The processed action result.

Source code

                public function afterAction($action, $result)
{
    return $result;
}

Source code

                public function afterFilter($event)
{
    $event->result = $this->afterAction($event->action, $event->result);
    $this->owner->off(Controller::EVENT_AFTER_ACTION, [$this, 'afterFilter']);
}

This method is invoked right after the response restoring is finished (but before the response is sent).

You may override this method to do last-minute preparation before the response is sent.

Source code

                public function afterRestoreResponse($data)
{
}

Defined in: yii\base\ActionFilter::attach()

Attaches the behavior object to the component.

The default implementation will set the $owner property and attach event handlers as declared in events(). Make sure you call the parent implementation if you override this method.

Source code

                public function attach($owner)
{
    $this->owner = $owner;
    $owner->on(Controller::EVENT_BEFORE_ACTION, [$this, 'beforeFilter']);
}

This method is invoked right before an action is to be executed (after all possible filters.) You may override this method to do last-minute preparation for the action.

Source code

                public function beforeAction($action)
{
    if (!$this->enabled) {
        return true;
    }
    $this->cache = Instance::ensure($this->cache, 'yii\caching\CacheInterface');
    if (is_array($this->dependency)) {
        $this->dependency = Yii::createObject($this->dependency);
    }
    $response = Yii::$app->getResponse();
    $data = $this->cache->get($this->calculateCacheKey());
    if (!is_array($data) || !isset($data['cacheVersion']) || $data['cacheVersion'] !== static::PAGE_CACHE_VERSION) {
        $this->view->pushDynamicContent($this);
        ob_start();
        ob_implicit_flush(false);
        $response->on(Response::EVENT_AFTER_SEND, [$this, 'cacheResponse']);
        Yii::debug('Valid page content is not found in the cache.', __METHOD__);
        return true;
    }
    $this->restoreResponse($response, $data);
    Yii::debug('Valid page content is found in the cache.', __METHOD__);
    return false;
}

This method is invoked right before the response caching is to be started.

You may override this method to cancel caching by returning false or store an additional data in a cache entry by returning an array instead of true.

Source code

                public function beforeCacheResponse()
{
    return true;
}

Source code

                public function beforeFilter($event)
{
    if (!$this->isActive($event->action)) {
        return;
    }
    $event->isValid = $this->beforeAction($event->action);
    if ($event->isValid) {
        
        
        $this->owner->on(Controller::EVENT_AFTER_ACTION, [$this, 'afterFilter'], null, false);
    } else {
        $event->handled = true;
    }
}

Caches response properties.

Source code

                public function cacheResponse()
{
    $this->view->popDynamicContent();
    $beforeCacheResponseResult = $this->beforeCacheResponse();
    if ($beforeCacheResponseResult === false) {
        echo $this->updateDynamicContent(ob_get_clean(), $this->getDynamicPlaceholders());
        return;
    }
    $response = Yii::$app->getResponse();
    $response->off(Response::EVENT_AFTER_SEND, [$this, 'cacheResponse']);
    $data = [
        'cacheVersion' => static::PAGE_CACHE_VERSION,
        'cacheData' => is_array($beforeCacheResponseResult) ? $beforeCacheResponseResult : null,
        'content' => ob_get_clean(),
    ];
    if ($data['content'] === false || $data['content'] === '') {
        return;
    }
    $data['dynamicPlaceholders'] = $this->getDynamicPlaceholders();
    foreach (['format', 'version', 'statusCode', 'statusText'] as $name) {
        $data[$name] = $response->{$name};
    }
    $this->insertResponseHeaderCollectionIntoData($response, $data);
    $this->insertResponseCookieCollectionIntoData($response, $data);
    $this->cache->set($this->calculateCacheKey(), $data, $this->duration, $this->dependency);
    $data['content'] = $this->updateDynamicContent($data['content'], $this->getDynamicPlaceholders());
    echo $data['content'];
}

Source code

                protected function calculateCacheKey()
{
    $key = [__CLASS__];
    if ($this->varyByRoute) {
        $key[] = Yii::$app->requestedRoute;
    }
    if ($this->variations instanceof Closure) {
        $variations = call_user_func($this->variations, $this);
    } else {
        $variations = $this->variations;
    }
    return array_merge($key, (array) $variations);
}

Defined in: yii\base\BaseObject::canGetProperty()

Returns a value indicating whether a property can be read.

A property is readable if:

the class has a getter method associated with the specified name (in this case, property name is case-insensitive);
the class has a member variable with the specified name (when $checkVars is true);