Caching Pattern: Comment appelez-vous (et comment remplacez-vous) OpenSymphony OsCache "groupe" paradigme

Question

Un problème de mise en cache pour les gourous cache.

Contexte

Nous avons utilisé OSCache depuis plusieurs années et envisager de passer à un meilleur/plus forte/produit mise en cache plus rapide/activement développé de OpenSymphony.

Problème

Nous avons utilisé la fonction « entrée de groupe » de OSCache et n'a pas trouvé ailleurs. En bref, OsCache vous permet de spécifier un ou plusieurs groupes à l'entrée temps d'insertion 'En résumé, OsCache vous permet de spécifier un ou plusieurs groupes à l'entrée . Plus tard, vous pouvez invalider un "groupe d'entrées", sans connaître les clés de chaque entrée.

OSCache Exemple

est le code exemple ici en utilisant ce mécanisme:

Object[] groups = {"mammal", "Northern Hemisphere", "cloven-feet"} 
myCache.put(myKey, myValue , groups); 
// later you can flush all 'mammal' entries 
myCache.flushGroup("mammal") 
// or flush all 'cloven-foot' 
myCache.flushGroup("cloven-foot") 

Alternative: matcher Mécanisme

Nous utilisons un autre cache home-grown écrit par un ancien membre de l'équipe qui utilise un modèle 'key matcher' pour invalider les entrées

Dans cette approche, vous définiriez votre classe 'clé' et matcher » comme suit:

public class AnimalKey 
{ 
    String fRegion; 
    String fPhylum; 
    String fFootType; 

    ..getters and setters go here 

} 

matcher:

public class RegionMatcher implements ICacheKeyMatcher 
{ 
    String fRegion; 

    public RegionMatcher(String pRegion) 
    { 
    fRegion=pRegion; 
    } 

    public boolean isMatch(Obect pKey) 
    { 
     boolean bMatch=false; 
     if (pKey instanceof AnimalKey) 
     { 
     AnimalKey key = (AninmalKey) pKey); 
     bMatch=(fRegion.equals(key.getRegion()); 
     } 
    } 
} 

Utilisation:

myCache.put(new AnimalKey("North America","mammal", "chews-the-cud"); 
//remove all entries for 'north america' 
IKeyMatcher myMatcher= new AnimalKeyMatcher("North America"); 
myCache.removeMatching(myMatcher); 

Ce mécanisme a mise en œuvre simple, mais a un rendement négatif: il doit passer à travers chaque entrée pour invalider un groupe. (Bien que ce soit encore plus rapide que de filer dans une base de données).

La question

• (Attention: cela peut sembler stupide) Qu'est-ce que vous appel cette fonctionnalité? OsCache l'appelle "groupes de cache". Ni JbossCache ni EhCache ne semblent ni le définir ni l'implémenter. Domaine? Région? Royaume?
• Existe-t-il des modèles standard pour ce paradigme "groupes/régions de cache"?
• Comment les produits de mise en cache à étoile montante (par exemple, ehcache, cohérence, jbosscache) gèrent ce problème
• Ce paradigme n'est pas dans la spécification jcache, n'est-ce pas? (JSR-107)
• Comment gérez-vous "l'invalidation de masse"? Les caches sont géniales jusqu'à ce qu'elles deviennent viciées. Une API qui vous permet d'invalider de larges andains est une aide précieuse. (Par exemple.administrateur souhaite appuyer sur un bouton et effacer toutes les entrées de poste mises en cache pour, disons, un forum particulier)

grâce

se

Answer 1

moi aussi mis en œuvre une approche matcher en essayant de l'échelle d'un système existant avec un processus d'invalidation ad hoc. La nature de O (n) n'était pas un problème puisque les caches étaient petits, l'invalidation a été exécutée sur un thread non-utilisateur et il n'a pas tenu les verrous ainsi il n'y avait pas une pénalité de contention. Cela était nécessaire pour la correspondance avec des clés qui traversent des caches, par exemple pour invalider toutes les données d'une entreprise dans des caches réparties dans l'application. C'était vraiment un problème de n'avoir aucun centre de conception donc l'application était monolithique et mal décomposée. Lorsque nous l'avons réécrit sur la base de services de domaine, j'ai adopté une stratégie différente. Nous avions maintenant le domaine pour les données spécifiques centralisées dans des caches spécifiques, comme pour les configurations, de sorte qu'il est devenu un désir de multi-recherche. Dans ce cas, nous avons réalisé que la clé était juste un sous-ensemble de la valeur, de sorte que nous puissions extraire toutes les clés après chargement à partir des métadonnées (par exemple des annotations). Cela a permis un regroupement à granularité fine et un modèle de programmation pratique grâce à notre abstraction de cache. J'ai publié la structure de données de base, IndexMap, dans un tutoriel sur l'idée. Ce n'est pas destiné à une utilisation directe en dehors d'une abstraction, mais cela résout mieux le problème de regroupement que nous avons rencontré.

http://code.google.com/p/concurrentlinkedhashmap/wiki/IndexableCache