Inleiding tot JCache

1. Overzicht

Simpel gezegd, JCache is de standaard caching-API voor Java. In deze tutorial gaan we zien wat JCache is en hoe we het kunnen gebruiken.

2. Maven afhankelijkheden

Om JCache te gebruiken, moeten we de volgende afhankelijkheid toevoegen aan onze pom.xml:

 javax.cache cache-api 1.0.0-PFD 

Merk op dat we de laatste versie van de bibliotheek kunnen vinden in de Maven Central Repository.

We moeten ook een implementatie van de API toevoegen aan ons pom.xml; we gebruiken Hazelcast hier:

 com.hazelcast hazelcast 3.9-EA 

We kunnen ook de nieuwste versie van Hazelcast vinden in de Maven Central Repository.

3. JCache-implementaties

JCache wordt geïmplementeerd door verschillende caching-oplossingen:

  • JCache referentie-implementatie
  • Hazelcast
  • Oracle Coherence
  • Terracotta Ehcache
  • Infinispan

Merk op dat, in tegenstelling tot andere referentie-implementaties, het wordt niet aanbevolen om JCache Reference Implementation in productie te gebruiken, aangezien dit enkele gelijktijdigheidsproblemen veroorzaakt.

4. Hoofdcomponenten

4.1. Cache

De Cache interface heeft de volgende handige methoden:

  • krijgen() - neemt de sleutel van een element als parameter en geeft de waarde van het element terug; het keert terug nul als de sleutel niet bestaat in het Cache
  • alles krijgen() - meerdere sleutels kunnen aan deze methode worden doorgegeven als een Set; tDe methode retourneert de gegeven sleutels en bijbehorende waarden als een Kaart
  • getAndRemove () - de methode haalt een waarde op met behulp van zijn sleutel en verwijdert het element uit de Cache
  • leggen() - voegt een nieuw item in de Cache
  • Doorzichtig() - verwijdert alle elementen in het Cache
  • bevatKey () - controleert of a Cache bevat een bepaalde sleutel

Zoals we kunnen zien, zijn de namen van de methoden vrijwel vanzelfsprekend. Bezoek Javadoc voor meer informatie over deze en andere methoden.

4.2. CacheManager

CacheManager is een van de belangrijkste interfaces van de API. Het stelt ons in staat om tot stand te brengen, te configureren en te sluiten Caches.

4.3. CachingProvider

CachingProvider is een interface waarmee we de levenscyclus van CacheManagers.

4.4. Configuratie

Configuratie is een interface waarmee we kunnen configureren Caches. Het heeft één concrete implementatie - MutableConfiguration en een subinterface - CompleteConfiguration.

5. Een Cache

Laten we eens kijken hoe we een eenvoudig kunnen maken Cache:

CachingProvider cachingProvider = Caching.getCachingProvider (); CacheManager cacheManager = cachingProvider.getCacheManager (); MutableConfiguration config = nieuwe MutableConfiguration (); Cache cache = cacheManager .createCache ("simpleCache", config); cache.put ("key1", "value1"); cache.put ("key2", "value2"); cacheManager.close ();

Het enige wat we doen is:

  • Een CachingProvider object, dat we gebruiken om een CacheManager voorwerp
  • Een MutableConfiguration object, wat een implementatie is van het Configuratie koppel
  • Een Cache object met behulp van de CacheManager object dat we eerder hebben gemaakt
  • Als we alle vermeldingen plaatsen, moeten we in het cachegeheugen onze Cache voorwerp
  • Het CacheManager om de bronnen vrij te geven die worden gebruikt door de Cache

Als we geen implementatie van JCache bieden in onze pom.xml, wordt de volgende uitzondering gegenereerd:

javax.cache.CacheException: er zijn geen CachingProviders geconfigureerd

De reden hiervoor is dat de JVM geen concrete implementatie van het getCacheManager () methode.

6. EntryProcessor

EntryProcessor stelt ons in staat om te wijzigen Cache items met behulp van atomaire bewerkingen zonder ze opnieuw toe te voegen aan de Cache. Om het te gebruiken, moeten we het EntryProcessor koppel:

openbare klasse SimpleEntryProcessor implementeert EntryProcessor, Serializable {openbaar String-proces (MutableEntry-invoer, Object ... args) gooit EntryProcessorException {if (entry.exists ()) {String current = entry.getValue (); entry.setValue (huidig ​​+ "- gewijzigd"); retourstroom; } retourneer null; }}

Laten we nu onze EntryProcessor implementatie:

@Test openbare leegte whenModifyValue_thenCorrect () {this.cache.invoke ("sleutel", nieuwe SimpleEntryProcessor ()); assertEquals ("waarde - gewijzigd", cache.get ("sleutel")); }

7. Evenementluisteraars

Event Listeners stellen ons in staat om actie te ondernemen bij het triggeren van een van de gebeurtenistypen die zijn gedefinieerd in het Gebeurtenistype enum, dat zijn:

  • GECREËERD
  • BIJGEWERKT
  • VERWIJDERD
  • NIET MEER GELDIG

Ten eerste moeten we interfaces implementeren van de evenementen die we gaan gebruiken.

Als we bijvoorbeeld de GECREËERD en de BIJGEWERKT gebeurtenistypen, dan moeten we de interfaces implementeren CacheEntryCreatedListener en CacheEntryUpdatedListener.

Laten we een voorbeeld bekijken:

openbare klasse SimpleCacheEntryListener implementeert CacheEntryCreatedListener, CacheEntryUpdatedListener, Serializable {private boolean updated; private boolean aangemaakt; // standard getters public void onUpdated (Iterable events) gooit CacheEntryListenerException {this.updated = true; } public void onCreated (Iterable events) gooit CacheEntryListenerException {this.created = true; }}

Laten we nu onze test uitvoeren:

@Test openbare void whenRunEvent_thenCorrect () gooit InterruptedException {this.listenerConfiguration = nieuwe MutableCacheEntryListenerConfiguration (FactoryBuilder.factoryOf (this.listener), null, false, true); this.cache.registerCacheEntryListener (this.listenerConfiguration); assertEquals (false, this.listener.getCreated ()); this.cache.put ("sleutel", "waarde"); assertEquals (true, this.listener.getCreated ()); assertEquals (false, this.listener.getUpdated ()); this.cache.put ("key", "newValue"); assertEquals (true, this.listener.getUpdated ()); }

8. CacheLoader

CacheLoader staat toeons om de leesmodus te gebruikenom cache te behandelen als de belangrijkste gegevensopslag en er gegevens uit te lezen.

In een realistisch scenario kunnen we de cache gegevens laten lezen uit de werkelijke opslag.

Laten we een voorbeeld bekijken. Ten eerste moeten we het CacheLoader koppel:

public class SimpleCacheLoader implementeert CacheLoader {public String load (Integer key) gooit CacheLoaderException {return "fromCache" + key; } public Map loadAll (herhaalbare sleutels) gooit CacheLoaderException {Map data = new HashMap (); for (int key: keys) {data.put (key, load (key)); } gegevens retourneren; }}

En laten we nu onze gebruiken CacheLoader implementatie:

openbare klasse CacheLoaderTest {privé cache cache; @Before public void setup () {CachingProvider cachingProvider = Caching.getCachingProvider (); CacheManager cacheManager = cachingProvider.getCacheManager (); MutableConfiguration config = nieuwe MutableConfiguration () .setReadThrough (true) .setCacheLoaderFactory (nieuwe FactoryBuilder.SingletonFactory (nieuwe SimpleCacheLoader ())); this.cache = cacheManager.createCache ("SimpleCache", config); } @Test openbare leegte whenReadingFromStorage_thenCorrect () {voor (int i = 1; i <4; i ++) {String value = cache.get (i); assertEquals ("fromCache" + i, waarde); }}}

9. Conclusie

In deze tutorial hebben we gezien wat JCache is en hebben we enkele van de belangrijke functies onderzocht in een paar praktische scenario's.

Zoals altijd is de volledige implementatie van deze tutorial te vinden op GitHub.