API Lightweight Java Object Cache [fermé]

Question

Je recherche une API de mise en cache d'objets Java en mémoire. Des recommandations? Quelles solutions avez-vous utilisées dans le passé?

Actuel

Pour le moment, j'utilise juste une carte:

Map cache = new HashMap<String, Object>();
cache.put("key", value);

Exigences

J'ai besoin d'étendre le cache pour inclure des fonctionnalités de base telles que:

• taille max
• Temps de vivre

Cependant, je n'ai pas besoin de fonctionnalités plus sophistiquées telles que:

• Accès à partir de plusieurs processus (serveur de mise en cache)
• Persistance (sur le disque)

Suggestions

Mise en cache en mémoire:

• Guava CacheBuilder - développement actif. Voir cette présentation .
• LRUMap - Config via API. Pas de TTL. Pas spécialement conçu pour la mise en cache.
• whirlycache - configuration XML. Liste de diffusion. Dernière mise à jour 2006.
• cache4j - configuration XML. Documentation en russe. Dernière mise à jour 2006.

Mise en cache d'entreprise:

• JCS - Configuration des propriétés. Documentation complète.
• Ehcache - configuration XML. Documentation complète. De loin le plus populaire selon les hits de Google.

EHCache est très agréable. Vous pouvez créer un cache mémoire. Découvrez leurs exemples de code pour un exemple de création d'un cache en mémoire. Vous pouvez spécifier une taille maximale et une durée de vie.

EHCache offre certaines fonctionnalités avancées, mais si vous n'êtes pas intéressé à les utiliser, ne le faites pas. Mais il est bon de savoir qu'ils sont là si vos exigences changent.

Voici un cache en mémoire. Créé dans le code, sans fichiers de configuration.

CacheManager cacheManager = CacheManager.getInstance();
int oneDay = 24 * 60 * 60;
Cache memoryOnlyCache = new Cache("name", 200, false, false, oneDay, oneDay);
cacheManager.addCache(memoryOnlyCache);

Crée un cache qui contiendra 200 éléments et a un ttl de 24 heures.

J'aime vraiment le MapMakerqui vient avec Google Guava ( API )

Le JavaDoc a un exemple assez soigné qui démontre à la fois sa facilité d'utilisation et sa puissance:

ConcurrentMap<Key, Graph> graphs = new MapMaker()
   .concurrencyLevel(32)
   .softKeys()
   .weakValues()
   .expiration(30, TimeUnit.MINUTES)
   .makeComputingMap(
       new Function<Key, Graph>() {
         public Graph apply(Key key) {
           return createExpensiveGraph(key);
         }
       });

De plus, la version 10.0 de Guava a introduit le com.google.common.cachepackage beaucoup plus complet (il y a une belle entrée wiki sur la façon de les utiliser ).

Vous pouvez également consulter ma petite bibliothèque de cache appelée KittyCache à:

https://github.com/treeder/kitty-cache

Il existe des benchmarks de performance par rapport à ehcache.

Il est utilisé dans le projet SimpleJPA comme cache de deuxième niveau.

Vous pouvez consulter LinkedHashMap pour implémenter un cache simple sans jars tiers:

    Map <String, Foo> cache = new LinkedHashMap<String, Foo>(MAX_ENTRIES + 1, .75F, true) {

        public boolean removeEldestEntry(Map.Entry<String, Foo> eldest) {
            return size() > MAX_ENTRIES;
        }
    };

alors vous pouvez obtenir du cache comme

    Foo foo = cache.get(key);
    if (foo == null && !cache.containsKey(key)) {
        try {
            FooDAO fooDAO = DAOFactory.getFooDAO(conn);
            foo = fooDAO.getFooByKey(key);
            cache.put(key, foo);
        } catch (SQLException sqle) {
            logger.error("[getFoo] SQL Exception when accessing Foo", sqle);
        }
    }

reste laissé comme exercice pour le lecteur :)

MapMaker de Guava a été remplacé par sa classe CacheBuilder .

JCS a fait ses preuves . Même s'il est léger en ce qui concerne les mécanismes de mise en cache, vous pouvez creuser dans le code réel et imiter ce qu'ils font avec HashMap sous les couvertures pour exactement ce dont vous avez besoin et pas plus. Vous semblez avoir une assez bonne idée de ce que vous recherchez.

memcached a un client pour Java. http://www.danga.com/memcached/ Nécessite un processus séparé pour être un serveur de cache, mais chose puissante.