PHP Response::canCache方法代码示例

 /**
  * Revalidate a cached response
  *
  * @param RequestInterface $request  Request to revalidate
  * @param Response         $response Response to revalidate
  *
  * @return bool
  */
 public function revalidate(RequestInterface $request, Response $response)
 {
     $revalidate = clone $request;
     $revalidate->getEventDispatcher()->removeSubscriber($this);
     $revalidate->removeHeader('Pragma')->removeHeader('Cache-Control')->setHeader('If-Modified-Since', $response->getDate());
     if ($response->getEtag()) {
         $revalidate->setHeader('If-None-Match', '"' . $response->getEtag() . '"');
     }
     try {
         $validateResponse = $revalidate->send();
         if ($validateResponse->getStatusCode() == 200) {
             // The server does not support validation, so use this response
             $request->setResponse($validateResponse);
             // Store this response in cache if possible
             if ($validateResponse->canCache()) {
                 $this->saveCache($this->getCacheKey($request), $validateResponse, $validateResponse->getMaxAge());
             }
             return false;
         }
         if ($validateResponse->getStatusCode() == 304) {
             // Make sure that this response has the same ETage
             if ($validateResponse->getEtag() != $response->getEtag()) {
                 return false;
             }
             // Replace cached headers with any of these headers from the
             // origin server that might be more up to date
             $modified = false;
             foreach (array('Date', 'Expires', 'Cache-Control', 'ETag', 'Last-Modified') as $name) {
                 if ($validateResponse->hasHeader($name)) {
                     $modified = true;
                     $response->setHeader($name, $validateResponse->getHeader($name));
                 }
             }
             // Store the updated response in cache
             if ($modified && $response->canCache()) {
                 $this->saveCache($this->getCacheKey($request), $response, $response->getMaxAge());
             }
             return true;
         }
     } catch (BadResponseException $e) {
         // 404 errors mean the resource no longer exists, so remove from
         // cache, and prevent an additional request by throwing the exception
         if ($e->getResponse()->getStatusCode() == 404) {
             $this->getCacheAdapter()->delete($this->getCacheKey($request));
             throw $e;
         }
     }
     // Other exceptions encountered in the revalidation request are ignored
     // in hopes that sending a request to the origin server will fix it
     return false;
 }

 public function canCacheResponse(Response $response)
 {
     return $response->isSuccessful() && $response->canCache();
 }

 public function isCacheable()
 {
     return $this->_response->canCache();
 }

 /**
  * Handle a 304 response and ensure that it is still valid
  *
  * @param RequestInterface $request          Request that was sent
  * @param Response         $validateResponse Response received
  * @param Response         $response         Original cached response
  *
  * @return bool Returns true if valid, false if invalid
  */
 protected function handle304Response(RequestInterface $request, Response $validateResponse, Response $response)
 {
     static $replaceHeaders = array('Date', 'Expires', 'Cache-Control', 'ETag', 'Last-Modified');
     // Make sure that this response has the same ETag
     if ($validateResponse->getEtag() != $response->getEtag()) {
         return false;
     }
     // Replace cached headers with any of these headers from the
     // origin server that might be more up to date
     $modified = false;
     foreach ($replaceHeaders as $name) {
         if ($validateResponse->hasHeader($name)) {
             $modified = true;
             $response->setHeader($name, $validateResponse->getHeader($name));
         }
     }
     // Store the updated response in cache
     if ($modified && $response->canCache()) {
         $this->storage->cache($this->cacheKey->getCacheKey($request), $response, $response->getMaxAge());
     }
     return true;
 }

 /**
  * @covers Guzzle\Http\Message\Response::canCache
  */
 public function testDeterminesIfItCanBeCached()
 {
     $this->assertTrue($this->getResponse(200)->canCache());
     $this->assertTrue($this->getResponse(410)->canCache());
     $this->assertFalse($this->getResponse(404)->canCache());
     $this->assertTrue($this->getResponse(200, array('Cache-Control' => 'public'))->canCache());
     // This has the no-store directive
     $this->assertFalse($this->getResponse(200, array('Cache-Control' => 'private, no-store'))->canCache());
     // The body cannot be read, so it cannot be cached
     $tmp = tempnam('/tmp', 'not-readable');
     $resource = fopen($tmp, 'w');
     $this->assertFalse($this->getResponse(200, array('Transfer-Encoding' => 'chunked'), EntityBody::factory($resource, 10))->canCache());
     unlink($tmp);
     // The body is 0 length, cannot be read, so it can be cached
     $tmp = tempnam('/tmp', 'not-readable');
     $resource = fopen($tmp, 'w');
     $this->assertTrue($this->getResponse(200, array(array('Content-Length' => 0)), EntityBody::factory($resource, 0))->canCache());
     unlink($tmp);
     // When an HTTPS request is sent and the Cache-Control directive does
     // not include a 'public' value, then the response is not to be cached
     $request = RequestFactory::getInstance()->create('GET', 'https://www.test.com/');
     $response = new Response(200);
     $response->setRequest($request);
     $this->assertFalse($response->canCache());
     // This response can be cache because it is public
     $response->setHeader('Cache-Control', 'public');
     $this->assertTrue($response->canCache());
 }