PHPackages                             noizu-labs/fragmented-keys - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Caching](/categories/caching)
4. /
5. noizu-labs/fragmented-keys

ActiveLibrary[Caching](/categories/caching)

noizu-labs/fragmented-keys
==========================

Fragmented Key Management and Invalidation Library for use with Memcache.

0.2.1.1(11y ago)179.4k1[1 issues](https://github.com/noizu/fragmented-keys/issues)1mitPHP

Since Aug 8Pushed 11y ago4 watchersCompare

[ Source](https://github.com/noizu/fragmented-keys)[ Packagist](https://packagist.org/packages/noizu-labs/fragmented-keys)[ RSS](/packages/noizu-labs-fragmented-keys/feed)WikiDiscussions master Synced 3w ago

READMEChangelogDependencies (1)Versions (4)Used By (1)

FragmentedKey
=============

[](#fragmentedkey)

tl;dr; A php library for managing cache invalidation by tracking tag-value pair versions on memcache, apc or other storage device and generating derived cache keys based on those values.

For a Java port of this library please see ()

Overview
--------

[](#overview)

Fragmented Keys provide a straightforward way to manage and invalidate composite cache keys.

It does this by persisting in memcache (or other back-end persistance layer of your choice) tag-instance versionining information. When constructing composite/fragmented keys these tags and their versions are used to generate the final composite key.

Thus if you wanted to tie something to to the granularity of say a specific thing like username you can do the following:

```
  $GlobalGreetingTag = new Tag\Standard("Global.Greeting", "global");
  $UserUserNameTag = new Tag\Standard("User.Username", $userId);
  $keyobj = new Key\Standard(
      "CacheDataThatInvalidatesWhenUserNamesAreChanged",
      array($UserUserNameTag, $GlobalGreetingTag)
  );
  $cacheKey = $keyObj->getKeyStr();
```

You can then Invalidate only items linked to your user's username by calling:

```
  $UserUserNameTag = new Tag\Standard("User.Username", $userId);
  $UserUserNameTag->Increment();
```

Behind the scenes this looks something like blocking out everything below the \[Targeted User\] bucket.

```
  AllKey
    \
     \-[ ]Global.Greeting
            \
             \-[ ]Other User Cached Greeting
              \
               \-[x]Targeted User

```

Or you could just go crazy and invalidate all keys that rely on Global.Greating

```
  $GlobalGreetingTag->Increment();
```

but amke sure your database is ready for it.

```
  AllKey
    \
     \-[x]Global.Greeting
            \
             \-[x]Other User Cached Greeting
              \
               \-[x]Target User

```

Setup & Installation
========================

[](#setup--installation)

Installation
------------

[](#installation)

This project is available on composer, just add noizu-labs/fragmented-keys to your required list. "require": { "noizu-labs/fragmented-keys": "dev-master", }

Setup
-----

[](#setup)

The code depends on a Memcached, Memcache or APC handle being available and configured along with a global prefix to avoid collisions.

```
$m = new \Memcached;
\NoizuLabs\FragmentedKeys\Configuration\setGlobalCacheHandler(new \NoizuLabs\FragmentedKeys\CacheHandler\Memcached($m));
\NoizuLabs\FragmentedKeys\Configuration\setGlobalPrefix("MyApp");

//you may override the handler per tag by calling
$tag->setCacheHandler($alternativeHandler);

//or by including a handler in you constructor.
$tag = new Tag\Standard("Users", 1234, null, CacheHandler\Apc());
```

Components
==========

[](#components)

Cache Handlers
--------------

[](#cache-handlers)

```
$apcHandler = \NoizuLabs\FragmentedKeys\CacheHandler\Apc();
$inMemoryHandler = \NoizuLabs\FragmentedKeys\CacheHandler\Memory();
$memcachedHandler = \NoizuLabs\FragmentedKeys\CacheHandler\Memcached(new Memcached());
$memcacheHandler = \NoizuLabs\FragmentedKeys\CacheHandler\Memcache(new Memcache());
```

Tags
----

[](#tags)

Tags are a logical grouping that you would under certain circumstance invalidate assocaited cached data.

A User:$id pair, a Site:$siteId, etc. This library takes they tag-instance pairs and appends @version fields to them so that when you want to invalidate a large swatch of related items you don't need to send dozens of invalidate requests to memcache, or apc. You just make a single $tag->increment() call and any associated keys that us that tag-instance (User:$userId) will generate new keys;

Tag ClassDescriptionStandardBasic Key. Persists version to specified cache handlerDelayed\*Basic Key with built in Delay. Only internal key versions greater than the specified delay will cause a new version to be returned. Allowing you to pull cached content that only updates every hours, 30 seconds, etc.ConstantKey with Constant associated Version. E.g. version can only be set once at construction time. useful for incorporating non version tag-instance details in large composite keys\*Delayed is not yet implemented

Key Rings
---------

[](#key-rings)

Key rings help may your life easier by letting you define common key structures one and then reuse him in your code as needed. You can tweak settings in your config, or even define custom keys that always include some additional tag s *with out requiring your cache caller to manually include them!*

Example

```