PHP HttpCache\HttpCache类代码示例

    public function testTerminateDelegatesTerminationOnlyForTerminableInterface()
    {
        $storeMock = $this->getMockBuilder('Symfony\\Component\\HttpKernel\\HttpCache\\StoreInterface')
            ->disableOriginalConstructor()
            ->getMock();

        // does not implement TerminableInterface
        $kernelMock = $this->getMockBuilder('Symfony\\Component\\HttpKernel\\HttpKernelInterface')
            ->disableOriginalConstructor()
            ->getMock();

        $kernelMock->expects($this->never())
            ->method('terminate');

        $kernel = new HttpCache($kernelMock, $storeMock);
        $kernel->terminate(Request::create('/'), new Response());

        // implements TerminableInterface
        $kernelMock = $this->getMockBuilder('Symfony\\Component\\HttpKernel\\Kernel')
            ->disableOriginalConstructor()
            ->setMethods(array('terminate', 'registerBundles', 'registerContainerConfiguration'))
            ->getMock();

        $kernelMock->expects($this->once())
            ->method('terminate');

        $kernel = new HttpCache($kernelMock, $storeMock);
        $kernel->terminate(Request::create('/'), new Response());
    }

 /**
  *
  */
 protected function buildAndCacheResponse()
 {
     $controllerResolver = new ControllerResolver(array($this, 'buildResponse'));
     $kernel = new HttpKernel(new EventDispatcher(), $controllerResolver);
     if ($this->adapter->isCachingEnabled($this->request)) {
         $kernel = new HttpCache($kernel, $this->adapter->getStore($this->request), $this->adapter->getSurrogate($this->request), $this->adapter->getHttpCacheOptions($this->request));
     }
     $response = $kernel->handle($this->request);
     $this->shutDownFunctionEnabled = false;
     $response->send();
     $kernel->terminate($this->request, $response);
 }

 /**
  * {@inheritdoc}
  */
 public function handle(HttpCache $cache, $uri, $alt, $ignoreErrors)
 {
     $subRequest = Request::create($uri, Request::METHOD_GET, array(), $cache->getRequest()->cookies->all(), array(), $cache->getRequest()->server->all());
     try {
         $response = $cache->handle($subRequest, HttpKernelInterface::SUB_REQUEST, true);
         if (!$response->isSuccessful()) {
             throw new \RuntimeException(sprintf('Error when rendering "%s" (Status code is %s).', $subRequest->getUri(), $response->getStatusCode()));
         }
         return $response->getContent();
     } catch (\Exception $e) {
         if ($alt) {
             return $this->handle($cache, $alt, '', $ignoreErrors);
         }
         if (!$ignoreErrors) {
             throw $e;
         }
     }
 }

<?php

ini_set('display_errors', 1);
require_once __DIR__ . '/../vendor/autoload.php';
use Simplex;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel;
use Symfony\Component\DependencyInjection\Reference;
$request = Request::createFromGlobals();
$sc = (include __DIR__ . '/../src/container.php');
$sc->setParameter('routes', include __DIR__ . '/../src/routes.php');
$sc->register('listener.string_response', Simplex\StringResponseListener::class);
$sc->getDefinition('dispatcher')->addMethodCall('addSubscriber', array(new Reference('listener.string_response')));
$framework = $sc->get('framework');
$framework = new HttpKernel\HttpCache\HttpCache($framework, new HttpKernel\HttpCache\Store(__DIR__ . '/../cache'));
$response = $framework->handle($request);
$response->send();

<?php

require_once __DIR__ . '/../vendor/autoload.php';
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing;
use Symfony\Component\HttpKernel;
use Symfony\Component\EventDispatcher\EventDispatcher;
function render_template(Request $request)
{
    extract($request->attributes->all(), EXTR_SKIP);
    ob_start();
    include sprintf(__DIR__ . '/../src/pages/%s.php', $_route);
    return new Response(ob_get_clean());
}
$request = Request::createFromGlobals();
$routes = (include __DIR__ . '/../src/app.php');
$context = new Routing\RequestContext();
$matcher = new Routing\Matcher\UrlMatcher($routes, $context);
$resolver = new HttpKernel\Controller\ControllerResolver();
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new Simplex\ContentLengthListener());
$dispatcher->addSubscriber(new Simplex\GoogleListener());
/*
$dispatcher = new EventDispatcher();
$dispatcher->addListener('response', array(new Simplex\ContentLengthListener(), 'onResponse'));
$dispatcher->addListener('response', array(new Simplex\GoogleListener(), 'onResponse'), -255);
*/
$framework = new Simplex\Framework($dispatcher, $matcher, $resolver);
$framework = new HttpKernel\HttpCache\HttpCache($framework, new HttpKernel\HttpCache\Store(__DIR__ . '/../cache'));
$framework->handle($request)->send();

 /**
  * Forwards the Request to the backend and returns the Response.
  *
  * @param Request  $request A Request instance
  * @param Boolean  $raw     Whether to catch exceptions or not
  * @param Response $entry   A Response instance (the stale entry if present, null otherwise)
  *
  * @return Response A Response instance
  */
 protected function forward(Request $request, $raw = false, Response $entry = null)
 {
     $this->getKernel()->boot();
     /** @var $container \Shopware\Components\DependencyInjection\Container */
     $container = $this->getKernel()->getContainer();
     $container->set('HttpCache', $this);
     return parent::forward($request, $raw, $entry);
 }

    /**
     * Forwards the Request to the backend and returns the Response.
     *
     * @param Request $request A Request instance
     * @param Boolean $raw Whether to catch exceptions or not
     * @param Response $entry A Response instance (the stale entry if present, null otherwise)
     *
     * @return Response A Response instance
     */
    protected function forward(Request $request, $raw = false, Response $entry = null)
    {
        /** @var $bootstrap \Shopware_Bootstrap */
        $bootstrap = $this->getKernel()->getApp()->Bootstrap();

        $bootstrap->registerResource('HttpCache', $this);
        $bootstrap->registerResource('Esi', $this->esi);

        return parent::forward($request, $raw, $entry);
    }

 /**
  * Forwards the Request to the backend and returns the Response.
  *
  * @param Request  $request A Request instance
  * @param Boolean  $raw     Whether to catch exceptions or not
  * @param Response $entry   A Response instance (the stale entry if present, null otherwise)
  *
  * @return Response A Response instance
  */
 protected function forward(Request $request, $raw = false, Response $entry = null)
 {
     $this->getKernel()->boot();
     $this->getKernel()->getContainer()->set('cache', $this);
     $this->getKernel()->getContainer()->set('esi', $this->getEsi());
     return parent::forward($request, $raw, $entry);
 }

 public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
 {
     if (!$request instanceof \Thelia\Core\HttpFoundation\Request) {
         $request = TheliaRequest::create($request->getUri(), $request->getMethod(), $request->getMethod() == 'GET' ? $request->query->all() : $request->request->all(), $request->cookies->all(), $request->files->all(), $request->server->all(), $request->getContent());
     }
     return parent::handle($request, $type, $catch);
 }

 /**
  * {@inheritDoc}
  *
  * Adding the Events::PRE_INVALIDATE event.
  */
 protected function invalidate(Request $request, $catch = false)
 {
     if ($this->getEventDispatcher()->hasListeners(Events::PRE_INVALIDATE)) {
         $event = new CacheEvent($this, $request);
         $this->getEventDispatcher()->dispatch(Events::PRE_INVALIDATE, $event);
         if ($event->getResponse()) {
             return $event->getResponse();
         }
     }
     return parent::invalidate($request, $catch);
 }