EHCACHE -Methode zur Entfernung von Cache mit Fuzzy -Stapel

Vorwort

Wie wir alle wissen, ist Encache das beliebteste Java Open Source Caching -Framework mit einfacher Konfiguration, klarer Struktur und leistungsstarken Funktionen. Durch Annotieren von @cacheable können Sie dem Cache schnell Methodenergebnisse hinzufügen. Der angegebene Cache kann schnell über @cacheevict gelöscht werden.

Da die @Cacheevict-Annotation jedoch den Schlüsselwert verwendet und die Fuzzy-Löschung nicht unterstützt, werden Sie auf Probleme stoßen. Wenn ich @cacheable verwendet, um mit Spring EL -Ausdrücken zusammenzuarbeiten, füge ich mehrere Caches derselben Methode hinzu, wie z. B.:

 @Getmapping ("/listoftask/{page}/")@cacheable (value = "businessCache", key = "'listoftask _'+ #Page") public pantemessage <Pagetaskvo> GetTaskList (@PathVariable ("Seite") String -Seite) {Do} etwas ...} etwas ...}

Der obige Code soll Aufgabeninformationen durch Paging abrufen. Verwenden Sie einen EL -Ausdruck, um die Seite im Parameter zu erhalten und mit der Cache -Taste den Cache von EHCache mit @cacheable hinzuzufügen. Zu diesem Zeitpunkt werden Schlüssel der Type Listoftask_1, Listoftask_2, Listoftask_3 im Cache angezeigt.

Beim Hinzufügen oder Löschen von Aufgaben ändert sich die Liste. Zu diesem Zeitpunkt müssen Sie alle mit listoftask_*bezogenen Caches entfernen. Zu diesem Zeitpunkt weiß ich nicht, wie viel Inhalt im Zusammenhang mit Listoftask_* im Cache zwischengespeichert ist. Daher ist es unmöglich, @cacheevict aufzurufen, um es einzeln zu löschen.

Da EHCache selbst es nicht unterstützen kann, können wir es nur selbst implementieren.

erreichen

In Anbetracht des durch die Verwendung von Anmerkungen hinzugefügten Cache wird auch die Annotationsverarbeitung verwendet, um die Entwicklungskonsistenz aufrechtzuerhalten. Anmerkungen sind auch sehr freundlich zu Entwicklern. Anschließend erwägen wir benutzerdefinierte Anmerkungen, um die Entfernung von Caches zu verwischen.

Definieren Sie zunächst die Annotation Cacheremove:

 @Target ({java.lang.annotation.elementtype.method}) @retention (retentionPolicy.Runtime) public @Interface CacherEmove {String value (); String [] key ();}

Wo, der Wert ist wie EHCACHE, der verwendet wird, um den zu bedienenden Cache -Namen zu definieren. Ein Schlüssel ist ein Array, das reguläre Ausdrücke für mehrere zwischengespeicherte Schlüsseln speichert. Die Benennung von Cacheremove ist klar und leicht zu verstehen und widerspricht nicht mit der Annotation von EHCache selbst. Die Definition der Annotation endet hier. Als nächstes müssen Sie sich mit Anmerkungen auseinandersetzen. Da das Frühlingsgerüst verwendet wird, ist es natürlich, dass Sie daran denken, AOP zu verwenden, um Anmerkungen zu treffen.

Der Zweck der Annotation besteht darin, die Entfernung des Cache zu verwischen. Die folgenden zwei Probleme müssen berücksichtigt werden:

1. Welche Methode wird zum Fuzzy -Match verwendet?
2. So löschen Sie Schlüssel in Chargen

Die Art und Weise, wie ich es gab und die einfachste Art und Weise, wie ich denke, ist:

1. Welche Methode wird verwendet, um das Spielen zu erreichen? - Der Schlüssel in Cacheremove übergibt den regulären Code, der mehrere Codes übergeben und reguläre Übereinstimmungen verwenden kann
2. So löschen Sie Tasten in Chargen - Schleifen Sie alle Schlüssel und löschen Sie sie, wenn sie eine passende Regelmäßigkeit finden

Definieren Sie zunächst den Klassennamen CacheremoveAtect:

 @Aspekt @componentpublic class cacheremoveAtepe {@pointcut (value = "(Execution (**.*(..)) && @Annotation (com.example.cacheremove)") private void pointCut () {} etwas ...}

Definieren Sie eine Tangente in einem Schnittbereich, verwenden Sie Ausführung (**.*(..) && @Annotation (com.example.cacheremove)), um anzugeben, dass alle annotierten Klassen Cacheremove ausgeführt werden, und die Werte in @Annotation sind die vollständig qualifizierten Namen der Annotationen.

Nachdem der Einschnittspunkt definiert ist, ist das folgende Highlight die spezifische Implementierung des Abschnitts. Im Allgemeinen wird der Cache nicht entfernt, nachdem das Hinzufügen, Löschen und Ändern der Methode ausgeführt wird. Verwenden Sie also @AfterReturning (), um es zu implementieren. Die folgenden Dinge müssen in der spezifischen Implementierung erfolgen:

1. Anmerkungen zur Intercept -Methode
2. Stellen Sie fest, ob die Annotation Cacheremove ist
3. Da der in der Annotation übergebene Schlüssel ein Array ist, wird jeder Schlüssel in einer Schleife verarbeitet
4. Machen Sie jedes Schlüsselmuster in einer Schleife und schleifen Sie alle Caches, um den Cache in der Übereinstimmung zu entfernen

Die spezifische Implementierung ist wie folgt:

 @AfterReturning (value = "pointCut ()") privater void -Prozess (joinpoint joinpoint) {methodeInturature Signature = (methodeInt) joinpoint.getSignature (); Methode Methode = Signature.getMethod (); Cacheremove cacheremove = methode.getannotation (cacheremove.class); if (cacheremove! = null) {string value = cacheremove.Value (); String [] keys = cacheremove.key (); // reguläre Schlüssel, die entfernt werden müssen, liste cachekeys = cacheUtils.cachekeys (Wert); für (String -Schlüssel: Schlüssel) {muster muster = muster.comPile (Schlüssel); für (Objekt cachekey: cachekeys) {String cachekeyStr = string.ValueOf (Cachekey); if (muster.matcher (cachekeystr) .find ()) {cacheUtils.remove (value, cachekeystr); }}}}}}}

Das obige ist die spezifische Implementierung des EHCACHE -Fuzzy -Batch -Entfernungscache. Unter ihnen fasst BusinessCacheUtils die EHCACHE -Toolklasse für sich selbst zusammen. Es implementiert hauptsächlich normale Funktionen wie das Erhalten von Cache -Pools, das Erhalten von Caches, das Entfernen von Caches, das Hinzufügen von Caches und das Betrachten aller Caches. Der Code ist wie folgt:

 public class cacheeutils {private static CacheManager CacheManager = SpringContextHolder.getbean ("EhCacheManagerFactory"); öffentliches statisches Objekt get (String CacheName, String -Schlüssel) {Element Element = getCache (cacheName) .get (Schlüssel); returnelement == null? null: element.getObjectValue (); } public static void put (String -CacheName, String -Schlüssel, Objektwert) {Element Element = New Element (Schlüssel, Wert); getCache (cacheName) .put (Element); } public static void entfernen (String CacheName, String -Schlüssel) {getCache (cacheName) .Remove (Schlüssel); } public static list cachekeys (String cacheName) {return getCache (cacheName) .getkeys (); } /*** einen Cache erhalten, wenn niemand erstellt wird. * @param cacheName * @return */ privater statischer Cache getCache (String CacheName) {cache cache = cacheManager.getCache (cacheName); if (cache == null) {cacheManager.addcache (cacheName); Cache = CacheManager.getCache (CacheName); cache.getCacheConfiguration (). seternal (true); } return cache; } public static CacheManager getCacheManager () {return cacheManager; }}

Zu diesem Zeitpunkt wird die gesamte EHCACHE -Fuzzy -Batch -Entfernungsfunktion implementiert.

Zusammenfassen

Der gesamte Prozess hat eine einfache Idee, und nach Verwendung einiger AOP -Kenntnisse werden die erforderlichen Funktionen erfüllt. Die spezifische Entfernung einiger Codes kann jedoch zur Optimierung in Betracht gezogen werden. Bei allen Cache -Schleifen werden alle Caches entfernt, die entfernt werden müssen, anstatt zu glauben, dass es mehrere Schlüssel wie diesen gibt, der vollständige Cache mehrmals durchquert wird. Die spezifische Implementierung bleibt den Lesern abgeschlossen. Ich hoffe, es wird Ihnen hilfreich sein. Ich hoffe auch, dass jeder wulin.com mehr unterstützen wird.