PHP cache library, with adapters for e.g. Memcached, Redis, Couchbase, APC(u), SQL and additional capabilities (e.g. transactions, stampede protection) built on top.

Overview

Scrapbook PHP cache

Build status Code coverage Code quality Latest version Downloads total License

Donate/Support: Support

Documentation: https://www.scrapbook.cash - API reference: https://docs.scrapbook.cash

Table of contents

Installation & usage

Simply add a dependency on matthiasmullie/scrapbook to your composer.json file if you use Composer to manage the dependencies of your project:

composer require matthiasmullie/scrapbook

The exact bootstrapping will depend on which adapter, features and interface you will want to use, all of which are detailed below.

This library is built in layers that are all KeyValueStore implementations that you can wrap inside one another if you want to add more features.

Here's a simple example: a Memcached-backed psr/cache with stampede protection.

// create \Memcached object pointing to your Memcached server
$client = new \Memcached();
$client->addServer('localhost', 11211);
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\Memcached($client);

// create stampede protector layer over our real cache
$cache = new \MatthiasMullie\Scrapbook\Scale\StampedeProtector($cache);

// create Pool (psr/cache) object from cache engine
$pool = new \MatthiasMullie\Scrapbook\Psr6\Pool($cache);

// get item from Pool
$item = $pool->getItem('key');

// get item value
$value = $item->get();

// ... or change the value & store it to cache
$item->set('updated-value');
$pool->save($item);

Just take a look at this "build your cache" section to generate the exact configuration you'd like to use (adapter, interface, features) and some example code.

Adapters

Memcached

Memcached is an in-memory key-value store for small chunks of arbitrary data (strings, objects) from results of database calls, API calls, or page rendering.

The PECL Memcached extension is used to interface with the Memcached server. Just provide a valid \Memcached object to the Memcached adapter:

// create \Memcached object pointing to your Memcached server
$client = new \Memcached();
$client->addServer('localhost', 11211);
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\Memcached($client);

Redis

Redis is often referred to as a data structure server since keys can contain strings, hashes, lists, sets, sorted sets, bitmaps and hyperloglogs.

The PECL Redis extension is used to interface with the Redis server. Just provide a valid \Redis object to the Redis adapter:

// create \Redis object pointing to your Redis server
$client = new \Redis();
$client->connect('127.0.0.1');
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\Redis($client);

Couchbase

Engineered to meet the elastic scalability, consistent high performance, always-on availability, and data mobility requirements of mission critical applications.

The PECL Couchbase extension is used to interface with the Couchbase server. Just provide a valid \CouchbaseBucket object to the Couchbase adapter:

// create \CouchbaseBucket object pointing to your Couchbase server
$cluster = new \CouchbaseCluster('couchbase://localhost');
$bucket = $cluster->openBucket('default');
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\Couchbase($bucket);

APC(u)

APC is a free and open opcode cache for PHP. Its goal is to provide a free, open, and robust framework for caching and optimizing PHP intermediate code.

With APC, there is no "cache server", the data is just cached on the executing machine and available to all PHP processes on that machine. The PECL APC or APCu extensions can be used.

// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\Apc();

MySQL

MySQL is the world's most popular open source database. MySQL can cost-effectively help you deliver high performance, scalable database applications.

While a database is not a genuine cache, it can also serve as key-value store. Just don't expect the same kind of performance you'd expect from a dedicated cache server.

But there could be a good reason to use a database-based cache: it's convenient if you already use a database and it may have other benefits (like persistent storage, replication.)

// create \PDO object pointing to your MySQL server
$client = new PDO('mysql:dbname=cache;host=127.0.0.1', 'root', '');
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\MySQL($client);

PostgreSQL

PostgreSQL has a proven architecture that has earned it a strong reputation for reliability, data integrity, and correctness.

While a database is not a genuine cache, it can also serve as key-value store. Just don't expect the same kind of performance you'd expect from a dedicated cache server.

But there could be a good reason to use a database-based cache: it's convenient if you already use a database and it may have other benefits (like persistent storage, replication.)

// create \PDO object pointing to your PostgreSQL server
$client = new PDO('pgsql:user=postgres dbname=cache password=');
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\PostgreSQL($client);

SQLite

SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.

While a database is not a genuine cache, it can also serve as key-value store. Just don't expect the same kind of performance you'd expect from a dedicated cache server.

// create \PDO object pointing to your SQLite server
$client = new PDO('sqlite:cache.db');
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\SQLite($client);

Filesystem

While it's not the fastest kind of cache in terms of I/O access times, opening a file usually still beats redoing expensive computations.

The filesystem-based adapter uses league\flysystem to abstract away the file operations, and will work with all kinds of storage that league\filesystem provides.

// create Flysystem object
$adapter = new \League\Flysystem\Adapter\Local('/path/to/cache', LOCK_EX);
$filesystem = new \League\Flysystem\Filesystem($adapter);
// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\Flysystem($filesystem);

Memory

PHP can keep data in memory, too! PHP arrays as storage are particularly useful to run tests against, since you don't have to install any other service.

Stuffing values in memory is mostly useless: they'll drop out at the end of the request. Unless you're using these cached values more than once in the same request, cache will always be empty and there's little reason to use this cache.

However, it is extremely useful when unittesting: you can run your entire test suite on this memory-based store, instead of setting up cache services and making sure they're in a pristine state...

// create Scrapbook KeyValueStore object
$cache = new \MatthiasMullie\Scrapbook\Adapters\MemoryStore();

Features

In addition to the default cache functionality (like get & set), Scrapbook comes with a few neat little features. These are all implemented in their own little object that implements KeyValueStore, and wraps around a KeyValueStore. In other words, any feature can just be wrapped inside another one or on top of any adapter.

Local buffer

BufferedStore helps reduce requests to your real cache. If you need the request the same value more than once (from various places in your code), it can be a pain to keep that value around. Requesting it again from cache would be easier, but then you get some latency from the connection to the cache server.

BufferedStore will keep known values (items that you've already requested or written yourself) in memory. Every time you need that value in the same request, it'll just get it from memory instead of going out to the cache server.

Just wrap the BufferedStore layer around your adapter (or other features):

// create buffered cache layer over our real cache
$cache = new \MatthiasMullie\Scrapbook\Buffered\BufferedStore($cache);

Transactions

TransactionalStore makes it possible to defer writes to a later point in time. Similar to transactions in databases, all deferred writes can be rolled back or committed all at once to ensure the data that is stored is reliable and complete. All of it will be stored, or nothing at all.

You may want to process code throughout your codebase, but not commit it any changes until everything has successfully been validated & written to permanent storage.

While inside a transaction, you don't have to worry about data consistency. Inside a transaction, even if it has not yet been committed, you'll always be served the one you intend to store. In other words, when you write a new value to cache but have not yet committed it, you'll still get that value when you query for it. Should you rollback, or fail to commit (because data stored by another process caused your commit to fail), then you'll get the original value from cache instead of the one your intended to commit.

Just wrap the TransactionalStore layer around your adapter (or other features):

// create transactional cache layer over our real cache
$cache = new \MatthiasMullie\Scrapbook\Buffered\TransactionalStore($cache);

And TA-DA, you can use transactions!

// begin a transaction
$cache->begin();

// set a value
// it won't be stored in real cache until commit() is called
$cache->set('key', 'value'); // returns true

// get a value
// it won't get it from the real cache (where it is not yet set), it'll be read
// from PHP memory
$cache->get('key'); // returns 'value'

// now commit write operations, this will effectively propagate the update to
// 'key' to the real cache
$cache->commit();

// ... or rollback, to discard uncommitted changes!
$cache->rollback();

Stampede protection

A cache stampede happens when there are a lot of requests for data that is not currently in cache, causing a lot of concurrent complex operations. For example:

  • cache expires for something that is often under very heavy load
  • sudden unexpected high load on something that is likely to not be in cache

In those cases, this huge amount of requests for data that is not in cache at that time causes that expensive operation to be executed a lot of times, all at once.

StampedeProtector is designed counteract that. If a value can't be found in cache, a placeholder will be stored to indicate it was requested but didn't exist. Every follow-up request for a short period of time will find that indication and know another process is already generating that result, so those will just wait until it becomes available, instead of crippling the servers.

Just wrap the StampedeProtector layer around your adapter (or other features):

// create stampede protector layer over our real cache
$cache = new \MatthiasMullie\Scrapbook\Scale\StampedeProtector($cache);

Sharding

When you have too much data for (or requests to) 1 little server, this'll let you shard it over multiple cache servers. All data will automatically be distributed evenly across your server pool, so all the individual cache servers only get a fraction of the data & traffic.

Pass the individual KeyValueStore objects that compose the cache server pool into this constructor & the data will be sharded over them according to the order the cache servers were passed into this constructor (so make sure to always keep the order the same.)

The sharding is spread evenly and all cache servers will roughly receive the same amount of cache keys. If some servers are bigger than others, you can offset this by adding that cache server's KeyValueStore object more than once.

Data can even be sharded among different adapters: one server in the shard pool can be Redis while another can be Memcached. Not sure why you would want to do that, but you could!

Just wrap the Shard layer around your adapter (or other features):

// boilerplate code example with Redis, but any
// MatthiasMullie\Scrapbook\KeyValueStore adapter will work
$client = new \Redis();
$client->connect('192.168.1.100');
$cache1 = new \MatthiasMullie\Scrapbook\Adapters\Redis($client);

// a second Redis server...
$client2 = new \Redis();
$client2->connect('192.168.1.101');
$cache2 = new \MatthiasMullie\Scrapbook\Adapters\Redis($client);

// create shard layer over our real caches
// now $cache will automatically distribute the data across both servers
$cache = new \MatthiasMullie\Scrapbook\Scale\Shard($cache1, $cache2);

Interfaces

Scrapbook supports 3 different interfaces. There's the Scrapbook-specific KeyValueStore, and then there are 2 PSR interfaces put forward by the PHP FIG.

KeyValueStore

KeyValueStore is the cornerstone of this project. It is the interface that provides the most cache operations: get, getMulti, set, setMulti, delete, deleteMulti, add, replace, cas, increment, decrement, touch & flush.

If you've ever used Memcached before, KeyValueStore will look very similar, since it's inspired by/modeled after that API.

All adapters & features implement this interface. If you have complex cache needs (like being able to cas), this is the one to stick to.

A detailed list of the KeyValueStore interface & its methods can be found in the documentation.

psr/cache

PSR-6 (a PHP-FIG standard) is a drastically different cache model than KeyValueStore & psr/simple-cache: instead of directly querying values from the cache, psr/cache basically operates on value objects (Item) to perform the changes, which then feed back to the cache (Pool.)

It doesn't let you do too many operations. If get, set, delete (and their *multi counterparts) and delete is all you need, you're probably better off using this (or psr/simple-cache, see below) as this interface is also supported by other cache libraries.

You can easily use psr/cache by wrapping it around any KeyValueStore object:

// create Pool object from Scrapbook KeyValueStore object
$pool = new \MatthiasMullie\Scrapbook\Psr6\Pool($cache);

// get item from Pool
$item = $pool->getItem('key');

// get item value
$value = $item->get();

// ... or change the value & store it to cache
$item->set('updated-value');
$pool->save($item);

A detailed list of the PSR-6 interface & its methods can be found in the documentation.

psr/simple-cache

PSR-16 (a PHP-FIG standard) is a second PHP-FIG cache standard. It's a driver model just like KeyValueStore, and it works very much in the same way.

It doesn't let you do too many operations. If get, set, delete (and their *multi counterparts) and delete is all you need, you're probably better off using this (or psr/cache, see above) as this interface is also supported by other cache libraries.

You can easily use psr/simple-cache by wrapping it around any KeyValueStore object:

// create Simplecache object from Scrapbook KeyValueStore object
$simplecache = new \MatthiasMullie\Scrapbook\Psr16\SimpleCache($cache);

// get value from cache
$value = $simplecache->get('key');

// ... or store a new value to cache
$simplecache->set('key', 'updated-value');

A detailed list of the PSR-16 interface & its methods can be found in the documentation.

Collections

Collections, or namespaces if you wish, are isolated cache subsets that will only ever provide access to the values within that context.

It is not possible to set/fetch data across collections. Setting the same key in 2 different collections will store 2 different values that can only be retrieved from their respective collection.

Flushing a collection will only flush those specific keys and will leave keys in other collections untouched.

Flushing the server, however, will wipe out everything, including data in any of the collections on that server.

Here's a simple example:

// let's create a Memcached cache object
$client = new \Memcached();
$client->addServer('localhost', 11211);
$cache = new \MatthiasMullie\Scrapbook\Adapters\Memcached($client);

$articleCache = $cache->collection('articles');
$sessionCache = $cache->collection('sessions');

// all of these are different keys
$cache->set('key', 'value one');
$articleCache->set('key', 'value two');
$sessionCache->set('key', 'value three');

// this clears our the entire 'articles' subset (thus removing 'value two'),
// while leaving everything else untouched
$articleCache->flush();

// this removes everything from the server, including all of its subsets
// ('value one' and 'value three' will also be deleted)
$cache->flush();

getCollection is available on all KeyValueStore implementations (so for every adapter & feature that may wrap around it) and also returns a KeyValueStore object. While it is not part of the PSR interfaces, you can create your collections first and then wrap all of your collections inside their own psr/cache or psr/simple-cache representations, like so:

$articleCache = $cache->collection('articles');
$sessionCache = $cache->collection('sessions');

// create Pool objects from both KeyValueStore collections
$articlePool = new \MatthiasMullie\Scrapbook\Psr6\Pool($articleCache);
$sessionPool = new \MatthiasMullie\Scrapbook\Psr6\Pool($sessionCache);

Compatibility

Where possible, Scrapbook supports PHP versions 5.3 up to the current version, as well as HHVM. Differences in the exact implementation of the cache backends across these versions & platforms will be mitigated within Scrapbook to ensure uniform behavior.

Compatibility with all of these versions & platforms is tested on Travis CI using the official PHP Docker images, which means that PHP<=5.5 is no longer actively being tested even though these versions are supported by Scrapbook.

Cache backends that do not have an implementation for a particular version or platform (Flysystem, on older PHP versions) are obviously not supported.

Compatibility with old software versions will not be broken easily. Not unless there is a compelling reason to do so, like security or performance implications. Syntactic sugar is not a reason to break compatibility.

License

Scrapbook is MIT licensed.

Comments
  • Collection or server?

    Collection or server?

    Hi Matthias,

    Please take a look at this comment I posted for the PSR-16 review.

    I have the same issue/question regarding Scrapbook.

    For example, Scrapbook's Memcached-adapter takes a Memcached instance via the constructor - and while I could use Memcached::OPT_PREFIX_KEY with setOption() prior to constructing the adapter, the implementation calls Memcached::flush(), which would flush the entire server, not just a single collection, so while the issue of key-collisions could be addressed that way, this approach does not effectively result in truly having multiple collections.

    Of course there are cases where you wish to clear the entire cache (typically on deployment) but there are certainly cases where you wish to clear only a collection.

    Thoughts?

    opened by mindplay-dk 19
  • Allow tags on PSR-6

    Allow tags on PSR-6

    Im really impressed by this library. Really good job!

    Here is a PR that allow your PSR-6 implementation to support tagging. It uses a trait and interface from https://github.com/php-cache/taggable-cache

    (I am the author of the trait)

    opened by Nyholm 8
  • Unit tests fail with Couchbase server v5.0.0

    Unit tests fail with Couchbase server v5.0.0

    I'm not a Couchbase guru, so I'm not sure what's going on

    $this->client->manager()->info() now returns null....

    $manager->flush() doesn't seem to flush?

    opened by bkdotcom 7
  • Invalid key: test:string. Contains (a) character(s) reserved for future extension:

    Invalid key: test:string. Contains (a) character(s) reserved for future extension:

    $backend = new \Redis();
    $backend->connect('localhost');
    $backend->select(1);
    
    $cache = new \MatthiasMullie\Scrapbook\Adapters\Redis( $backend );
    $pool = new \MatthiasMullie\Scrapbook\Psr6\Pool($cache);
    
    $item = $pool->getItem('test:string');
    
    var_dump($item->get());
    

    return:

    PHP Fatal error:  Uncaught MatthiasMullie\Scrapbook\Psr6\InvalidArgumentException: Invalid key: test:string. Contains (a) character(s) reserved for future extension: {}()/\@: in .../vendor/matthiasmullie/scrapbook/src/Psr6/Pool.php:247
    Stack trace:
    #0 .../vendor/matthiasmullie/scrapbook/src/Psr6/Pool.php(58): MatthiasMullie\Scrapbook\Psr6\Pool->assertValidKey()
    #1 .../test_redis_scrapbook.php(14): MatthiasMullie\Scrapbook\Psr6\Pool->getItem()
    #2 {main} thrown in .../vendor/matthiasmullie/scrapbook/src/Psr6/Pool.php on line 247
    

    but Redis allowed this key:

    [email protected]:/etc/redis# redis-cli --version
    redis-cli 6.2.6
    
    [email protected]:/etc/redis# redis-cli
    
    127.0.0.1:6379> set test:string 'foobar'
    OK
    127.0.0.1:6379> get test:string
    "foobar"
    127.0.0.1:6379> 
    

    WTF?

    opened by KarelWintersky 4
  • Stampede protection with

    Stampede protection with "stale-while-revalidate" strategy?

    I'm fetching data from an external API, and these requests can take 3-5 seconds to complete.

    The information I'm getting from this API is secondary content for the page - so it's okay to cache this probably for 5 minutes before pulling updated data from the API.

    The stampede protection strategy will take care of the problem of making too many requests to this external API.

    Being cached for 5 minutes, it's also not crucial to have the latest information within a 5-minute window, and so I'm looking for a means of implementing a "stale while revalidate" pattern.

    That is, I don't want to block the rendering of a page for any user while fetching an updated version of the cached content - if the content has expired, I'd like to trigger an update in the background (e.g. via register_shutdown_handler()) and just return what we have.

    Would it make sense to expand the stampede protection decorator with a feature like that?

    Or is it best left to a separate decorator?

    Is this feature useful/common enough that you might want it in your library?

    opened by mindplay-dk 4
  • Incompatibility with Memcached 3

    Incompatibility with Memcached 3

    I am checking if a non-existing key is set in Memcached. When I use SimpleCache::has I get the following error:

    Warning: Memcached::getMulti() expects parameter 2 to be integer, array given in .../matthiasmullie/scrapbook/src/Adapters/Memcached.php on line 72

    In Memcached v3 (the only version properly supported for PHP 7) the signature of getMulti() changed and now expects 2 arguments instead of the 3 before. This means that any usage of getMulti() with the Memcached adapter will result in error. This should be handled in a graceful manner, so both v2 and v3 of the Memcached API are supported. The code causing headaches is on this line in Adapters\Memcached.

    Scrapbook version: 1.4 PHP version: 7.1 Memcached version: 3.0

    opened by martin-georgiev 4
  • Added integration tests

    Added integration tests

    I also updated the PHP version. We do not test with php53 so we dont know if it works or not. Also php53 has not been officially supported since 2014.

    opened by Nyholm 4
  • psr6 problems

    psr6 problems

    just installed the package, used the default memory store and wrapped it with a psr6 implementation, the tried this:

    $pool = $app->get(\Psr\Cache\CacheItemPoolInterface::class);//aliased to \MatthiasMullie\Scrapbook\Psr6\Pool(\MatthiasMullie\Scrapbook\Adapters\MemoryStore())
    
            $item = $pool->getItem('widget_list'); // this is all thats needed to cause the error
            if (!$item->isHit()) {
                $value = ['array', 'of', 'values'];
                $item->set($value);
                $pool->save($item);
            }
            return $item->get();
    

    this is what i got back:

    Fatal Error: Class MatthiasMullie\Scrapbook\Psr6\Item contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (Psr\Cache\CacheItemInterface::exists, Psr\Cache\CacheItemInterface::setExpiration) in ...

    opened by leemason 4
  • Postgres set on conflict update

    Postgres set on conflict update

    Since version 9.5 postgres (9.6 latest) has on conflict update set syntax. This syntax avoids lots of error record in postgres logs (duplicate key error). https://www.postgresql.org/docs/9.5/static/sql-insert.html

    opened by AlexKomrakov 3
  • Fixed StampedeProtector for phpredis > 4.0.0

    Fixed StampedeProtector for phpredis > 4.0.0

    This will break for phpredis < 4.0.0 so its not backwards compatibility.

    I tried to run the tests on my local machine but with no luck.

    Step 6/7 : COPY tests/Docker tests/docker
     ---> Using cache
     ---> 474441258ea4
    Step 7/7 : RUN tests/docker/build-php.sh
     ---> Running in 923b6ca5d785
    /bin/sh: 1: tests/docker/build-php.sh: not found
    ERROR: Service 'php' failed to build : The command '/bin/sh -c tests/docker/build-php.sh' returned a non-zero code: 127
    
    opened by ValiNiculae 2
  • Stampede not working for phpredis > 4.0.0

    Stampede not working for phpredis > 4.0.0

    Hi!

    There seems to be an issue with the StampedeProtector since phpredis 4.0.0. The exists method now returns an int instead of TRUE/FALSE: https://github.com/phpredis/phpredis#exists

    image

    Another issue I found is with the TTL of the stampede protect. We set it in milliseconds, in the constructor, but when we do: $success[$key] = $this->cache->add($this->stampedeKey($key), '', $this->sla); (in [email protected]) is set in seconds.

    I will open a pull request to fix/discuss these issues.

    Thanks!

    opened by ValiNiculae 2
Owner
Matthias Mullie
Senior software engineer with an appetite for complex problems.
Matthias Mullie
A simple cache library. Implements different adapters that you can use and change easily by a manager or similar.

Desarolla2 Cache A simple cache library, implementing the PSR-16 standard using immutable objects. Caching is typically used throughout an applicatito

Daniel González 129 Nov 20, 2022
CLI App and library to manage apc & opcache.

CacheTool - Manage cache in the CLI CacheTool allows you to work with APCu, OPcache, and the file status cache through the CLI. It will connect to a F

Samuel Gordalina 1.4k Nov 22, 2022
A fast, light-weight proxy for memcached and redis

twemproxy (nutcracker) twemproxy (pronounced "two-em-proxy"), aka nutcracker is a fast and lightweight proxy for memcached and redis protocol. It was

Twitter 11.6k Dec 1, 2022
PHP cache implementation supporting memcached

php cache implementation (PSR-6 and PSR-16) Support for memcached and APCu is included. Memcached $memcached = new Memcached(); $memcached->addServer(

Michael Bretterklieber 1 Aug 11, 2022
Simple artisan command to debug your redis cache. Requires PHP 8.1 & Laravel 9

?? php artisan cache:debug Simple artisan command to debug your redis cache ?? Installation You can install the package via composer: composer require

Juan Pablo Barreto 19 Sep 18, 2022
Graphic stand-alone administration for memcached to monitor and debug purpose

PHPMemcachedAdmin Graphic stand-alone administration for memcached to monitor and debug purpose This program allows to see in real-time (top-like) or

Cyrille Mahieux 249 Nov 15, 2022
More Than Just a Cache: Redis Data Structures

More Than Just a Cache: Redis Data Structures Redis is a popular key-value store, commonly used as a cache or message broker service. However, it can

Andy Snell 2 Oct 16, 2021
Redis Object Cache for WordPress

A persistent object cache backend for WordPress powered by Redis. Supports Predis, PhpRedis, Relay, Credis, HHVM, replication and clustering.

Rhubarb Group 288 Nov 22, 2022
A thin PSR-6 cache wrapper with a generic interface to various caching backends emphasising cache tagging and indexing.

Apix Cache, cache-tagging for PHP Apix Cache is a generic and thin cache wrapper with a PSR-6 interface to various caching backends and emphasising ca

Apix 111 Nov 26, 2022
Yii Caching Library - Redis Handler

Yii Caching Library - Redis Handler This package provides the Redis handler and implements PSR-16 cache. Requirements PHP 7.4 or higher. Installation

Yii Software 4 Oct 9, 2022
A library providing platform-specific user directory paths, such as config and cache

Phirs A library providing platform-specific user directory paths, such as config and cache. Inspired by dirs-rs.

Mohammad Amin Chitgarha 7 Mar 1, 2022
A flexible and feature-complete Redis client for PHP.

Predis A flexible and feature-complete Redis client for PHP 7.2 and newer. ATTENTION: you are on the README file of an unstable branch of Predis speci

Predis 7.3k Nov 29, 2022
A PHP extension for Redis

PhpRedis The phpredis extension provides an API for communicating with the Redis key-value store. It is released under the PHP License, version 3.01.

null 9.5k Nov 25, 2022
Zend_Cache backend using Redis with full support for tags

This Zend_Cache backend allows you to use a Redis server as a central cache storage. Tags are fully supported without the use of TwoLevels cache so this backend is great for use on a single machine or in a cluster. Works with any Zend Framework project including all versions of Magento!

Colin Mollenhour 387 Jun 9, 2022
The cache component provides a Promise-based CacheInterface and an in-memory ArrayCache implementation of that

Cache Async, Promise-based cache interface for ReactPHP. The cache component provides a Promise-based CacheInterface and an in-memory ArrayCache imple

ReactPHP 329 Nov 21, 2022
LaraCache is an ORM based package for Laravel to create, update and manage cache items based on model queries

LaraCache Using this package, you can cache your heavy and most used queries. All you have to do is to define the CacheEntity objects in the model and

Mostafa Zeinivand 200 Nov 16, 2022
:zap: Simple Cache Abstraction Layer for PHP

⚡ Simple Cache Class This is a simple Cache Abstraction Layer for PHP >= 7.0 that provides a simple interaction with your cache-server. You can define

Lars Moelleken 26 Jun 9, 2022
LRU Cache implementation in PHP

PHP LRU Cache implementation Intro WTF is a LRU Cache? LRU stands for Least Recently Used. It's a type of cache that usually has a fixed capacity and

Rogério Vicente 61 Jun 23, 2022
Elephant - a highly performant PHP Cache Driver for Kirby 3

?? Kirby3 PHP Cache-Driver Elephant - a highly performant PHP Cache Driver for Kirby 3 Commerical Usage Support open source! This plugin is free but i

Bruno Meilick 11 Apr 6, 2022