API Lightweight Java Object cache [chiusa]

Domanda

Sto cercando un'API per la memorizzazione nella cache di oggetti in memoria Java. Qualche consiglio? Quali soluzioni hai utilizzato in passato?

attuale

In questo momento, sto solo usando una mappa:

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

Requisiti

Devo estendere la cache per includere funzionalità di base come:

• Dimensione massima
• Tempo di vivere

Tuttavia, non ho bisogno di funzionalità più sofisticate come:

• Accesso da più processi (server di cache)
• Persistenza (su disco)

Suggerimenti

Memorizzazione nella cache in memoria:

• Guava CacheBuilder - sviluppo attivo. Vedi questa presentazione .
• LRUMap - Configurazione tramite API. Nessun TTL. Non costruito appositamente per la memorizzazione nella cache.
• whirlycache - configurazione XML. Mailing list. Ultimo aggiornamento 2006.
• cache4j - configurazione XML. Documentazione in russo. Ultimo aggiornamento 2006.

Memorizzazione nella cache aziendale:

• JCS - Proprietà config. Ampia documentazione.
• Ehcache : configurazione XML. Ampia documentazione. Di gran lunga il più popolare secondo i risultati di Google.

EHCache è molto carino. Puoi creare una cache in memoria. Controlla i loro esempi di codice per un esempio di creazione di una cache in memoria. Puoi specificare una dimensione massima e un tempo per vivere.

EHCache offre alcune funzionalità avanzate, ma se non sei interessato a usarle, non farlo. Ma è bello sapere che ci sono se le tue esigenze cambiano.

Ecco una cache in memoria. Creato in codice, senza file di configurazione.

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

Crea una cache che conterrà 200 elementi e ha un ttl di 24 ore.

Mi piace molto MapMakerquello fornito con Google Guava ( API )

Il JavaDoc ha un esempio piuttosto accurato che dimostra sia la sua facilità d'uso che la sua potenza:

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);
         }
       });

Inoltre, la versione 10.0 di Guava ha introdotto il com.google.common.cachepacchetto molto più ampio (c'è una bella voce wiki su come usarli ).

Puoi anche controllare la mia piccola libreria cache chiamata KittyCache su:

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

Esistono alcuni benchmark delle prestazioni rispetto a ehcache.

Viene utilizzato nel progetto SimpleJPA come cache di secondo livello.

Puoi controllare LinkedHashMap per implementare una semplice cache senza jar di terze parti:

    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;
        }
    };

quindi puoi ottenere dalla cache come

    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);
        }
    }

resto a sinistra come esercizio per il lettore :)

MapMaker di Guava è stato sostituito dalla loro classe CacheBuilder .

JCS è provato e vero. Anche se è leggero per quanto riguarda i meccanismi di cache, potresti scavare nel codice effettivo e imitare ciò che fanno con HashMap sotto le coperte esattamente ciò di cui hai bisogno e non di più. Sembra che tu abbia un'idea abbastanza chiara di quello che stai cercando.

memcached ha un client per Java. http://www.danga.com/memcached/ Richiede un processo separato per essere un server di cache, ma potente.