缓存¶

概览¶

The Phalcon\Cache\Cache是一个组件，为你的 Phalcon 应用程序提供了一种轻量级但灵活的缓存机制。

频繁使用的数据或已经处理/计算好的数据，可以存储在缓存中以便于快速检索。由于Phalcon\Cache\Cache是使用 Zephir 编写的，因此会被编译为 C 代码，这样可以在从任何存储容器获取数据时获得更高性能并减少开销。以下是一些适合使用缓存的例子：

你正在进行复杂的计算，而输出结果并不频繁变更
你一直使用相同的数据生成 HTML（相同的 HTML）
你持续访问数据库中的数据，这些数据不经常变化。

注意

即便在实现了缓存之后，你也应该始终在一段时间内检查你的缓存后端的命中率，以确保你的缓存策略是最优的。

Phalcon\Cache\Cache组件依赖Phalcon\Storage组件。Phalcon\Storage被分为两个类别：序列化器和适配器。

缓存¶

实例化一个新的Phalcon\Cache\Cache组件时，你需要传入一个Phalcon\Cache\Adapter\*类或者实现Phalcon\Cache\Adapter\AdapterInterface接口的类。关于适配器和序列化器的详细说明，请参见下文。

<?php

use Phalcon\Cache\Cache;
use Phalcon\Cache\AdapterFactory;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();
$adapterFactory    = new AdapterFactory($serializerFactory);

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200
];

$adapter = $adapterFactory->newInstance('apcu', $options);

$cache = new Cache($adapter);

操作¶

缓存组件实现了与PSR-16的标准，但没有实现特定的接口。有一个实现了PSR-16的包可用，该包使用了Phalcon\Cache\Cache。该包位于点击这里。要使用它，你需要安装 Phalcon，然后通过 Composer 安装代理包。

composer require phalcon/proxy-psr16

使用代理类可以让你遵循PSR-16并在需要该接口的其他包中使用它。

每个缓存组件都包含一个提供的缓存适配器，它负责所有操作。

`get` - `getMultiple`¶

要从缓存中获取数据，需要调用get()方法，并传递一个键和默认值。如果该键存在且未过期，则会返回其中存储的数据。否则将返回传入的defaultValue值（默认为null）。

$value = $cache->get('my-key');

$value = $cache->get('my-key', 'default');

如果你想通过一次调用获取多个键的数据，你可以调用getMultiple()方法，并传入所需的键数组。这个方法将返回一个key=>value键值对数组。不存在或已过期的缓存键将以defaultValue作为值（默认为null）。

$value = $cache->getMultiple(['my-key1', 'my-key2']);

$value = $cache->getMultiple(['my-key1', 'my-key2'], 'default');

注意

如果使用了 Redis 适配器，适配器将使用mget命令来获取多个键。这种方式从 Redis 获取多个键更高效。

`has`¶

要检查某个键是否存在于缓存中（或尚未过期），你可以调用has()方法。该方法将返回true表示键存在，或false。

$exists = $cache->has('my-key');

`set` - `setMultiple`¶

表示不存在。set()方法。方法接受你要存储的数据对应的键以及要存储的值。数据类型必须支持序列化，即 PHP 类型或实现了序列化接口的对象。最后一个可选参数是该条目的 TTL（存活时间）值。如果底层适配器不支持此功能，该选项可能不可用。方法将在成功时返回true表示键存在，或false否则返回 false。如果有任意一个键未能成功存储，该方法将返回false.

$result = $cache->set('my-key', $data);

如果你希望通过一次调用存储多个元素，可以调用setMultiple()方法，并传入 key => value 键值对数组用于多值设置操作。与set方法类似，最后一个可选参数是 TTL（生存时间）。该方法将在成功时返回true表示键存在，或false。

$value = $cache->setMultiple(
    [
        'my-key1' => $data1, 
        'my-key2' => $data2,
    ],
    9600
);

`delete` - `deleteMultiple` - `clear`¶

在失败时返回 false。delete()方法，并传入一个键。该方法在成功时返回true，失败时返回false。

$result = $cache->delete('my-key');

如果你想通过一次调用删除多个键，你可以调用deleteMultiple()方法，并传入所需键的数组。方法将在成功时返回true，失败时返回false。如果有任意一个键未能成功删除，方法将返回false。

$result = $cache->deleteMultiple(['my-key1', 'my-key2']);

如果你想清除所有键，你可以调用clear()方法。该方法将在成功时返回true，失败时返回false。

工厂¶

`newInstance`¶

我们可以很容易地使用Phalcon\Cache\Cache关键字创建一个new类。然而，Phalcon 提供了Phalcon\Cache\CacheFactory类，使得开发者可以轻松地实例化缓存对象。工厂接受一个Phalcon\Cache\AdapterFactory对象（其本身又需要一个Phalcon\Storage\SerializerFactory对象），并能够使用选择的适配器和选项实例化必要的缓存类。工厂总是返回一个新的Phalcon\Cache\Cache.

实例。Apcu适配器和Json序列化器创建一个缓存对象：

<?php

use Phalcon\Cache\CacheFactory;
use Phalcon\Cache\AdapterFactory;
use Phalcon\Storage\SerializerFactory;

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
];

$serializerFactory = new SerializerFactory();
$adapterFactory    = new AdapterFactory(
    $serializerFactory,
    $options
);

$cacheFactory = new CacheFactory($adapterFactory);

$cache = $cacheFactory->newInstance('apcu');

`load`¶

缓存工厂还提供了load方法，该方法接受一个配置对象。此对象可以是一个数组或Phalcon\Config\Config对象，它包含了用来配置缓存的指令。该对象要求含有必要的指令信息的adapter元素以及options元素。

<?php

use Phalcon\Cache\CacheFactory;
use Phalcon\Cache\AdapterFactory;
use Phalcon\Storage\SerializerFactory;

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
];

$serializerFactory = new SerializerFactory();
$adapterFactory    = new AdapterFactory(
    $serializerFactory,
    $options
);

$cacheFactory = new CacheFactory($adapterFactory);

$cacheOptions = [
    'adapter' => 'apcu',
    'options' => [
        'prefix' => 'my-prefix',
    ],
];

$cache = $cacheFactory->load($cacheOptions);

异常¶

缓存组件抛出的所有异常都将属于Phalcon\Cache\Exception\Exception类型，Psr\SimpleCache\CacheException接口。此外还有Phalcon\Cache\Exception\InvalidArgumentException它也实现了Psr\SimpleCache\CacheException接口。当提供给组件或其子组件的数据无效时，就会抛出此类异常。你可以使用这些异常来捕获仅来自本组件的特定异常。

<?php

use Phalcon\Cache\Exception\Exception;
use Phalcon\Mvc\Controller;

class IndexController extends Controller
{
    public function index()
    {
        try {
            $content = $this->cache->get('some-key');
        } catch (Exception $ex) {
            echo $ex->getMessage();
        }
    }
}

序列化器¶

The Phalcon\Storage\Serializer命名空间提供了实现Serializable接口并因此暴露serialize和unserialize方法的类。这些类的目的是在保存数据到存储之前和从存储中检索数据之后对其进行转换。

注意

所有适配器的默认序列化器是Phalcon\Storage\Serializer\Php，它使用 PHP 的serialize和unserialize方法。这些方法可以满足大多数应用程序的需求。然而，开发人员可能希望使用更高效的序列化器，例如igbinary，它更快并且具有更好的压缩效果。

缓存适配器可以被配置为使用不同的序列化器。可用的序列化器包括：

`Base64`¶

此序列化器使用base64_encode和base64_decode方法来序列化数据。输入必须是类型string，因此此序列化器有明显的限制。

`Igbinary`¶

The igbinary序列化依赖于igbinary_serialize和igbinary_unserialize方法。这些方法由igbinaryPHP 扩展公开，该扩展必须安装并加载到目标系统上。

`Json`¶

The JSON序列化器使用json_encode和json_decode。目标系统必须具备 PHP 的 JSON 支持。

`MemcachedIgbinary`¶

当使用Memcached时可以使用此序列化器。它对应于Memcached中内置的 PHP 序列化器。

`MemcachedJson`¶

当使用Memcached时可以使用此序列化器。它对应于Memcached中内置的 PHP 序列化器。

`MemcachedPhp`¶

当使用Memcached时可以使用此序列化器。它对应于Memcached中内置的 PHP 序列化器。

`Msgpack`¶

类似于igbinary超全局变量。如果cookie存在于任一集合中，则返回msgpack序列化器使用msgpack_pack和msgpack_unpack进行数据的序列化和反序列化。这与igbinary之一是最快的和最有效的序列化器之一。但是，它要求目标系统加载了msgpackPHP 扩展。

`None`¶

此序列化器不转换数据。它的serialize和unserialize获取和设置数据而不改变它。

`Php`¶

这是默认的序列化器。它使用 PHP 的serialize和unserialize方法进行数据转换。

`RedisIgbinary`¶

当使用Redis时可以使用此序列化器。它对应于Redis中内置的 PHP 序列化器。

`RedisJson`¶

当使用Redis时可以使用此序列化器。它对应于Redis中内置的 PHP 序列化器。

`RedisMsgpack`¶

当使用Redis时可以使用此序列化器。它对应于Redis中内置的 PHP 序列化器。

`RedisNone`¶

当使用Redis时可以使用此序列化器。它对应于Redis中内置的 PHP 序列化器。

`RedisPhp`¶

当使用Redis时可以使用此序列化器。它对应于Redis中内置的 PHP 序列化器。

自定义¶

Phalcon 还提供了Phalcon\Storage\Serializer\SerializerInterface`，可以在自定义类中实现。该类可以提供您需要的序列化功能。

<?php

namespace MyApp\Storage\Serializer;

use Phalcon\Storage\SerializerInterface;

class Garble implements SerializerInterface
{
    /**
     * Data storage
     * 
     * @var string
     */
    private $data = '';

    /**
     * Return the stored data
     * 
     * @return string
     */
    public function getData(): string
    {
        return $this->data;
    }       

    /**
     * Serializes data
     */
    public function serialize(): string
    {
        return rot13($this->data);
    }

    /**
     * Set the data
     * 
     * @var Garble
     *
     * @return Garble
     */
    public function setData($data): Garble
    {
        $this->data = (string) $data;

        return $this;
    }       

    /**
     * Unserializes data
     */
    public function unserialize($data): void
    {
        $this->data = str_rot13($data);
    }
}

使用它：

<?php

namespace MyApp;

use MyApp\Storage\Serializer\Garble;

$data = 'I came, I saw, I conquered.';
$garble = new Garble();

$garble
    ->setData($data)
    ->serialize()  
;

echo $garble->getData(); // "V pnzr, V fnj, V pbadhrerq."

$encrypted = 'V pnzr, V fnj, V pbadhrerq.';

$garble->unserialize($encrypted);

echo $garble->getData(); // "I came, I saw, I conquered."

序列化工厂¶

虽然所有的序列化类都可以通过new关键字实例化，Phalcon 提供了Phalcon\Storage\SerializerFactory类，以便开发者可以轻松实例化序列化类。上述所有序列化器都在工厂中注册，并在调用时延迟加载。工厂还允许您注册额外的（自定义）序列化类。唯一需要考虑的是选择序列化器名称时要与现有的进行比较。如果定义了相同的名称，则会覆盖内置的序列化器。工厂中的对象会被缓存，因此如果您在同一个请求中使用相同参数调用newInstance()方法，你会得到相同的对象返回。

下面的例子展示了如何创建一个Json序列化器，可以使用new关键字或工厂：

<?php

use Phalcon\Storage\Serializer\Json; 
use Phalcon\Storage\SerializerFactory;

$jsonSerializer = new Json();

$factory        = new SerializerFactory();
$jsonSerializer = $factory->newInstance('json');

你可以用于工厂的参数是：

名称	类
`base64`	Phalcon\Storage\Serializer\Base64
`igbinary`	Phalcon\Storage\Serializer\Igbinary
`json`	Phalcon\Storage\Serializer\Json
`memcached_igbinary`	Phalcon\Storage\Serializer\MemcachedIgbinary
`memcached_json`	Phalcon\Storage\Serializer\MemcachedJson
`memcached_php`	Phalcon\Storage\Serializer\MemcachedPhp
`msgpack`	Phalcon\Storage\Serializer\Msgpack
`none`	Phalcon\Storage\Serializer\None
`php`	Phalcon\Storage\Serializer\Php
`redis_igbinary`	Phalcon\Storage\Serializer\RedisIgbinary
`redis_json`	Phalcon\Storage\Serializer\RedisJson
`redis_msgpack`	Phalcon\Storage\Serializer\RedisMsgpack
`redis_none`	Phalcon\Storage\Serializer\RedisNone
`redis_php`	Phalcon\Storage\Serializer\RedisPhp

适配器¶

The Phalcon\Cache\Adapter命名空间提供了实现Phalcon\Cache\Adapter\AdapterInterface接口。它暴露了一系列通用方法，用于执行存储适配器或缓存后端的操作。这些适配器充当了对应后端代码的包装器。

可用的方法有：

方法	描述
`clear`	清空/清除缓存
`decrement`	减少存储的数字
`delete`	从适配器中删除数据
`get`	从适配器读取数据
`getAdapter`	返回已连接的适配器或连接到后端服务器（们）
`getKeys`	返回存储的所有键（可选过滤参数）
`getPrefix`	返回键的前缀
`has`	检查某个元素是否存在缓存中
`increment`	增加存储的数字
`set`	在适配器中存储数据

注意

The getAdapter()方法返回连接的适配器。这为开发者提供了更大的灵活性，因为它可以用于执行每个适配器提供的其他方法。例如，对于Redis适配器你可以用来获取连接的对象并调用getAdapter()，以获取连接的对象并调用zAdd, zRange，以及Phalcon适配器未公开的其他方法。

要构造这些对象之一，你需要传递一个Phalcon\Storage\SerializerFactory对象到构造函数中，并可选地为所选适配器提供一些参数。下面列出了选项列表。

可用的适配器有：

`Apcu`¶

此适配器使用Apcu存储数据。为了使用此适配器，你需要在目标系统中启用apcu。这个类并不使用实际的适配器，因为功能是通过apcuPHP函数暴露的。apcu_*选项

选项	默认值
`defaultSerializer`	`Php`
`lifetime`	`3600`
`serializer`	`null`
`prefix`	`ph-apcu-`

下面的例子演示了如何创建一个新的Apcu缓存适配器，它将使用Phalcon\Storage\Serializer\Json序列化器，并具有默认生命周期7200。

<?php

use Phalcon\Cache\Adapter\Apcu;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
];

$adapter = new Apcu($serializerFactory, $options);

上面的例子使用了Phalcon\Storage\SerializerFactory对象和defaultSerializer选项来告诉适配器实例化相关的序列化器。

`Libmemcached`¶

此适配器利用PHP的memcached扩展连接到Memcached服务器。使用的适配器是Memcached类的一个实例，在第一次需要活动连接的事件后创建。

选项	默认值
`defaultSerializer`	`Php`
`lifetime`	`3600`
`serializer`	`null`
`prefix`	`ph-memc-`
`servers[0]['host']`	`127.0.0.1`
`servers[0]['port']`	`11211`
`servers[0]['weight']`	`1`
`persistentId`	`ph-mcid-`
`saslAuthData['user']`
`saslAuthData['pass']`
`client[\Memcached::OPT_CONNECT_TIMEOUT]`	`10`
`client[\Memcached::OPT_DISTRIBUTION]`	`\Memcached::DISTRIBUTION_CONSISTENT`
`client[\Memcached::OPT_SERVER_FAILURE_LIMIT]`	`2`
`client[\Memcached::OPT_REMOVE_FAILED_SERVERS]`	`true`
`client[\Memcached::OPT_RETRY_TIMEOUT]`	`1`

你可以在构造函数中传递的选项数组中指定多个服务器。如果定义了SASL数据，适配器将尝试使用传递的数据进行身份验证。如果选项中有错误，或者该类无法向池中添加一个或多个服务器，则会抛出异常。Phalcon\Storage\Exception异常。

下面的例子演示了如何创建一个新的Libmemcached缓存适配器，它将使用Phalcon\Storage\Serializer\Json序列化器，并具有默认生命周期7200。它将使用10.4.13.100作为第一台服务器，权重为1连接到端口11211和10.4.13.110作为第二台服务器，权重为5再次连接到端口11211.

<?php

use Phalcon\Cache\Adapter\Libmemcached;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
    'servers'           => [
        0 => [
            'host'   => '10.4.13.100',
            'port'   => 11211,
            'weight' => 1,
        ],
        1 => [
            'host'   => '10.4.13.110',
            'port'   => 11211,
            'weight' => 5,
        ],
    ],
];

$adapter = new Libmemcached($serializerFactory, $options);

上面的例子使用了Phalcon\Storage\SerializerFactory对象和defaultSerializer选项来告诉适配器实例化相关的序列化器。

序列化器：该Memcached类是Phalcon\Cache\Adapter\Libmemcached使用的适配器，提供了开箱即用的序列化支持。内置的序列化器包括：

\Memcached::SERIALIZER_PHP
\Memcached::SERIALIZER_JSON
\Memcached::SERIALIZER_IGBINARY

The igbinary内置序列化器仅在igbinary存在于目标系统并且Memcached扩展已编译时可用。要启用这些序列化器，可以使用Phalcon\Storage\Serializer\MemcachedIgbinary, Phalcon\Storage\Serializer\MemcachedJson或Phalcon\Storage\Serializer\MemcachedPhp

`Memory`¶

此适配器使用计算机的内存存储数据。由于所有数据都存储在内存中，因此没有持久性，这意味着一旦请求完成，数据就会丢失。此适配器可用于测试或特定请求期间的临时存储。构造函数的可用选项包括：

选项	默认值
`defaultSerializer`	`Php`
`lifetime`	`3600`
`serializer`	`null`
`prefix`	`ph-memo-`

下面的例子演示了如何创建一个新的Memory缓存适配器，它将使用Phalcon\Storage\Serializer\Json序列化器，并具有默认生命周期7200。

<?php

use Phalcon\Cache\Adapter\Memory;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
];

$adapter = new Memory($serializerFactory, $options);

上面的例子使用了Phalcon\Storage\SerializerFactory对象和defaultSerializer选项来告诉适配器实例化相关的序列化器。

`Redis`¶

此适配器利用PHP的redis扩展连接到Redis服务器。使用的适配器是Redis类的一个实例，在第一次需要活动连接的事件后创建。

选项	默认值
`defaultSerializer`	`Php`
`lifetime`	`3600`
`serializer`	`null`
`prefix`	`ph-reds-`
`host`	`127.0.0.1`
`port`	`6379`
`index`	`1`
`persistent`	`false`
`auth`
`socket`

如果auth数据定义了，适配器将尝试使用传递的数据进行身份验证。如果选项中有错误，或者服务器无法连接或身份验证失败，则会抛出异常。Phalcon\Storage\Exception异常。

下面的例子演示了如何创建一个新的Redis缓存适配器，它将使用Phalcon\Storage\Serializer\Json序列化器，并具有默认生命周期7200。它将使用10.4.13.100作为主机，连接到端口6379，并选择索引1.

<?php

use Phalcon\Cache\Adapter\Redis;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
    'host'              => '10.4.13.100',
    'port'              => 6379,
    'index'             => 1,
];

$adapter = new Redis($serializerFactory, $options);

上面的例子使用了Phalcon\Storage\SerializerFactory对象和defaultSerializer选项来告诉适配器实例化相关的序列化器。

序列化器：该Redis类是Phalcon\Cache\Adapter\Redis使用的适配器，提供了开箱即用的序列化支持。内置的序列化器包括：

\Redis::SERIALIZER_NONE
\Redis::SERIALIZER_PHP
\Redis::SERIALIZER_IGBINARY
\Redis::SERIALIZER_MSGPACK

The igbinary和内置序列化器仅在igbinary存在于目标系统并且Redis扩展已编译时可用。同样的规则适用于msgpack内置序列化器。它仅在msgpack存在于目标系统且Redis扩展已编译时可用。要启用这些序列化器，可以使用Phalcon\Storage\Serializer\RedisIgbinary, Phalcon\Storage\Serializer\RedisJson, Phalcon\Storage\Serializer\RedisMsgpack, Phalcon\Storage\Serializer\RedisNone或Phalcon\Storage\Serializer\RedisPhp.

注意 increment - decrement

目前存在一个问题与Redis，其中内部Redis序列化器不会跳过标量值，因为它只能存储字符串。结果是，如果你在increment后使用set对于数字，将不会返回一个数字：

存储数字并使用increment（或decrement的方法是删除内部序列化器Redis

$cache->getAdapter()->setOption(\Redis::OPT_SERIALIZER, \Redis::SERIALIZER_NONE);

或者你可以使用increment代替使用set在设置键值对的第一个设置时：

$cache->delete('my-key');
$cache->increment('my-key', 2);
echo $cache->get('my-key');      // 2
$cache->increment('my-key', 3);
echo $cache->get('my-key');      // 3

`Stream`¶

这个适配器是最简单的设置方式，因为它使用目标系统的文件系统（只需要一个可写的缓存路径）。它是速度最慢的缓存适配器之一，因为数据必须写入文件系统。每个创建的文件对应一个存储的键。该文件包含用于计算缓存元素生命周期的额外元数据，导致对文件系统的额外读取和写入操作。

选项	默认值
`defaultSerializer`	`Php`
`lifetime`	`3600`
`serializer`	`null`
`prefix`	`phstrm-`
`storageDir`

如果storageDir未定义，则Phalcon\Storage\Exception异常。

注意

适配器利用逻辑根据传递的键名将文件存储在单独的子目录中，从而避免了too many files in one folder在 Windows 或 Linux 系统中存在的限制。

下面的例子演示了如何创建一个新的Stream缓存适配器，它将使用Phalcon\Storage\Serializer\Json序列化器，并具有默认的生命周期 7200。它会将缓存的数据存储在/data/storage/cache.

<?php

use Phalcon\Cache\Adapter\Stream;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
    'storageDir'        => '/data/storage/cache',
];

$adapter = new Stream($serializerFactory, $options);

上面的例子使用了Phalcon\Storage\SerializerFactory对象和defaultSerializer选项来告诉适配器实例化相关的序列化器。

自定义¶

Phalcon 还提供了Phalcon\Cache\Adapter\AdapterInterface可以在一个自定义类中实现。这个类可以提供你需要的缓存适配器功能。

<?php

namespace MyApp\Cache\Adapter;

use Phalcon\Cache\Adapter\AdapterInterface;

class Custom implements AdapterInterface
{
    /**
     * Flushes/clears the cache
     */
    public function clear(): bool
    {
        // Custom implementation
    }

    /**
     * Decrements a stored number
     */
    public function decrement(string $key, int $value = 1)
    {
        // Custom implementation
    }

    /**
     * Deletes data from the adapter
     */
    public function delete(string $key): bool
    {
        Custom implementation
    }

    /**
     * Reads data from the adapter
     */
    public function get(string $key)
    {
        // Custom implementation
    }

    /**
     * Returns the already connected adapter or connects to the backend server(s)
     */
    public function getAdapter()
    {
        // Custom implementation
    }

    /**
     * Returns all the keys stored. If a filter has been passed the 
     * keys that match the filter will be returned
     */
    public function getKeys(string $prefix = ""): array
    {
        // Custom implementation
    }

    /**
     * Returns the prefix for the keys
     */
    public function getPrefix(): string
    {
        // Custom implementation
    }

    /**
     * Checks if an element exists in the cache
     */
    public function has(string $key): bool
    {
        // Custom implementation
    }

    /**
     * Increments a stored number
     */
    public function increment(string $key, int $value = 1)
    {
        // Custom implementation
    }

    /**
     * Stores data in the adapter
     */
    public function set(string $key, $value, $ttl = null): bool
    {
        // Custom implementation
    }
}

使用它：

<?php

namespace MyApp;

use MyApp\Cache\Adapter\Custom;

$custom = new Custom();

$custom->set('my-key', $data);

适配器工厂¶

虽然所有适配器类都可以通过new关键字实例化，Phalcon 提供了Phalcon\Cache\AdapterFactory类，这样你可以轻松地实例化缓存适配器类。以上所有适配器都在工厂中注册，并在被调用时惰性加载。该工厂还允许你注册额外的（自定义）适配器类。唯一需要注意的是选择与现有适配器不同的名称。如果你定义了相同的名称，将会覆盖内置的名称。对象在工厂中被缓存，因此如果你调用newInstance()方法，你会得到相同的对象返回。

下面的例子展示了如何创建一个Apcu缓存适配器，使用new关键字或工厂：

<?php

use Phalcon\Cache\Adapter\Apcu;
use Phalcon\Storage\Serializer\Json;

$jsonSerializer = new Json();

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
    'serializer'        => $jsonSerializer,
];

$adapter = new Apcu(null, $options);

<?php

use Phalcon\Cache\AdapterFactory;
use Phalcon\Storage\SerializerFactory;

$serializerFactory = new SerializerFactory();
$adapterFactory    = new AdapterFactory($serializerFactory);

$options = [
    'defaultSerializer' => 'Json',
    'lifetime'          => 7200,
];

$adapter = $adapterFactory->newInstance('apcu', $options);

你可以用于工厂的参数是：

名称	适配器
`apcu`	Phalcon\Cache\Adapter\Apcu
`libmemcached`	Phalcon\Cache\Adapter\Libmemcached
`memory`	Phalcon\Cache\Adapter\Memory
`redis`	Phalcon\Cache\Adapter\Redis
`stream`	Phalcon\Cache\Adapter\Stream

事件¶

The Phalcon\Cache\AbstractCache对象实现了Phalcon\Events\EventsAware接口。因此，getEventsManager()和setEventsManager()可供您使用。

事件	描述	可以停止操作
`beforeSet`	在设置值之前触发	否
`afterSet`	在值设置后触发	否
`beforeGet`	在请求值之前触发	否
`afterGet`	在值请求后触发	否
`beforeHas`	在请求值之前触发	否
`afterHas`	在值请求后触发	否
`beforeDelete`	在删除值之前触发	否
`afterDelete`	在值删除后触发	否
`beforeIncrement`	在值递增之前触发	否
`afterIncrement`	在值递增后触发	否
`beforeDecrement`	在值递减之前触发	否
`afterDecrement`	在值递减后触发	否

缓存¶

概览¶

缓存¶

操作¶

get - getMultiple¶

has¶

set - setMultiple¶

delete - deleteMultiple - clear¶

工厂¶

newInstance¶

load¶

异常¶

序列化器¶

Base64¶

Igbinary¶

Json¶

MemcachedIgbinary¶

MemcachedJson¶

MemcachedPhp¶

Msgpack¶

None¶

Php¶

RedisIgbinary¶

RedisJson¶

RedisMsgpack¶

RedisNone¶

RedisPhp¶

自定义¶

序列化工厂¶

适配器¶

Apcu¶

Libmemcached¶

Memory¶

Redis¶

Stream¶

自定义¶

适配器工厂¶

事件¶

`get` - `getMultiple`¶

`has`¶

`set` - `setMultiple`¶

`delete` - `deleteMultiple` - `clear`¶

`newInstance`¶

`load`¶

`Base64`¶

`Igbinary`¶

`Json`¶

`MemcachedIgbinary`¶

`MemcachedJson`¶

`MemcachedPhp`¶

`Msgpack`¶

`None`¶

`Php`¶

`RedisIgbinary`¶

`RedisJson`¶

`RedisMsgpack`¶

`RedisNone`¶

`RedisPhp`¶

`Apcu`¶

`Libmemcached`¶

`Memory`¶

`Redis`¶

`Stream`¶