缓存对象关系映射（Caching in the ORM）

现实中的每个应用都不同，一些应用的模型数据经常改变而另一些模型的数据几乎不同。访问数据库在很多时候对我们应用的来说 是个瓶颈。这是由于我们每次访问应用时都会和数据库数据通信，和数据库进行通信的代价是很大的。因此在必要时我们可以通过增加 缓存层来获取更高的性能。 本章内容的重点即是探讨实施缓存来提高性能的可行性。Phalcon框架给我们提供了灵活的缓存技术来实现我们的应用缓存。

缓存结果集（Caching Resultsets）

一个非常可行的方案是我们可以为那些不经常改变且经常访问的数据库数据进行缓存，比如把他们放入内存，这样可以加快程序的执行速度。

当 Phalcon\Mvc\Model 需要使用缓存数据的服务时Model可以直接从DI中取得此缓存服务modelsCache(惯例名).

Phalcon提供了一个组件（服务）可以用来 缓存 任何种类的数据，下面我们会解释如何在model使用它。第一步我们要在启动文件注册 这个服务:

  1. <?php
  3. use Phalcon\Cache\Frontend\Data as FrontendData;
  4. use Phalcon\Cache\Backend\Memcache as BackendMemcache;
  6. // 设置模型缓存服务
  7. $di->set(
  8.     "modelsCache",
  9.     function () {
  10.         // 默认缓存时间为一天
  11.         $frontCache = new FrontendData(
  12.             [
  13.                 "lifetime" => 86400,
  14.             ]
  15.         );
  17.         // Memcached连接配置 这里使用的是Memcache适配器
  18.         $cache = new BackendMemcache(
  19.             $frontCache,
  20.             [
  21.                 "host" => "localhost",
  22.                 "port" => "11211",
  23.             ]
  24.         );
  26.         return $cache;
  27.     }
  28. );

在注册缓存服务时我们可以按照我们的需要进行配置。一旦完成正确的缓存设置之后，我们可以按如下的方式缓存查询的结果了:

  1. <?php
  3. // 直接取Products模型里的数据（未缓存）
  4. $products = Products::find();
  6. // 缓存查询结果.缓存时间为默认1天。
  7. $products = Products::find(
  8.     [
  9.         "cache" => [
  10.             "key" => "my-cache",
  11.         ],
  12.     ]
  13. );
  15. // 缓存查询结果时间为300秒
  16. $products = Products::find(
  17.     [
  18.         "cache" => [
  19.             "key"      => "my-cache",
  20.             "lifetime" => 300,
  21.         ],
  22.     ]
  23. );
  25. // Use the 'cache' service from the DI instead of 'modelsCache'
  26. $products = Products::find(
  27.     [
  28.         "cache" => [
  29.             "key"     => "my-cache",
  30.             "service" => "cache",
  31.         ],
  32.     ]
  33. );
  35. 这里我们也可以缓存关联表的数据:
  1. <?php
  3. // Query some post
  4. $post = Post::findFirst();
  6. // Get comments related to a post, also cache it
  7. $comments = $post->getComments(
  8.     [
  9.         "cache" => [
  10.             "key" => "my-key",
  11.         ],
  12.     ]
  13. );
  15. // Get comments related to a post, setting lifetime
  16. $comments = $post->getComments(
  17.     [
  18.         "cache" => [
  19.             "key"      => "my-key",
  20.             "lifetime" => 3600,
  21.         ],
  22.     ]
  23. );

如果想删除已经缓存的结果，则只需要使用前面指定的缓存的键值进行删除即可。

注意并不是所有的结果都必须缓存下来。那些经常改变的数据就不应该被缓存，这样做只会影响应用的性能。另外对于那些特别大的 不易变的数据集，开发者应用根据实际情况进行选择是否进行缓存。

强制缓存（Forcing Cache）

前面的例子中我们在 Phalcon\Mvc\Model 中使用框架内建的缓存组件。为实现强制缓存我们传递了cache作为参数：

  1. <?php
  3. // 缓存查询结果5分钟
  4. $products = Products::find(
  5.     [
  6.         "cache" => [
  7.             "key"      => "my-cache",
  8.             "lifetime" => 300,
  9.         ],
  10.     ]
  11. );

这给了我们自由选择需要缓存的查询结果，但是如果我们想对模型中的所有查询结果进行缓存，那么我们可以重写:code:find()/:code:`findFirst()`方法：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Robots extends Model
  6. {
  7.     /**
  8.      * Implement a method that returns a string key based
  9.      * on the query parameters
  10.      */
  11.     protected static function _createKey($parameters)
  12.     {
  13.         $uniqueKey = [];
  15.         foreach ($parameters as $key => $value) {
  16.             if (is_scalar($value)) {
  17.                 $uniqueKey[] = $key . ":" . $value;
  18.             } elseif (is_array($value)) {
  19.                 $uniqueKey[] = $key . ":[" . self::_createKey($value) . "]";
  20.             }
  21.         }
  23.         return join(",", $uniqueKey);
  24.     }
  26.     public static function find($parameters = null)
  27.     {
  28.         // Convert the parameters to an array
  29.         if (!is_array($parameters)) {
  30.             $parameters = [$parameters];
  31.         }
  33.         // Check if a cache key wasn't passed
  34.         // and create the cache parameters
  35.         if (!isset($parameters["cache"])) {
  36.             $parameters["cache"] = [
  37.                 "key"      => self::_createKey($parameters),
  38.                 "lifetime" => 300,
  39.             ];
  40.         }
  42.         return parent::find($parameters);
  43.     }
  45.     public static function findFirst($parameters = null)
  46.     {
  47.         // ...
  48.     }
  49. }

访问数据要远比计算key值慢的多，我们在这里定义自己需要的key生成方式。注意好的键可以避免冲突，这样就可以依据不同的key值 取得不同的缓存结果。

这样我们可以对每个模型的缓存进行完全的控制，如果其他的模型也需要共用此缓存，可以建立一个模型缓存基类：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class CacheableModel extends Model
  6. {
  7.     protected static function _createKey($parameters)
  8.     {
  9.         // ... Create a cache key based on the parameters
  10.     }
  12.     public static function find($parameters = null)
  13.     {
  14.         // ... Custom caching strategy
  15.     }
  17.     public static function findFirst($parameters = null)
  18.     {
  19.         // ... Custom caching strategy
  20.     }
  21. }

然后把这个类作为其它缓存类的基类：

  1. <?php
  3. class Robots extends CacheableModel
  4. {
  6. }

缓存 PHQL 查询（Caching PHQL Queries）

ORM中的所有查询，不论多高级的查询方法，内部都是通过PHQL进行实现的。PHQL可以让我们非常自由的创建各种查询，当然这些查询也可以被缓存：

  1. <?php
  3. $phql = "SELECT * FROM Cars WHERE name = :name:";
  5. $query = $this->modelsManager->createQuery($phql);
  7. $query->cache(
  8.     [
  9.         "key"      => "cars-by-name",
  10.         "lifetime" => 300,
  11.     ]
  12. );
  14. $cars = $query->execute(
  15.     [
  16.         "name" => "Audi",
  17.     ]
  18. );

可重用的相关记录（Reusable Related Records）

一些模型可能与其他模型之间有关联关系。下面的例子可以让我们非常容易的在内存中检索相关联的数据：

  1. <?php
  3. // Get some invoice
  4. $invoice = Invoices::findFirst();
  6. // Get the customer related to the invoice
  7. $customer = $invoice->customer;
  9. // Print his/her name
  10. echo $customer->name, "\n";

这个例子非常简单，依据查询到的订单信息取得用户信息之后再取得用户名。下面的例子也是如此：我们查询了一些订单的信息，然后取得这些订单相关联 用户的信息，之后取得用户名：

  1. <?php
  3. // Get a set of invoices
  4. // SELECT * FROM invoices;
  5. $invoices = Invoices::find();
  7. foreach ($invoices as $invoice) {
  8.     // Get the customer related to the invoice
  9.     // SELECT * FROM customers WHERE id = ?;
  10.     $customer = $invoice->customer;
  12.     // Print his/her name
  13.     echo $customer->name, "\n";
  14. }

每个客户可能会有一个或多个帐单，这就意味着客户对象没必须取多次。为了避免一次次的重复取客户信息，我们这里设置关系为reusable为true, 这样ORM就可以重复使用客户信息：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Invoices extends Model
  6. {
  7.     public function initialize()
  8.     {
  9.         $this->belongsTo(
  10.             "customers_id",
  11.             "Customer",
  12.             "id",
  13.             [
  14.                 "reusable" => true,
  15.             ]
  16.         );
  17.     }
  18. }

此Cache存在于内存中，这意味着当请求结束时缓存数据即被释放。

缓存相关记录（Caching Related Records）

当使用:code:`find()`或:code:`findFirst()`查询关联数据时，ORM内部会自动的依据以下规则创建查询条件：

类型描述隐含方法
Belongs-To直接的返回模型相关的记录findFirst()
Has-One直接的返回模型相关的记录findFirst()
Has-Many返回模型相关的记录集合find()

这意味着当我们取得关联记录时，我们需要解析如何取得数据的方法：

  1. <?php
  3. // Get some invoice
  4. $invoice = Invoices::findFirst();
  6. // Get the customer related to the invoice
  7. $customer = $invoice->customer; // Invoices::findFirst("...");
  9. // Same as above
  10. $customer = $invoice->getCustomer(); // Invoices::findFirst("...");

因此，我们可以替换掉Invoices模型中的:code:`findFirst()`方法然后实现我们使用适合的方法

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Invoices extends Model
  6. {
  7.     public static function findFirst($parameters = null)
  8.     {
  9.         // ... Custom caching strategy
  10.     }
  11. }

递归缓存相关记录（Caching Related Records Recursively）

在这种场景下我们假定我们每次取主记录时都会取模型的关联记录，如果我们此时保存这些记录可能会为我们的系统带来一些性能上的提升：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Invoices extends Model
  6. {
  7.     protected static function _createKey($parameters)
  8.     {
  9.         // ... Create a cache key based on the parameters
  10.     }
  12.     protected static function _getCache($key)
  13.     {
  14.         // Returns data from a cache
  15.     }
  17.     protected static function _setCache($key, $results)
  18.     {
  19.         // Stores data in the cache
  20.     }
  22.     public static function find($parameters = null)
  23.     {
  24.         // Create a unique key
  25.         $key = self::_createKey($parameters);
  27.         // Check if there are data in the cache
  28.         $results = self::_getCache($key);
  30.         // Valid data is an object
  31.         if (is_object($results)) {
  32.             return $results;
  33.         }
  35.         $results = [];
  37.         $invoices = parent::find($parameters);
  39.         foreach ($invoices as $invoice) {
  40.             // Query the related customer
  41.             $customer = $invoice->customer;
  43.             // Assign it to the record
  44.             $invoice->customer = $customer;
  46.             $results[] = $invoice;
  47.         }
  49.         // Store the invoices in the cache + their customers
  50.         self::_setCache($key, $results);
  52.         return $results;
  53.     }
  55.     public function initialize()
  56.     {
  57.         // Add relations and initialize other stuff
  58.     }
  59. }

从已经缓存的订单中取得用户信息，可以减少系统的负载。注意我们也可以使用PHQL来实现这个，下面使用了PHQL来实现：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Invoices extends Model
  6. {
  7.     public function initialize()
  8.     {
  9.         // Add relations and initialize other stuff
  10.     }
  12.     protected static function _createKey($conditions, $params)
  13.     {
  14.         // ... Create a cache key based on the parameters
  15.     }
  17.     public function getInvoicesCustomers($conditions, $params = null)
  18.     {
  19.         $phql = "SELECT Invoices.*, Customers.* FROM Invoices JOIN Customers WHERE " . $conditions;
  21.         $query = $this->getModelsManager()->executeQuery($phql);
  23.         $query->cache(
  24.             [
  25.                 "key"      => self::_createKey($conditions, $params),
  26.                 "lifetime" => 300,
  27.             ]
  28.         );
  30.         return $query->execute($params);
  31.     }
  33. }

基于条件的缓存（Caching based on Conditions）

此例中，根据不同的条件实施缓存. We might decide that the cache backend should be determined by the primary key:

类型缓存
1 - 10000mongo1
10000 - 20000mongo2
> 20000mongo3

最简单的方式即是为模型类添加一个静态的方法，此方法中我们指定要使用的缓存：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Robots extends Model
  6. {
  7.     public static function queryCache($initial, $final)
  8.     {
  9.         if ($initial >= 1 && $final < 10000) {
  10.             $service = "mongo1";
  11.         } elseif ($initial >= 10000 && $final <= 20000) {
  12.             $service = "mongo2";
  13.         } elseif ($initial > 20000) {
  14.             $service = "mongo3";
  15.         }
  17.         return self::find(
  18.             [
  19.                 "id >= " . $initial . " AND id <= " . $final,
  20.                 "cache" => [
  21.                     "service" => $service,
  22.                 ],
  23.             ]
  24.         );
  25.     }
  26. }

这个方法是可以解决问题，不过如果我们需要添加其它的参数比如排序或条件等等，我们还要创建更复杂的方法。另外当我们使用:code:find()/:code:`findFirst()`来查询关联数据时此方法亦会失效：

  1. <?php
  3. $robots = Robots::find("id < 1000");
  4. $robots = Robots::find("id > 100 AND type = 'A'");
  5. $robots = Robots::find("(id > 100 AND type = 'A') AND id < 2000");
  7. $robots = Robots::find(
  8.     [
  9.         "(id > ?0 AND type = 'A') AND id < ?1",
  10.         "bind"  => [100, 2000],
  11.         "order" => "type",
  12.     ]
  13. );

为了实现这个，我们需要拦截中间语言解析，然后书写相关的代码以定制缓存： 首先我们需要创建自定义的创建器，然后我们可以使用它来创建自己定义的查询：

  1. <?php
  3. use Phalcon\Mvc\Model\Query\Builder as QueryBuilder;
  5. class CustomQueryBuilder extends QueryBuilder
  6. {
  7.     public function getQuery()
  8.     {
  9.         $query = new CustomQuery($this->getPhql());
  11.         $query->setDI($this->getDI());
  13.         return $query;
  14.     }
  15. }

这里我们返回的是CustomQuery而不是不直接的返回 Phalcon\Mvc\Model\Query， 类定义如下所示：

  1. <?php
  3. use Phalcon\Mvc\Model\Query as ModelQuery;
  5. class CustomQuery extends ModelQuery
  6. {
  7.     /**
  8.      * The execute method is overridden
  9.      */
  10.     public function execute($params = null, $types = null)
  11.     {
  12.         // Parse the intermediate representation for the SELECT
  13.         $ir = $this->parse();
  15.         // Check if the query has conditions
  16.         if (isset($ir["where"])) {
  17.             // The fields in the conditions can have any order
  18.             // We need to recursively check the conditions tree
  19.             // to find the info we're looking for
  20.             $visitor = new CustomNodeVisitor();
  22.             // Recursively visits the nodes
  23.             $visitor->visit($ir["where"]);
  25.             $initial = $visitor->getInitial();
  26.             $final   = $visitor->getFinal();
  28.             // Select the cache according to the range
  29.             // ...
  31.             // Check if the cache has data
  32.             // ...
  33.         }
  35.         // Execute the query
  36.         $result = $this->_executeSelect($ir, $params, $types);
  38.         // Cache the result
  39.         // ...
  41.         return $result;
  42.     }
  43. }

这里我们实现了一个帮助类，用递归的方式来检查条件中的查询字段，方便我们了解需要使用缓存的范围（即检查条件以确认实施查询缓存的范围）：

  1. <?php
  3. class CustomNodeVisitor
  4. {
  5.     protected $_initial = 0;
  7.     protected $_final = 25000;
  9.     public function visit($node)
  10.     {
  11.         switch ($node["type"]) {
  12.             case "binary-op":
  13.                 $left  = $this->visit($node["left"]);
  14.                 $right = $this->visit($node["right"]);
  16.                 if (!$left || !$right) {
  17.                     return false;
  18.                 }
  20.                 if ($left === "id") {
  21.                     if ($node["op"] === ">") {
  22.                         $this->_initial = $right;
  23.                     }
  25.                     if ($node["op"] === "=") {
  26.                         $this->_initial = $right;
  27.                     }
  29.                     if ($node["op"] === ">=") {
  30.                         $this->_initial = $right;
  31.                     }
  33.                     if ($node["op"] === "<") {
  34.                         $this->_final = $right;
  35.                     }
  37.                     if ($node["op"] === "<=") {
  38.                         $this->_final = $right;
  39.                     }
  40.                 }
  42.                 break;
  44.             case "qualified":
  45.                 if ($node["name"] === "id") {
  46.                     return "id";
  47.                 }
  49.                 break;
  51.             case "literal":
  52.                 return $node["value"];
  54.             default:
  55.                 return false;
  56.         }
  57.     }
  59.     public function getInitial()
  60.     {
  61.         return $this->_initial;
  62.     }
  64.     public function getFinal()
  65.     {
  66.         return $this->_final;
  67.     }
  68. }

最后，我们替换Robots模型中的查询方法，以使用我们创建的自定义类：

  1. <?php
  3. use Phalcon\Mvc\Model;
  5. class Robots extends Model
  6. {
  7.     public static function find($parameters = null)
  8.     {
  9.         if (!is_array($parameters)) {
  10.             $parameters = [$parameters];
  11.         }
  13.         $builder = new CustomQueryBuilder($parameters);
  15.         $builder->from(get_called_class());
  17.         $query = $builder->getQuery();
  19.         if (isset($parameters["bind"])) {
  20.             return $query->execute($parameters["bind"]);
  21.         } else {
  22.             return $query->execute();
  23.         }
  24.     }
  25. }

缓存 PHQL 查询计划（Caching of PHQL planning）

像大多数现代的操作系统一样PHQL内部会缓存执行计划，如果同样的语句多次执行，PHQL会使用之前生成的查询计划以提升系统的性能， 对开发者来说只采用绑定参数的形式传递参数即可实现：

  1. <?php
  3. for ($i = 1; $i <= 10; $i++) {
  4.     $phql = "SELECT * FROM Store\Robots WHERE id = " . $i;
  6.     $robots = $this->modelsManager->executeQuery($phql);
  8.     // ...
  9. }

上面的例子中，Phalcon产生了10个查询计划，这导致了应用的内存使用量增加。重写以上代码，我们使用绑定参数的这个优点可以减少系统和数据库的过多操作：

  1. <?php
  3. $phql = "SELECT * FROM Store\Robots WHERE id = ?0";
  5. for ($i = 1; $i <= 10; $i++) {
  6.     $robots = $this->modelsManager->executeQuery(
  7.         $phql,
  8.         [
  9.             $i,
  10.         ]
  11.     );
  13.     // ...
  14. }

使用PHQL查询亦可以提升查询性能：

  1. <?php
  3. $phql = "SELECT * FROM Store\Robots WHERE id = ?0";
  5. $query = $this->modelsManager->createQuery($phql);
  7. for ($i = 1; $i <= 10; $i++) {
  8.     $robots = $query->execute(
  9.         $phql,
  10.         [
  11.             $i,
  12.         ]
  13.     );
  15.     // ...
  16. }

预先准备的查询语句 的查询计划亦可以被大多数的数据库所缓存，这样可以减少执行的时间，也可以使我们的系统免受 SQL注入 的影响。