Leichte Java Object Cache API [geschlossen]

Frage

Ich suche nach einer Java In-Memory-Objekt-Caching-API. Irgendwelche Empfehlungen? Welche Lösungen haben Sie in der Vergangenheit verwendet?

Aktuell

Im Moment verwende ich nur eine Karte:

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

Bedarf

Ich muss den Cache um grundlegende Funktionen wie Folgendes erweitern:

• maximale Größe
• Zeit zu leben

Ich brauche jedoch keine anspruchsvolleren Funktionen wie:

• Zugriff von mehreren Prozessen (Caching-Server)
• Persistenz (auf Festplatte)

Vorschläge

In-Memory-Caching:

• Guava CacheBuilder - aktive Entwicklung. Siehe diese Präsentation .
• LRUMap - Konfiguration über API. Keine TTL. Nicht für das Caching gedacht.
• whirlycache - XML-Konfiguration Mailingliste. Letzte Aktualisierung 2006.
• cache4j - XML-Konfiguration Dokumentation in russischer Sprache. Letzte Aktualisierung 2006.

Enterprise-Caching:

• JCS - Eigenschaften config. Umfangreiche Dokumentation.
• Ehcache - XML-Konfiguration Umfangreiche Dokumentation. Bei weitem am beliebtesten laut Google-Hits.

EHCache ist sehr nett. Sie können einen In-Memory-Cache erstellen. In den Codebeispielen finden Sie ein Beispiel für die Erstellung eines In-Memory-Cache. Sie können eine maximale Größe und eine Lebenszeit angeben.

EHCache bietet einige erweiterte Funktionen, aber wenn Sie nicht daran interessiert sind, diese zu verwenden, tun Sie dies nicht. Aber es ist schön zu wissen, dass sie da sind, wenn sich Ihre Anforderungen jemals ändern.

Hier ist ein In-Memory-Cache. Erstellt im Code ohne Konfigurationsdateien.

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

Erstellt einen Cache mit 200 Elementen und einer Laufzeit von 24 Stunden.

Ich mag das MapMaker, was mit Google Guava ( API ) geliefert wird.

Der JavaDoc hat ein hübsches Beispiel, das sowohl seine Benutzerfreundlichkeit als auch seine Leistungsfähigkeit demonstriert:

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

Darüber hinaus wurde in Version 10.0 von Guava das viel umfangreichere com.google.common.cachePaket eingeführt (es gibt einen schönen Wiki-Eintrag zu deren Verwendung ).

Sie können auch meine kleine Cache-Bibliothek namens KittyCache unter folgender Adresse überprüfen:

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

Es gibt einige Leistungsbenchmarks gegenüber ehcache.

Es wird im SimpleJPA- Projekt als Cache der zweiten Ebene verwendet.

Sie können LinkedHashMap auschecken, um einen einfachen Cache ohne Jars von Drittanbietern zu implementieren:

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

dann kann man aus dem cache gerne abrufen

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

Rest links als Übung für den Leser :)

Guava des MapMaker wurde durch ihre ersetzt CacheBuilder Klasse.

JCS hat sich bewährt. Auch wenn es in Bezug auf die Caching-Mechanismen leicht ist, können Sie sich in den eigentlichen Code vertiefen und nachahmen, was sie mit HashMap unter der Decke tun, um genau das zu erreichen, was Sie brauchen, und nicht mehr. Sie scheinen eine ziemlich gute Vorstellung davon zu haben, wonach Sie suchen.

memcached hat einen Client für Java. http://www.danga.com/memcached/ Erfordert einen separaten Prozess, um ein Caching-Server zu sein, aber eine leistungsstarke Sache.