Préface
Comme nous le savons tous, Enchache est maintenant le cadre de mise en cache open source Java le plus populaire, avec une configuration simple, une structure claire et des fonctions puissantes. En annotant @Cacheable, vous pouvez rapidement ajouter des résultats de la méthode au cache. Le cache spécifié peut être rapidement éliminé via @cacheevict.
Cependant, comme l'annotation @cacheevict utilise la valeur clé et ne prend pas en charge la suppression floue, vous rencontrerez des problèmes. Lorsque j'utilise @cacheable pour coopérer avec les expressions de printemps EL, j'ajoute plusieurs caches de la même méthode, comme:
@GetMapping ("/ listoftask / {page} /") @ cacheable (value = "businesscache", key = "'listoftask _' + #Page") public réponses de la page <pageTaskvo> GetTaskList (@PathVariable ("page") Page de chaîne) {faire quelque chose ...}Le code ci-dessus est d'obtenir des informations de tâche en paginant. Utilisez une expression EL pour obtenir la page dans le paramètre et utilisez la touche de cache pour l'ajouter au cache d'EhCache en utilisant @Cacheable. À l'heure actuelle, les clés du type listoftask_1, listoftask_2, listoftask_3 apparaîtront dans le cache.
Lors de l'ajout ou de la suppression de tâches, la liste changera. À l'heure actuelle, vous devez supprimer tous les caches liés à Listoftask_ *. Pour le moment, je ne sais pas combien de contenu lié à Listoftask_ * est mis en cache dans le cache, il est donc impossible d'appeler @cacheevict pour le supprimer un par un.
Étant donné qu'Ehcache lui-même ne peut pas le supporter, nous ne pouvons que l'implémenter nous-mêmes.
accomplir
Compte tenu du cache ajouté en utilisant des annotations, la suppression des caches utilise également le traitement d'annotation pour maintenir la cohérence du développement. Les annotations sont également très amicales avec les développeurs. Ensuite, nous envisageons d'utiliser des annotations personnalisées pour brouiller l'élimination des lots des caches.
Tout d'abord, définissez le cachemove annotation:
@Target ({java.lang.annotation.elementType.Method}) @ Rétention (RetenderPolicy.Runtime) public @Interface CacheMove {String Value (); String [] key ();}Où, la valeur est comme ehcache, utilisée pour définir le nom du cache pour fonctionner. Une clé est un tableau qui stocke des expressions régulières pour plusieurs caches cache-cache. La dénomination de Cachemove est claire et facile à comprendre et n'entre pas en conflit avec l'annotation d'Ehcache elle-même. La définition de l'annotation se termine ici. Ensuite, vous devez faire face aux annotations. Parce que le cadre de ressort est utilisé, il est naturel que vous pensiez à utiliser AOP pour faire des annotations.
Le but de l'annotation est d'éliminer le cache floue par lots. Les deux problèmes suivants doivent être pris en compte:
La façon dont j'ai donné et la manière la plus simple que je pense est:
Définissez d'abord le nom de classe CacheMoveaSpect:
@ Aspect @ ComponentPublic classe CacheMoveaSpect {@Pointcut (value = "(exécution (* *. * (..)) && @annotation (com.example.cacheMove))") private void Pointcut () {} faire quelque chose ...}Définissez une tangente dans une zone de tranchage, utilisez l'exécution (* *. * (..) && @annotation (com.example.cacheMove)) pour indiquer que toutes les classes annotées CachereMove sont exécutées, et les valeurs dans @annotation sont les noms entièrement qualifiés des annotations.
Une fois le point d'incision défini, le point culminant suivant est la mise en œuvre spécifique de la section. De manière générale, le cache ne sera pas supprimé après l'exécution de la méthode d'ajout, de supprimer et de modifier. Utilisez donc @afterreturning () pour l'implémenter. Les choses suivantes doivent être faites dans l'implémentation spécifique:
La mise en œuvre spécifique est la suivante:
@Afterreturning (value = "Pointcut ()") Process void privé (joinpoint joinpoint) {Methodsignature Signature = (Methodsignature) joinpoint.getSignature (); Méthode méthode = signature.getMethod (); CacheMove cacheMove = méthode.getAnnotation (cacheMove.class); if (cacheMove! = null) {String value = cacheMove.Value (); String [] keys = cacheMove.key (); // les touches régulières qui doivent être supprimées list cachekeys = cacheutils.cachekeys (valeur); for (String Key: Keys) {Pattern Pattern = Pattern.Compile (key); for (object cacheKey: cachekeys) {String cachekeystr = string.valueof (cacheKey); if (Pattern.matcher (cachekeystr) .find ()) {cacheutils.remove (valeur, cachekeystr); }}}}}}}Ce qui précède est la mise en œuvre spécifique du cache de suppression par lots Fuzzy Ehcache. Parmi eux, BusinessCacheutils résume la classe d'outils ehcache pour lui-même. Il implémente principalement des fonctions normales telles que l'obtention de pools de cache, l'obtention de caches, l'élimination des caches, l'ajout de caches et la visualisation de toutes les caches. Le code est le suivant:
classe publique Cacheutils {private static cacheManager cacheManager = SpringContexTholder.getBean ("ehcacheManagerFactory"); Objet statique public Get (String cachename, string key) {element element = getCache (cachename) .get (key); élément de retour == null? null: element.getObjectValue (); } public static void put (string cachename, key string, valeur objet) {element element = new element (key, valeur); getCache (cachename) .put (élément); } public static void dispos (string cachename, string key) {getCache (cachename) .Remove (key); } public static list cachekeys (string cachename) {return getCache (cachename) .getKeys (); } / ** * Obtenez un cache, si personne n'est créé. * @param cachename * @return * / cache statique privé getCache (String cachename) {cache cache = cacheManager.getCache (cachename); if (cache == null) {cacheManager.addcache (cachename); cache = cacheManager.getCache (cachename); cache.getCacheConfiguration (). setEternal (true); } return cache; } public static cachemanager getCacheManager () {return cacheManager; }}À ce stade, l'intégralité de la fonction de suppression des lots floues ehcache est implémentée.
Résumer
L'ensemble du processus a une idée simple, et après avoir utilisé certaines connaissances AOP, les fonctions requises sont remplies. Cependant, l'élimination spécifique de certains codes peut être prise en compte pour l'optimisation. Grâce à toutes les boucles de cache, tous les caches qui doivent être supprimés sont supprimés, au lieu de penser qu'il y a plusieurs clés comme celle-ci, le cache complet est traversé plusieurs fois. L'implémentation spécifique est laissée aux lecteurs à terminer. J'espère que cela vous sera utile. J'espère également que tout le monde soutiendra davantage Wulin.com.