SWARMCACHE - Part1
Traduction de la documentation officielle.
(Mehdi KASMI - Architecte Technique - mehdi.kasmi@unilog.fr)
Comment ça Marche ?
Le principe est simple. Chaque serveur instancie son propre gestionnaire. Pour chaque type dobjets que le serveur veut cacher, on instancie un cache et on le déclare dans le Gestionnaire.
Le gestionnaire fait partie dun groupe multicast , et communique par ce biais avec les autres gestionnaires du groupe. Lorsquun Objet est libéré dun cache, le manager le notifie à tous les autres gestionnaires du groupe qui sassurent que lobjet est bien libéré de leurs caches respectifs. Le résultat est qu'un serveur n'aura pas dans sa mémoire cache de version erronée d'un objet qui aura été mis à jour ou supprimé sur un autre serveur.
Notez que les Gestionnaires doivent seulement communiquer entre eux quand un objet est supprimé d'une mémoire cache. ce qui arrive quand un objet est mis à jour ou supprimé. Les Gestionnaires ne coopèrent pas au-delà de cela. Cela signifie que la quantité de communications inter serveur est proportionnelle à la quantité de mise à jour ou suppression d'éléments dans l'application. Comme les communications sont multipoint, en antémémoire des hôtes ne sont pas proportionnels au nombre d'hôtes. Remarquez aussi qu'il n'y a aucun "serveur maître", tous les hôtes sont des noeuds égaux. Ainsi l'opération de la mémoire cache distribuée est très robuste.
SwarmCache est conçu pour être intégré dans la couche de persistance d'une Application Java. Une fois intégré au moteur de persistance, SwarmCache devrait être transparent aux couches plus hautes du logiciel. SwarmCache ne supporte pas directement la gestion de transaction qui peut être accompli en enveloppant les objets (Wrapper) mis en antémémoire et en stockant quelques données de transaction supplémentaires. Ce sera décrit et probablement mis en uvre plus tard dans le Framework.
Swarmcache requiert les jars suivants:
à swarmcache.jar
à jgroups-all.jar
à commons-collections.jar
à commons-logging.jar
Pour la plupart des applications, il est suffisant de se servir de la classe « CacheFactory » pour configurer et utiliser SwarmCache.
Voici un exemple :
import net.sf.swarmcache.*;
...
CacheFactory cacheFactory;
...
// Configure and Initialize the cache manager
CacheConfiguration conf = new CacheConfiguration();
conf.setCacheType(CacheConfiguration.TYPE_LRU);
cacheFactory = new CacheFactory(conf);
...
// Create a new cache, using a name that describes
// what kind of object we will store
ObjectCache cache = cacheFactory.createCache("People");...
// Store something in the cache
String key = "0001";
String person = "John Watkinson";
cache.put(key, person);
...
// Retrieve something from the cache
String person = (String)cache.get("0001");System.out.println(person);
...
// Clear an object from the cache
// (This results in the sending of a
// multicast message to other caching hosts)
cache.clear("0001");String person = (String)cache.get("0001");// The following will print 'null'
System.out.println(person);
L'exemple est simple, l'exécution de ce code sur plusieurs machines d'un réseau (cluster) implique que leurs mémoires cache est cohérentes.
Notez que les clefs utilisées doivent être des objets sérialisable - Elles doivent implémenter l'interface java.io.Serializable.
Les objets qui sont stockés dans la mémoire cache n'ont pas besoin d'être "serializable". Et bien sûr, les clefs doivent être limitées en taille pour optimiser les transmissions entre nuds.
Pour s'assurer d'avoir des clefs distinctes, il est est conseillé d'utilisé un cache par type d'objet manipulé.
L'utilisation de SwarmCache dans un Moteur de Persistance
Voici un code skeleton démontrant comment SwarmCache peut être intégré à un outil de gestion de la persistance.
La classe suivante permet de faire persister un objet de type Personne.
public class PersonEntity extends GenericEntity {
ObjectCache cache;
public PersonEntity(CacheFactory cacheFactory) { cache = cacheFactory.createCache("Person"); // * Other initialization here
}
...
public Person get(long key) { Long cacheKey = new Long(key);
Person person = (Person)cache.get(cachekey);
if (person == null) { // * Get the object from the database
if (person != null) { // Put it in the cache
cache.put(cacheKey, person);
}
}
return person;
}
...
public void insert(Person person) { // * Do database insert
// Add new object to cache
Long cacheKey = new Long(person.getKey());
cache.put(cacheKey, person);
}
...
public void update(Person person) { // * Do database update
// Remove object from cache
// (This causes all caches in the group to be notified)
Long cacheKey = new Long(person.getKey());
cache.clear(cacheKey);
// Re-add the object to the cache
cache.put(cacheKey, person);
}
...
public void delete(long key) { // * Do database delete
// Remove object from cache
// (This causes all caches in the group to be notified)
Long cacheKey = new Long(key);
cache.clear(cacheKey);
}
...
}
Commentaires