Útmutató a gyorsítótárazáshoz tavasszal

1. A gyorsítótár-absztrakció?

Ebben a cikkben bemutatjuk, hogyan kell használja a gyorsítótár-absztrakciót tavasszal - és általában javítsa a rendszer teljesítményét.

Engedélyezzük az egyszerű gyorsítótárazást néhány valós módszeres példánál, és megbeszéljük, hogyan javíthatjuk gyakorlatilag e hívások teljesítményét az intelligens gyorsítótár-kezelés révén.

2. Az első lépések

A Spring által biztosított mag gyorsítótár-absztrakció a tavaszi kontextus modul. Tehát a Maven használatakor a mi pom.xml a következő függőséget kell tartalmaznia:

 org.springframework tavaszi kontextus 5.2.8.KÖZLEMÉNY 

Érdekes módon van egy másik modul is tavaszi kontextus-támogatás, amely a tetején ül tavaszi kontextus modul és még néhányat nyújt CacheManagers az EhCache vagy a Koffein kedvelői. Ha ezeket gyorsítótár-tárolóként fogja használni, akkor használja a tavasz-kontextus-támogatás modul helyett:

 org.springframework tavaszi kontextus-támogatás 5.2.8.KÖZLEMÉNY 

Mivel a tavasz-kontextus-támogatás modul átmenetileg a tavaszi kontextus modulhoz nincs szükség külön függőségi deklarációra a tavaszi kontextus.

2.1. Tavaszi csizma

Ha Ön Spring Boot felhasználó, akkor használja a spring-boot-starter-cache indítócsomag a gyorsítótár-függőségek egyszerű hozzáadásához:

 org.springframework.boot spring-boot-starter-cache 2.3.3.FELHASZNÁLÁS 

A motorháztető alatt az önindító hozza a tavasz-kontextus-támogatás modul.

3. Engedélyezze a gyorsítótárat

A gyorsítótárazás engedélyezéséhez a Spring jól használja a jegyzeteket, akárcsak bármely más konfigurációs szintű funkció engedélyezését a keretrendszerben.

A gyorsítótár-funkció deklaratív módon engedélyezhető a szimbólum hozzáadásával @EnableCaching kommentár a konfigurációs osztályok bármelyikéhez:

@Configuration @EnableCaching public class CachingConfig {@Bean public CacheManager cacheManager () {return new ConcurrentMapCacheManager ("address"); }}

Természetesen engedélyezze a gyorsítótár kezelését XML használatával konfiguráció is:

Jegyzet: Miután engedélyeztük a gyorsítótárat - a minimális beállításhoz - regisztrálnunk kell a cacheManager.

3.1. A Spring Boot használata

A Spring Boot használatakor az indító csomag puszta jelenléte az osztályúton a EnableCaching az annotáció ugyanezt regisztrálná ConcurrentMapCacheManager. Tehát nincs szükség külön babnyilatkozatra.

Ezenkívül testre szabhatjuk az automatikusan konfiguráltakat CacheManager egy vagy több felhasználásával CacheManagerCustomizer bab:

@Component public class SimpleCacheCustomizer implementálja a CacheManagerCustomizer {@Override public void customize (ConcurrentMapCacheManager cacheManager) {cacheManager.setCacheNames (asList ("felhasználók", "tranzakciók")); }}

A CacheAutoConfiguration az automatikus konfiguráció felveszi ezeket a testreszabókat és alkalmazza az aktuálisra CacheManager teljes inicializálása előtt.

4. Használja a gyorsítótárat kommentárokkal

Miután engedélyeztük a gyorsítótárat, a következő lépés a gyorsítótárazás viselkedésének deklaratív kommentárokkal történő megkötése a módszerekhez.

4.1. @Tárolható

A módszer gyorsítótárazási viselkedésének engedélyezésének legegyszerűbb módja annak elhatárolása @Cache és paraméterezze azt a gyorsítótár nevével, ahol az eredményeket tárolnák:

@Cacheable ("címek") public String getAddress (Ügyfél ügyfél) {...} 

A getAddress () A call először ellenőrzi a gyorsítótárat címek mielőtt ténylegesen meghívná a módszert, majd tárolja az eredményt.

Míg a legtöbb esetben elegendő egy gyorsítótár, a Spring keretrendszer több gyorsítótárat is támogat paraméterként:

@Cacheable ({"címek", "könyvtár"}) public String getAddress (Ügyfél ügyfél) {...}

Ebben az esetben, ha a gyorsítótárak bármelyike ​​tartalmazza a kívánt eredményt, az eredmény visszaadódik, és a metódust nem hívják meg.

4.2. @CacheEvict

Most mi lenne a probléma az összes módszer elkészítésével @Cache?

A probléma a méret - nem akarjuk olyan értékekkel feltölteni a gyorsítótárat, amelyekre gyakran nincs szükségünk. A gyorsítótárak elég nagyra nőhetnek, meglehetősen gyorsan, és rengeteg elavult vagy fel nem használt adathoz tarthatunk.

A @CacheEvict az annotációt egy vagy több / összes érték eltávolításának jelzésére használják, hogy a friss értékek ismét betölthetők legyenek a gyorsítótárba:

@CacheEvict (value = "address", allEntries = true) public String getAddress (Ügyfél ügyfél) {...}

Itt a kiegészítő paramétert használjuk allEntries a kiürítendő gyorsítótárral együtt - a gyorsítótár összes bejegyzésének törlése címek és előkészíti az új adatokra.

4.3. @CachePut

Míg @CacheEvict csökkenti a bejegyzések nagy gyorsítótárban történő keresésének költségeit az elavult és fel nem használt bejegyzések eltávolításával, ideális esetben, ha szeretné kerülje a túl sok adat kiürítését a gyorsítótárból.

Ehelyett szelektíven és intelligensen szeretné frissíteni a bejegyzéseket, ha azok megváltoznak.

A ... val @CachePut Megjegyzés: frissítheti a gyorsítótár tartalmát anélkül, hogy zavarná a módszer végrehajtását. Vagyis a metódust mindig végrehajtják, és az eredményt gyorsítótárba helyezik.

@CachePut (value = "address") public String getAddress (Ügyfél ügyfél) {...}

A különbség @Cache és @CachePut az, hogy a @Cache akarat hagyja ki a módszer futtatását, mivel @CachePut akarat futtassa a módszert majd az eredményeket a gyorsítótárba helyezi.

4.4. @Gyorsítótár

Mi a helyzet akkor, ha egy módszer gyorsítótárazásához több, ugyanolyan típusú feljegyzést szeretne használni. Nézze meg az alábbi hibás példát:

@CacheEvict ("címek") @CacheEvict (érték = "könyvtár", kulcs = ügyfél.név) public String getAddress (Ügyfél ügyfél) {...}

A fenti kódot nem sikerül lefordítani, mivel a Java nem engedi meg, hogy egyazon módszerhez több azonos típusú kommentár deklarálódjon.

A fenti probléma megoldása a következő lenne:

@ Caching (evict = {@CacheEvict ("címek"), @CacheEvict (value = "könyvtár", kulcs = "# ügyfél.név")}) public String getAddress (Ügyfél ügyfél) {...}

Ahogy a fenti kódrészlet mutatja, megteheti csoportosítson több gyorsítótár-jegyzetet val vel @Caching, és használja saját testreszabott gyorsítótár-logikájának megvalósításához.

4.5. @CacheConfig

A ... val @CacheConfig megjegyzés, akkor ésszerűsítse a gyorsítótár egyes beállításait egyetlen helyre - osztály szinten - hogy ne kelljen többször is bevallania a dolgokat:

@CacheConfig (cacheNames = {"address"}) public class CustomerDataService {@Cacheable public String getAddress (Customer customer) {...}

5. Feltételes gyorsítótár

Előfordulhat, hogy a gyorsítótár nem minden esetben működik jól egy módszer esetében.

Például - újból felhasználva a @CachePut kommentár - ez mind végrehajtja a módszert, mind az eredményeket gyorsítótárba helyezi:

@CachePut (value = "address") public String getAddress (Ügyfél ügyfél) {...} 

5.1. Állapot paraméter

Most - ha nagyobb irányítást akarunk, amikor a kommentár aktív - @CachePut paraméterezhető olyan feltételparaméterrel, amely SpEL-kifejezést vesz fel annak biztosítása érdekében, hogy az eredmények a gyorsítótárba kerüljenek a kifejezés kiértékelése alapján:

@CachePut (value = "address", condition = "# customer.name == 'Tom'") public String getAddress (Customer customer) {...}

5.2. Kivéve, ha a paraméter

A gyorsítótárat is ellenőrizhetjük nem a bemenet, hanem a módszer kimenete alapján - a hacsak paraméter:

@CachePut (érték = "címek", kivéve, ha = "# result.length () <64") public String getAddress (Ügyfél ügyfél) {...}

A fenti megjegyzés gyorsítótárazza a címeket, kivéve, ha azok rövidebbek, mint 64 karakter.

Fontos tudni, hogy a feltétel és hacsak A paraméterek az összes gyorsítótár-annotációval együtt használhatók.

Ez a fajta feltételes gyorsítótár nagyon hasznosnak bizonyulhat a nagy eredmények kezelésében és a viselkedés testreszabásában a bemeneti paraméterek alapján, ahelyett, hogy az összes műveletre érvényesítené az általános viselkedést.

6. Deklaratív XML-alapú gyorsítótár

Abban az esetben, ha nincs hozzáférése az alkalmazás forráskódjához, vagy ha külsőleg szeretné beinjektálni a gyorsítótár-viselkedést, használhat deklaratív XML-alapú gyorsítótárat is.

Itt van az XML konfigurációnk:

7. A Java-alapú gyorsítótár

És itt van az egyenértékű Java konfiguráció:

@Configuration @EnableCaching public class CachingConfig {@Bean public CacheManager cacheManager () {SimpleCacheManager cacheManager = new SimpleCacheManager (); cacheManager.setCache (Arrays.asList (új ConcurrentMapCache ("könyvtár"), új ConcurrentMapCache ("címek"))); return cacheManager; }}

És itt van a miénk CustomerDataService:

@Component public class CustomerDataService {@Cacheable (value = "address", key = "# customer.name") public String getAddress (Customer customer) {return customer.getAddress (); }}

8. Összefoglalás

Ebben a cikkben megvitattuk a tavaszi gyorsítótárazás alapjait, és azt, hogyan lehet ezt az absztrakciót annotációkkal jól kihasználni.

A cikk teljes megvalósítása megtalálható a GitHub projektben.