Inleiding tot Ehcache

1. Overzicht

In dit artikel introduceren we Ehcache, een veelgebruikte open-source Java-cache. Het beschikt over geheugen- en schijfopslagplaatsen, luisteraars, cache-laders, RESTful- en SOAP-API's en andere zeer nuttige functies.

Om te laten zien hoe caching onze applicatie kan optimaliseren, zullen we een eenvoudige methode maken die kwadratische waarden van opgegeven getallen berekent. Bij elke oproep roept de methode aan berekenSquareOfNummer (int getal) methode en print informatiebericht naar de console.

Met dit eenvoudige voorbeeld willen we laten zien dat de berekening van gekwadrateerde waarden slechts één keer wordt uitgevoerd en dat elke andere aanroep met dezelfde invoerwaarde het resultaat van de cache retourneert.

Het is belangrijk op te merken dat we volledig gefocust zijn op Ehcache zelf (zonder Spring); als je wilt zien hoe Ehcache werkt met Spring, lees dan dit artikel.

2. Maven afhankelijkheden

Om Ehcache te gebruiken, moeten we deze Maven-afhankelijkheid toevoegen:

 org.ehcache ehcache 3.1.3 

De nieuwste versie van het Ehcache-artefact is hier te vinden.

3. Cacheconfiguratie

Ehcache kan op twee manieren worden geconfigureerd:

  • De eerste manier is via Java POJO, waar alle configuratieparameters worden geconfigureerd via Ehcache API
  • De tweede manier is configuratie via XML-bestand waar we Ehcache kunnen configureren volgens de opgegeven schemadefinitie

In dit artikel laten we beide benaderingen zien: zowel Java als XML-configuratie.

3.1. Java-configuratie

Deze subsectie laat zien hoe gemakkelijk het is om Ehcache te configureren met POJO's. We zullen ook een helperklasse maken voor eenvoudigere cacheconfiguratie en beschikbaarheid:

openbare klasse CacheHelper {privé CacheManager cacheManager; privé cache squareNumberCache; openbare CacheHelper () {cacheManager = CacheManagerBuilder .newCacheManagerBuilder (). build (); cacheManager.init (); squareNumberCache = cacheManager .createCache ("squaredNumber", CacheConfigurationBuilder .newCacheConfigurationBuilder (Integer.class, Integer.class, ResourcePoolsBuilder.heap (10))); } openbare cache getSquareNumberCacheFromCacheManager () {terug cacheManager.getCache ("squaredNumber", Integer.class, Integer.class); } // standaard getters en setters}

Om onze cache te initialiseren, moeten we eerst Ehcache definiëren CacheManager voorwerp. In dit voorbeeld maken we een standaardcache kwadraatgetal ' met de newCacheManagerBuilder () API.

De cache zal eenvoudig in kaart worden gebracht Geheel getal sleutels tot Geheel getal waarden.

Merk op hoe, voordat we de gedefinieerde cache gaan gebruiken, we de CacheManager object met de in het() methode.

Ten slotte kunnen we, om onze cache te verkrijgen, gewoon de getCache () API met de opgegeven naam-, sleutel- en waardetypen van onze cache.

Met die paar regels hebben we onze eerste cache gemaakt die nu beschikbaar is voor onze applicatie.

3.2. XML-configuratie

Het configuratieobject uit paragraaf 3.1. is gelijk aan het gebruik van deze XML-configuratie:

 java.lang.Geheel getal java.lang.Geheel getal 10 

En om deze cache op te nemen in onze Java-applicatie, moeten we het XML-configuratiebestand in Java lezen:

URL myUrl = getClass (). GetResource (xmlFile); XmlConfiguration xmlConfig = nieuwe XmlConfiguration (myUrl); CacheManager myCacheManager = CacheManagerBuilder .newCacheManager (xmlConfig);

4. Ehcache-test

In sectie 3. hebben we laten zien hoe u een eenvoudige cache voor uw doeleinden kunt definiëren. Om te laten zien dat caching echt werkt, zullen we Kwadraatcalculator klasse die de gekwadrateerde waarde van de opgegeven invoer berekent en de berekende waarde in een cache opslaat.

Als de cache al een berekende waarde bevat, zullen we natuurlijk de cache-waarde retourneren en onnodige berekeningen vermijden:

openbare klasse SquaredCalculator {privé CacheHelper cache; openbaar int getSquareValueOfNumber (int invoer) {if (cache.getSquareNumberCache (). containsKey (invoer)) {terug cache.getSquareNumberCache (). get (invoer); } System.out.println ("Berekenen van vierkante waarde van" + invoer + "en cacheresultaat."); int squaredValue = (int) Math.pow (invoer, 2); cache.getSquareNumberCache (). put (input, squaredValue); return squaredValue; } // standaard getters en setters; }

Om ons testscenario te voltooien, hebben we ook de code nodig die kwadratische waarden berekent:

@Test openbare leegte whenCalculatingSquareValueAgain_thenCacheHasAllValues ​​() {voor (int i = 10; i <15; i ++) {assertFalse (cacheHelper.getSquareNumberCache (). ContainsKey (i)); System.out.println ("Vierkante waarde van" + i + "is:" + squaredCalculator.getSquareValueOfNumber (i) + "\ n"); } voor (int i = 10; i <15; i ++) {assertTrue (cacheHelper.getSquareNumberCache (). containsKey (i)); System.out.println ("Vierkante waarde van" + i + "is:" + squaredCalculator.getSquareValueOfNumber (i) + "\ n"); }}

Als we onze test uitvoeren, krijgen we dit resultaat in onze console:

Berekenen van vierkante waarde van 10 en cacheresultaat. Kwadraatwaarde van 10 is: 100 Kwadraatwaarde van 11 en cacheresultaat. Kwadraatwaarde van 11 is: 121 Kwadraatwaarde van 12 en cacheresultaat. Kwadraatwaarde van 12 is: 144 Kwadraatwaarde van 13 en cacheresultaat. Kwadraatwaarde van 13 is: 169 Kwadraatwaarde van 14 en cacheresultaat. Kwadraatwaarde van 14 is: 196 Kwadraatwaarde van 10 is: 100 Kwadraatwaarde van 11 is: 121 Kwadraatwaarde van 12 is: 144 Kwadraatwaarde van 13 is: 169 Kwadraatwaarde van 14 is: 196

Zoals je kunt zien, berekenen() De methode deed alleen berekeningen bij de eerste oproep. Bij de tweede aanroep zijn alle waarden in de cache gevonden en eruit geretourneerd.

5. Andere Ehcache-configuratie-opties

Toen we onze cache in het vorige voorbeeld maakten, was het een eenvoudige cache zonder speciale opties. In dit gedeelte worden andere opties getoond die handig zijn bij het maken van cache.

5.1. Schijf persistentie

Als er te veel waarden zijn om in de cache op te slaan, kunnen we enkele van die waarden op de harde schijf opslaan.

PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder () .with (CacheManagerBuilder.persistence (getStoragePath () + File.separator + "squaredValue")) .withCache ("persistent-cache", CacheConfigurationBuilderon. .newResourcePoolsBuilder () .heap (10, EntryUnit.ENTRIES) .disk (10, MemoryUnit.MB, true))) .build (true); persistentCacheManager.close ();

In plaats van standaard CacheManager, gebruiken we nu PersistentCacheManager waardoor alle waarden behouden blijven die niet in het geheugen kunnen worden opgeslagen.

Uit de configuratie kunnen we zien dat de cache 10 elementen in het geheugen zal opslaan en 10 MB op de harde schijf zal toewijzen voor persistentie.

5.2. Vervallen gegevens

Als we veel gegevens cachen, is het normaal dat we cachegegevens een bepaalde tijd bewaren, zodat we een groot geheugengebruik kunnen voorkomen.

Ehcache controleert de versheid van gegevens Vervaldatum koppel:

CacheConfiguration cacheConfiguration = CacheConfigurationBuilder .newCacheConfigurationBuilder (Integer.class, Integer.class, ResourcePoolsBuilder.heap (100)) .withExpiry (Expirations.timeToLiveExpiration (Duration.of (60, TimeUnit.SECONDS);).

In deze cache blijven alle gegevens 60 seconden bewaard en daarna worden ze uit het geheugen verwijderd.

6. Conclusie

In dit artikel hebben we laten zien hoe je eenvoudige Ehcache-caching kunt gebruiken in een Java-applicatie.

In ons voorbeeld zagen we dat zelfs een eenvoudig geconfigureerde cache veel onnodige bewerkingen kan besparen. We hebben ook laten zien dat we caches kunnen configureren via POJO's en XML en dat Ehcache behoorlijk wat leuke features heeft - zoals persistentie en dataverval.

Zoals altijd is de code uit dit artikel te vinden op GitHub.