title: EasySwoole Template engine meta:

  • name: description content: EasySwoole Template engine|swoole Template engine|swoole Template rendering
  • name: keywords content: swoole|swoole extension|swoole framework|EasySwoole Template engine|swoole Template engine|swoole Template rendering

Template engine

Rendering driver

EasySwoole introduces the form of the template rendering driver, and the data that needs to be rendered is delivered to the custom synchronization process through the coroutine client for rendering and returning the result. The reason for this is that some of the templating engines on the market have variable security issues under the Swoole coroutine. For example, the following process:

  • request A reached, static A assign requestA-data
  • compiled template
  • write compiled template (yiled current coroutine)
  • request B reached，static A assign requestB-data

  • render static A data into complied template file

    The above process we can find that the data requested by A is polluted by B. To solve this problem, EasySwoole introduced a template rendering driver mode.

Installation

  1. composer require easyswoole/template

Basic implementation

Implementing the rendering engine

  1. use EasySwoole\Template\Config;
  2. use EasySwoole\Template\Render;
  3. use EasySwoole\Template\RenderInterface;
  5. class R implements RenderInterface
  6. {
  8.     public function render(string $template, array $data = [], array $options = []):?string
  9.     {
  10.         return 'asas';
  11.     }
  13.     public function afterRender(?string $result, string $template, array $data = [], array $options = [])
  14.     {
  15.         // TODO: Implement afterRender() method.
  16.     }
  18.     public function onException(Throwable $throwable):string
  19.     {
  20.         return $throwable->getMessage();
  21.     }
  22. }

Called in HTTP service

  1. //In the event created in the global main service, instantiate the Render and inject your driver configuration
  2. Render::getInstance()->getConfig()->setRender(new R());
  4. $http = new swoole_http_server("0.0.0.0", 9501);
  5. $http->on("request", function ($request, $response)use($render) {
  6.     //Call the renderer, and then send the data to the custom synchronization process through the Ctrip client, and get the rendering result.
  7.     $response->end(Render::getInstance()->render('a.html'));
  8. });
  9. $render->attachServer($http);
  11. $http->start();

Restart the rendering engine

Because some template engines cache template files This may lead to the following situations:

  • User A requests 1.tpl to return ‘a’
  • The developer modified the 1.tpl data and changed it to ‘b’
  • User B, C, D may have two different values of ‘a’ and ‘b’ in subsequent requests.

That’s because the template engine has already cached the file of the process in which A is located, causing subsequent requests to be cached if they are also assigned to A’s process.

The solution is as follows: 1: Restart easyswoole, you can solve 2: The template rendering engine implements the restart method restartWorker, which can be called directly.

  1. Render::getInstance()->restartWorker();

Users can call the restartWorker method to restart according to their own logic. For example, add a reload method to the controller:

  1. <?php
  2. namespace App\HttpController;
  5. use EasySwoole\Http\AbstractInterface\Controller;
  6. use EasySwoole\Template\Render;
  8. class Index extends Controller
  9. {
  11.     function index()
  12.     {
  13.         $this->response()->write(Render::getInstance()->render('index.tpl',[
  14.             'user'=>'easyswoole',
  15.             'time'=>time()
  16.         ]));
  17.     }
  19.     function reload(){
  20.         Render::getInstance()->restartWorker();
  21.         $this->response()->write(1);
  22.     }
  23. }

Smarty Rendering

Introducing Smarty

  1. composer require smarty/smarty   - request A reached, static A assign requestA-data
  2.    - compiled template 
  3.    - write compiled template (yiled current coroutine)
  4.    - request B reached，static A assign requestB-data
  5.    - render static A data into complied template file

Implement the rendering engine

  1. use EasySwoole\Template\RenderInterface;
  2. use EasySwoole\Template\RenderInterface;
  4. class Smarty implements RenderInterface
  5. {
  7.     private $smarty;
  8.     function __construct()
  9.     {
  10.         $temp = sys_get_temp_dir();
  11.         $this->smarty = new \Smarty();
  12.         $this->smarty->setTemplateDir(__DIR__.'/');
  13.         $this->smarty->setCacheDir("{$temp}/smarty/cache/");
  14.         $this->smarty->setCompileDir("{$temp}/smarty/compile/");
  15.     }
  17.     public function render(string $template, array $data = [], array $options = []): ?string
  18.     {
  19.         foreach ($data as $key => $item){
  20.             $this->smarty->assign($key,$item);
  21.         }
  22.         return $this->smarty->fetch($template,$cache_id = null, $compile_id = null, $parent = null, $display = false,
  23.             $merge_tpl_vars = true, $no_output_filter = false);
  24.     }
  26.     public function afterRender(?string $result, string $template, array $data = [], array $options = [])
  27.     {
  29.     }
  31.     public function onException(\Throwable $throwable): string
  32.     {
  33.         $msg = "{$throwable->getMessage()} at file:{$throwable->getFile()} line:{$throwable->getLine()}";
  34.         trigger_error($msg);
  35.         return $msg;
  36.     }
  37. }

Calling in HTTP service

  1. // Create an event in the global main service, instantiate the Render, and inject your driver configuration
  2. Render::getInstance()->getConfig()->setRender(new Smarty());
  3. Render::getInstance()->getConfig()->setTempDir(EASYSWOOLE_TEMP_DIR);
  4. Render::getInstance()->attachServer(ServerManager::getInstance()->getSwooleServer());
  5. // Implement the response in the action
  6. Render::getInstance()->render('a.html');

Support for common template engines

Here are some common template engine packages for easy introduction:

smarty/smarty

Smarty is a template engine written in PHP and is one of the most famous PHP template engines in the industry.

::: warning composer require smarty/smarty=~3.1 :::

league/plates

Lower cost of learning and higher freedom with a non-compiled template engine using native PHP syntax

::: warning Composer require league/plates=3.* :::

duncan3dc/blade

Template engine used by the Laravel framework

::: warning Composer require duncan3dc/blade=^4.5 :::

topthink/think-template

Template engine used by the ThinkPHP framework

::: warning composer require topthink/think-template :::