0038d1bac4
To stream a Response, use the StreamedResponse class instead of the
standard Response class:
$response = new StreamedResponse(function () {
echo 'FOO';
});
$response = new StreamedResponse(function () {
echo 'FOO';
}, 200, array('Content-Type' => 'text/plain'));
As you can see, a StreamedResponse instance takes a PHP callback instead of
a string for the Response content. It's up to the developer to stream the
response content from the callback with standard PHP functions like echo.
You can also use flush() if needed.
From a controller, do something like this:
$twig = $this->get('templating');
return new StreamedResponse(function () use ($templating) {
$templating->stream('BlogBundle:Annot:streamed.html.twig');
}, 200, array('Content-Type' => 'text/html'));
If you are using the base controller, you can use the stream() method instead:
return $this->stream('BlogBundle:Annot:streamed.html.twig');
You can stream an existing file by using the PHP built-in readfile() function:
new StreamedResponse(function () use ($file) {
readfile($file);
}, 200, array('Content-Type' => 'image/png');
Read http://php.net/flush for more information about output buffering in PHP.
Note that you should do your best to move all expensive operations to
be "activated/evaluated/called" during template evaluation.
Templates
---------
If you are using Twig as a template engine, everything should work as
usual, even if are using template inheritance!
However, note that streaming is not supported for PHP templates. Support
is impossible by design (as the layout is rendered after the main content).
Exceptions
----------
Exceptions thrown during rendering will be rendered as usual except that
some content might have been rendered already.
Limitations
-----------
As the getContent() method always returns false for streamed Responses, some
event listeners won't work at all:
* Web debug toolbar is not available for such Responses (but the profiler works fine);
* ESI is not supported.
Also note that streamed responses cannot benefit from HTTP caching for obvious
reasons.
141 lines
3.5 KiB
PHP
141 lines
3.5 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Symfony package.
|
|
*
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Symfony\Component\Templating;
|
|
|
|
/**
|
|
* DelegatingEngine selects an engine for a given template.
|
|
*
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
|
*
|
|
* @api
|
|
*/
|
|
class DelegatingEngine implements EngineInterface
|
|
{
|
|
protected $engines;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param array $engines An array of EngineInterface instances to add
|
|
*
|
|
* @api
|
|
*/
|
|
public function __construct(array $engines = array())
|
|
{
|
|
$this->engines = array();
|
|
foreach ($engines as $engine) {
|
|
$this->addEngine($engine);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renders a template.
|
|
*
|
|
* @param mixed $name A template name or a TemplateReferenceInterface instance
|
|
* @param array $parameters An array of parameters to pass to the template
|
|
*
|
|
* @return string The evaluated template as a string
|
|
*
|
|
* @throws \InvalidArgumentException if the template does not exist
|
|
* @throws \RuntimeException if the template cannot be rendered
|
|
*
|
|
* @api
|
|
*/
|
|
public function render($name, array $parameters = array())
|
|
{
|
|
return $this->getEngine($name)->render($name, $parameters);
|
|
}
|
|
|
|
/**
|
|
* Streams a template.
|
|
*
|
|
* @param mixed $name A template name or a TemplateReferenceInterface instance
|
|
* @param array $parameters An array of parameters to pass to the template
|
|
*
|
|
* @throws \RuntimeException if the template cannot be rendered
|
|
*
|
|
* @api
|
|
*/
|
|
public function stream($name, array $parameters = array())
|
|
{
|
|
$this->getEngine($name)->stream($name, $parameters);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the template exists.
|
|
*
|
|
* @param mixed $name A template name or a TemplateReferenceInterface instance
|
|
*
|
|
* @return Boolean true if the template exists, false otherwise
|
|
*
|
|
* @api
|
|
*/
|
|
public function exists($name)
|
|
{
|
|
return $this->getEngine($name)->exists($name);
|
|
}
|
|
|
|
/**
|
|
* Adds an engine.
|
|
*
|
|
* @param EngineInterface $engine An EngineInterface instance
|
|
*
|
|
* @api
|
|
*/
|
|
public function addEngine(EngineInterface $engine)
|
|
{
|
|
$this->engines[] = $engine;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this class is able to render the given template.
|
|
*
|
|
* @param mixed $name A template name or a TemplateReferenceInterface instance
|
|
*
|
|
* @return Boolean true if this class supports the given template, false otherwise
|
|
*
|
|
* @api
|
|
*/
|
|
public function supports($name)
|
|
{
|
|
try {
|
|
$this->getEngine($name);
|
|
} catch (\RuntimeException $e) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get an engine able to render the given template.
|
|
*
|
|
* @param mixed $name A template name or a TemplateReferenceInterface instance
|
|
*
|
|
* @return EngineInterface The engine
|
|
*
|
|
* @throws \RuntimeException if no engine able to work with the template is found
|
|
*
|
|
* @api
|
|
*/
|
|
protected function getEngine($name)
|
|
{
|
|
foreach ($this->engines as $engine) {
|
|
if ($engine->supports($name)) {
|
|
return $engine;
|
|
}
|
|
}
|
|
|
|
throw new \RuntimeException(sprintf('No engine is able to work with the template "%s".', $name));
|
|
}
|
|
}
|