Explication détaillée de l'Ehcache intégré Springboot pour mettre en œuvre le mécanisme de mise en cache

Ehcache est un cadre de mise en cache Java en Java pur, avec des fonctionnalités rapides et maigres, et est le cacheprovider par défaut en hibernate.

Ehcache fournit une variété de stratégies de mise en cache, principalement divisées en niveaux de mémoire et de disque, il n'est donc pas nécessaire de se soucier des problèmes de capacité.

Spring-Boot est un cadre d'intégration rapide conçu pour simplifier le processus initial de construction et de développement des nouvelles applications de printemps. Le framework utilise un moyen spécifique de le configurer, afin que les développeurs n'aient plus besoin de définir des configurations de chaudières.

Étant donné que Spring-Boot ne nécessite aucun fichier de configuration de passe-partout, Spring-Boot sera légèrement différent lors de l'intégration d'autres cadres.

1.Spring-boot est un cadre pour les packages JAR gérés via Maven. Les dépendances requises pour intégrer ehcache sont les suivantes

 <dependency> <proupId> org.springFramework </proupId> <Ertifactid> Spring-Context-Support </ Artifactid> </Dependency> <Dependency> <ProupId> net.sf.ehcache </proupId> <Ertifactid> ehcache </ artifactid> <version> 2.8.3 </-version> </Dedency>

Le fichier POM.xml spécifique est le suivant

 <? xml version = "1.0" Encoding = "utf-8"?> <project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" XSI: ScheMalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <Modelversion> 4.0.0 </ Modelversion> <proupId> COMACTID> BOOCK <version> 0.0.1-snapshot </-version> <! - Hériter par défaut de Spring Boot -> <parent> <proupId> org.springframework.boot </proncId> <Artifactid> printemps-boot-starter-Parent </letetences> <Detency> <GroupId> org.springframework.boot </proupId> <Ertifactid> printemps-boot-starter-web </ artifactid> </dendency> <dependency> <proupId> org.springframework.boot </proupatid> <Artifactid> printemps-boot-starter-data-jpa </ artifactid> <GroupId> org.springframework.boot </prôdId> <Ertifactive> printemps-boot-starter-thymeleaf </ artifactid> </dependency> <dependency> <proupId> mysql </proupId> <prefactid> mysql-connector-java </ artifactid> </pedency> <pedency> <GroupId> com.google.guava </prôdId> <Artifactid> Guava </ ArtifactId> <DersonD> 17.0 </ Version> </Dependency> <Dedency> <ProupId> Org.SspringFramework </proupdicy> <Ertifactid> Spring-context-soupport </ artifactid> </dependency> <petency> <GroupId> net.sf.ehcache </proupId> <Artifactid> ehcache </retifactid> <version> 2.8.3 </pterences> </Dedency> </Detences> <DependencyManagement> <Detendances> </Dedencys> </Detencys> </Dedency> </Dedensences> </Detences> </Detency> </Detencescs> <build> <frackeins> <GroupId> org.springframework.boot </proupId> <Ertifactid> printemps-boot-maven-plugin </lefactive> </dugin> </nigins> </ build> <fepositories> <fopostory> <id> Spring-Snapshots </id> <url> http://repo.spring.io/snaps <Snapshots> <veabled> true </ enable <Id> Spring-Snapshots </id> <url> http://repo.spring.io/snapshot </url> </GluginRepository> <GluginRepository> <id> Spring-Milestones </id> <url> http://repository> </ PluginRepositories> </propject>

2. En utilisant ehcache, nous avons besoin d'un ehcache.xml pour définir certains attributs de cache.

 <? xml version = "1.0" Encoding = "utf-8"?> <ehcache xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: nonamespaceschemalation = "http://ehcache.org/ehcache.xsd" Toolecheck = " <diskstore path = "java.io.tmpdir / tmp_ehcache" /> <defaultCache eternal = "false" maxElementsInMemory = "1000" overflowtodisk = "false" diskpersistent = "false" TimeToidleSeconds = "0" timetoliveSeds = "600" MemoryStoreevictionpolicy = "LRU" /> <cacheds = "600" MemoryStoreevictionPolicy = "LRU" /> <cacheds = "600" MemoryStoreevictionpolicy = "LRU" /> <cacheds = " name = "Demo" eternal = "false" maxElementsInMemory = "100" overflowtodisk = "false" diskpersistent = "false" TimeToidleSeconds = "0" TIMETOLivesEconds = "300" MemoryStoreevictionPolicy = "LRU" /> </ehCache>

Expliquez les balises dans ce fichier XML.

(1) .Diskstore: Le chemin du cache est-il divisé en deux niveaux: mémoire et disque. Cette propriété définit l'emplacement du cache du disque. Les paramètres sont expliqués comme suit:

1. User.home User Home Directory
2. répertoire de travail actuel de l'utilisateur user.dir
3. Java.io.tmpdir Chemin de fichier temporaire par défaut

(2) .DefaultCache: la stratégie de cache par défaut. Lorsque ehcache ne peut pas trouver le cache défini, cette politique de cache sera utilisée. Un seul peut être défini.

(3) .cache: stratégie de cache personnalisée, une stratégie de cache personnalisée. Les paramètres sont expliqués comme suit:

1. Propriétés de l'élément de cache:
2. Nom: Nom du cache
3. MaxElementsInMemory: Nombre maximum d'objets mis en cache en mémoire
4. Maxelementsondisk: le nombre maximum d'objets mis en cache dans le disque dur. Si c'est 0, cela signifie l'infini
5. Éternel: le vrai signifie que l'objet ne s'expire jamais. À l'heure
6. OverflowTodisk: Vrai signifie que lorsque le nombre d'objets mis en cache dans la mémoire atteint la limite maxelementsInMemory, les objets débordés seront écrits dans le cache de disque dur. Remarque: Si l'objet mis en cache doit être écrit sur le disque dur, l'objet doit implémenter l'interface sérialisable.
7. DiskSpoolBuffeSizemb: Taille du cache de disque, la valeur par défaut est de 30 Mo. Chaque cache doit avoir sa propre zone de cache.
8. Diskpersistent: Il faut mettre en cache des données de redémarrage de la machine virtuelle pendant les données
9. DiskExpiryThreadIntervalSeconds: Intervalle de temps de fonctionnement du thread de discussion du disque, la valeur par défaut est de 120 secondes
10. TimeToidleSonds: définit le temps maximum pour permettre à l'objet d'être inactif, en quelques secondes. Lorsque l'objet a été accessible pour la dernière fois, si la valeur de propriété TimeToidleSonds dépasse la valeur de propriété TimeToidleSonds, l'objet expirera et ehcache le effacera à partir du cache. Cette propriété n'est valable que si la propriété éternelle est fausse. Si la valeur de la propriété est 0, cela signifie que l'objet peut être inactif indéfiniment
11. TIMETOLIVESECONDS: Définit le temps maximum que l'objet permet d'exister dans le cache, en quelques secondes. Lorsque l'objet a été stocké dans le cache, si le temps dans le cache dépasse la valeur de propriété TimeTolivesEnconds, l'objet expirera et ehcache le effacera à partir du cache. Cette propriété n'est valable que si la propriété éternelle est fausse. Si la valeur de la propriété est 0, cela signifie que l'objet peut exister indéfiniment dans le cache. TIMETOLIVESEcondes doivent être plus importantes que la propriété TimeToidleSonds pour avoir un sens
12. MemoryStoreevictionPolicy: Lorsque la limite maxelementsInMemory est atteinte, ehcache nettoiera la mémoire en fonction de la politique spécifiée. Les politiques facultatives sont: LRU (dernier récemment utilisé, politique par défaut), FIFO (First in, First Out) et LFU (nombre minimum de visites).

Springboot prend en charge de nombreuses méthodes de mise en cache: redis, goyave, ehcahe, jcache, etc.

Expliquez la différence entre redis et ehcache:

Redis: Il s'agit d'un programme de course indépendant. Après l'installation seule, il est manipulé à l'aide de Jedis en Java. Parce qu'il est indépendant, si vous écrivez un programme de test unitaire, mettez des données dans Redis, puis écrivez un autre programme pour obtenir les données, vous pouvez obtenir les données. ,
EHCACH: Il est évidemment différent de Redis, il est lié aux programmes Java. Lorsque le programme Java est vivant, il est vivant. Par exemple, si vous écrivez un programme indépendant pour mettre des données, puis écrivez un programme indépendant pour obtenir des données, vous n'obtiendrez pas de données. Les données ne peuvent être obtenues que dans des programmes indépendants.

3. Exposez le gestionnaire ehcache au conteneur de contexte de ressort.

 @ Configuration // L'annotation démarre le cache @EnableCachingPublic Class CacheConfiguration {/ * * ehcache Main Manager * / @Bean (name = "AppeHcachecacheManager") public ehcachecachemanager ehcachecachemanager (ehcacheManArfactoryBean Beeban) {RETOUR New EhcachecAcaReArfere ()); } / * * Selon le partagé ou non, Spring crée une base ehcache via CacheManager.Create () ou New CacheManager () respectivement. * / @Bean public ehcacheManagerFactoryBean ehcacheManagerFactoryBean () {ehcacheManagerFactoryBean CacheManagerFactoryBean = new ehcacheManagerFactoryBean (); cacheManagerFactoryBean.setConfigLocation (new ClassPathResource ("conf / ehcache-app.xml")); CacheManagerFactoryBean.SetShared (true); retour CacheManagerFactoryBean; }}

@Configuration: annoté pour Spring-Boot, principalement annoté en tant que classe de configuration, et la priorité est donnée à la numérisation.

@Bean: Ajoutez du bean au conteneur à ressort.

Toutes les configurations sont effectuées jusqu'à présent et l'intégration du cadre via Spring-Boot est aussi simple.

4. Utilisez ehcache

L'utilisation d'Ehcache est principalement par le mécanisme de cache de ressort. Nous avons implémenté le mécanisme de cache de ressort à l'aide d'EhCache, afin que nous puissions utiliser complètement le mécanisme de cache de ressort en termes d'utilisation.

Quelques notes sont impliquées:

@Cacheable: responsable de l'ajout de la valeur de retour de la méthode au cache, paramètre 3
@Cacheevict: responsable de la compensation du cache, paramètre 4

Explication des paramètres:

1. Valeur: le nom de l'emplacement du cache ne peut pas être vide. Si ehcache est utilisé, c'est le nom du cache déclaré dans ehcache.xml
2. Clé: la touche mise en cache, la valeur par défaut est vide, ce qui signifie le type de paramètre et la valeur du paramètre de la méthode utilisée comme clé, et prend en charge Spel
3. Condition: Condition de déclenchement, uniquement si la condition est remplie sera ajoutée au cache. La valeur par défaut est vide, ce qui signifie que toutes sont ajoutées au cache et prennent en charge Spel
4. AllEntries: Cacheevict Paramètre, True signifie effacer toutes les caches dans la valeur, la valeur par défaut est fausse

Sans plus tarder, téléchargez simplement le code:

 @ServicePublic Class CacheDemoServiceIMPl implémente CacheDemoService {/ ** * Cache Key * / public static final String thing_all_key = "/" thing_all / ""; / ** * L'attribut de valeur indique la stratégie de cache à utiliser. La politique de cache est dans ehcache.xml * / public static final string Demo_cache_name = "Demo"; @Cacheevict (value = demo_cache_name, key = thing_all_key) @Override public void create (thing thing) {long id = getNextid (); thing.setid (id); data.put (id, chose); } @Cacheable (value = demo_cache_name, key = "# thing.getID () + 'thing'") @Override public Things FindById (long id) {System.err.println ("pas de cache!" + Id); return data.get (id); } @Cacheable (value = demo_cache_name, key = thing_all_key) @Override public list <Thing> findall () {return lists.newArrayList (data.values ​​()); } @Override @cacheput (value = demo_cache_name, key = "# thing.getID () + 'thing'") @cacheevict (value = DEMO_CACHE_NAME, key = thing_all_key) public what update (thing) {System.out.println (thing); data.put (Thing.getId (), Thing); Retour Thing; } @Cacheevict (value = DEMO_CACHE_NAME) @Override public void Delete (Long ID) {data.Remove (id); }}

5. Vous n'avez qu'à annoter sur la méthode de la couche de service via des annotations et vous pouvez utiliser le cache, stocker le cache sur Find ** et effacer le cache sur Delete ** et mettre à jour **.

Explication détaillée des annotations de cache

@CacheConfig: il est principalement utilisé pour configurer certaines configurations de cache courantes qui seront utilisées dans cette classe. Ici @CacheConfig (cachenames = "utilisateurs"): le contenu renvoyé dans l'objet d'accès aux données est configuré pour être stocké dans l'objet Cache nommé utilisateurs. Nous pouvons également le définir directement via le propre nom de Cacheable de l'ensemble de cache sans utiliser cette annotation.

@Cacheable: La valeur de retour de la fonction FindByName configurée sera ajoutée au cache. Dans le même temps, lors de la requête, il ira d'abord du cache, et s'il n'existe pas, l'accès à la base de données sera initié. Cette annotation a principalement les paramètres suivants:

1. Valeur et noms de cache: deux paramètres équivalents (Cachenames est ajouté à Spring 4 comme alias pour la valeur), qui est utilisé pour spécifier le nom de collection du stockage du cache. Étant donné que @CacheConfig est ajouté au printemps 4, l'attribut de valeur qui était à l'origine requis au printemps 3 est également devenu un non-essentiel
2. Clé: La valeur clé stockée dans la collection de cartes des objets Cache n'est pas requise. Par défaut, tous les paramètres de la fonction sont combinés comme valeur de clé. Si vous le configurez vous-même, vous devez utiliser des expressions Spel, telles que: @Cacheable (key = "# p0"): utilisez le premier paramètre de la fonction comme valeur de clé en cache. Pour plus de détails sur les expressions de Spel, veuillez vous référer au document officiel.
3. Condition: les conditions pour les objets de cache ne sont pas requises et des expressions de Spel sont également nécessaires. Seuls le contenu qui remplit les conditions d'expression sera mis en cache. Par exemple: @cacheable (key = "# p0", condition = "# p0.length () <3"), ce qui signifie qu'il ne sera mis en cache que lorsque la longueur du premier paramètre est inférieure à 3. Si l'utilisateur AAA sur cette configuration ne sera pas mis en cache, les lecteurs peuvent expérimenter et l'essayer par eux-mêmes.
4. À moins: un autre paramètre conditionnel du cache, qui n'est pas requis, nécessite l'utilisation de l'expression de Spel. Ce qui le rend différent du paramètre de condition réside dans son calendrier de jugement. Cette condition n'est jugée qu'après que la fonction est appelée, donc elle peut être jugée par le résultat.
5. KeyGenerator: utilisé pour spécifier le générateur de touches, non requis. Si vous devez spécifier un générateur de clés personnalisé, nous devons implémenter l'interface org.springframework.cache.interceptor.keyGenerator et utiliser ce paramètre pour le spécifier. Il convient de noter que ce paramètre et cette clé s'excluent mutuellement
6. CacheManager: utilisé pour spécifier le gestionnaire de cache à utiliser, non requis. Utiliser uniquement s'il y a plusieurs
7. Cacheresolver: est utilisé pour spécifier quel analyseur de cache à utiliser, non requis. Vous devez implémenter votre propre analyseur de cache via l'interface org.springframework.cache.interceptor.cacheresolver et le spécifiez avec ce paramètre.

En plus des deux annotations utilisées ici, il existe également les annotations de base suivantes:

@Cacheput: configuré sur une fonction, il peut être mis en cache en fonction des paramètres et définit les conditions. Contrairement à @Cacheable, il appelle vraiment la fonction à chaque fois, il est donc principalement utilisé pour les opérations d'addition et de modification des données. Ses paramètres sont similaires à @Cacheable. Pour des fonctions spécifiques, veuillez vous référer à l'analyse ci-dessus des paramètres @cacheables.

@Cacheevict: configuré sur des fonctions, généralement utilisées dans les méthodes de suppression, pour supprimer les données correspondantes du cache. En plus des mêmes paramètres que @Cacheable, il a les deux paramètres suivants:

1. Allentries: non essentiel, par défaut en false. Quand c'est vrai, toutes les données sont supprimées
2. AVANTInvocation: non essentiel, la valeur par défaut est fausse et les données seront supprimées après l'appel de la méthode. Lorsqu'il est vrai, les données sont supprimées avant d'appeler la méthode.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.