Download the PHP package vectorface/cache without Composer

Cache

This is a simple cache library. It exposes several caching mechanisms (with different semantics), along with support for adapting to a PSR-16 compatible interface, and atomic counters. Nothing fancy.

Interface

The cache interface exposes get and set methods, which do exactly what you'd expect from a cache:

The interface supports optional time-to-live (expiry) where supported by the underlying cache type.

The Cache interface is a superset of PSR-16's CacheInterface: it has the same get, set, delete, clear, has, getMultiple, setMultiple, and deleteMultiple methods with the same signatures and semantics. It adds clean, which removes expired entries, and flush, an alias for clear. Any cache in this library can be handed to PSR-16 tooling via the SimpleCacheAdapter (see below).

Available Implementations

• APCCache: APCu, using the apcu extension
• MCCache: Memcache, using the memcache extension. Takes a configured Memcache instance.
• MemcachedCache: Memcache, using the memcached extension. Takes a configured Memcached instance.
• RedisCache: Redis, using either the phpredis extension or the php-redis-client library. Takes a connected Redis or RedisClient instance and an optional key prefix.
• NullCache: A blackhole for your data
• PHPCache: Stores values in a local variable, for one script execution only.
• SQLCache: Values stored in an SQL table, accessed via PDO. Takes a PDO instance.
• TempFileCache: Store values in temporary files. Does not support atomic counting.
• TieredCache: Layer any of the above caches on top of each other to form a hybrid cache. Does not support atomic counting.
• LogDecorator: Wraps any of the above and logs each operation to a PSR-3 logger.

Real-World Use

Why would you want to use this? It makes it almost trivial to switch your underlying cache implementation without any code changes. This can be especially useful for testing.

Atomic Counters

A common use of caches is to implement atomic counting, i.e. incrementing or decrementing by some amount. Atomicity is important for reliability in distributed environments to avoid race conditions.

Not all cache implementations in this library support atomic counting, because it either isn't possible or doesn't make sense in that context.

Tiered Caching

Another particularly useful feature is the ability to stack caches. You can put fast caches in front of successively slower caches, presumably where the fast caches will have less storage and evict items used less often.

Caching Expensive Calls

CacheHelper::fetch wraps the common get-or-compute pattern: return the cached value if there is one, otherwise call a callback, cache its result, and return it.

Results of null are treated as a miss and are not cached.

Logging

LogDecorator wraps any cache and logs every operation (including hits, misses, and approximate value sizes) to a PSR-3 logger at the level of your choice. Without a logger it is a transparent pass-through.

PSR-16 Support

If you need interoperability with other tooling that support PSR-16 SimpleCache, you may use the SimpleCacheAdapter class which can wrap any of the cache implementations in this library.