La recherche principale de cet article concerne le contenu lié au cache de printemps, comme suit.
Cet article a été à peu près modifié en fonction de la traduction de Google. Étant donné que je ne sais pas quel est le texte original, cela peut entraîner des erreurs et des inexactitudes dans la traduction, mais la direction générale est très bien, donc je l'ai trié ici, en espérant que ce sera utile.
La mise en cache a toujours été un grand besoin pour les deux pour améliorer les performances des applications et réduire sa charge de travail. En outre, son utilité est particulièrement évidente aujourd'hui, qui peut être utilisée pour gérer des milliers de visiteurs sur les concurrents. À partir de la version 3.1, Spring fournit une API de gestion de cache, similaire à la gestion des transactions déclaratives. L'interface abstraite du cache, en utilisant différentes solutions de cache de manière unifiée, a le moins d'impact sur le code.
Spring utilise des méthodes Java pour demander une méthode pour la première fois pour une combinaison avec des paramètres, et Spring stocke la valeur de retour dans le cache. Par conséquent, la prochaine demande consistera à utiliser directement la valeur du cache sans avoir à appeler une méthode coûteuse possible. Tout est appliqué de manière transparente sans affecter la méthode appelée.
Dans cet article, nous verrons des implémentations de deux stockages de cache différents du printemps.
L'intégration du printemps et du cache est simple et transparente. La méthode qui a besoin de cache est annotée par @cacheable annotation
@Cacheable (value = "datacache") Réponse publique getDatas (long param1, chaîne param2) {} DataCache est le nom du cache associé. Lorsque cette méthode est appelée pour la première fois, la méthode s'exécute et stocke le résultat d'exécution dans l'ensemble de résultats avec la clé secrète hachée de <paramètre 1 et du paramètre 2> en conséquence. Lorsque le même paramètre est à nouveau appelé, cette méthode n'a plus besoin d'être exécutée.
Il est possible que plus d'un cache soit associé à notre méthode
@Cacheable ({"datacache", "par défaut"}) Réponse publique getDatas (long param1, string param2) {} Dans ce cas, chaque cache est vérifié avant l'exécution de la méthode, et s'il y a un coup, la valeur pertinente sera renvoyée.
La proportion d'algorithmes de base d'un gestionnaire de cache est relativement faible. Le cache peut être considéré comme un domaine de mémoire dans lequel les objets stockés sont mappés par une clé unique. Le processus de recherche d'objets est le suivant:
1. Calculez la touche (utilisez la méthode de hachage pour obtenir HashCode)
2. Trouver des objets en fonction de la valeur clé
3. Si l'objet est trouvé, retournez le résultat
4. S'il ne peut être trouvé, la clé qui est réellement associée à l'objet sera calculée et l'objet sera stocké dans l'emplacement correspondant.
Spring utilise un hachage simple, qui génère des clés en fonction des paramètres de méthode passagés.
La méthode cible ne peut pas simplement générer des clés inutiles en fonction des paramètres, mais seuls certains cas simples sont générés en fonction des paramètres.
@Cacheable (value = "datacache") Réponse publique getDatas (long param1, string param2, booléen param3) {}@Cacheable permet aux développeurs de spécifier la façon dont la génération de clés est générée par elles-mêmes. Vous pouvez utiliser des expressions Spel pour ce faire.
@Cacheable (value = "datacache", key = "# param2") Réponse publique getDatas (long param1, string param2, booléen param3) {} Dans ce cas ci-dessus, le paramètre de la clé en cache n'est que parma2
Le printemps autorise également les propriétés imbriquées
@Cacheable (value = "datacache", key = # param2.name ") Réponse publique getDatas (long param1, data param2, booléen param3) {} Cette situation est la clé calculée sur la base de l'attribut de nom de parma2
Il existe un cache qui peut ne pas convenir au cache dans le cas utilisé, mais dans certains cas, un cache est requis. Lorsqu'il est mis en cache, le cache est traité en fonction du vrai ou du faux calculé par l'expression de Spel, et si la condition est vraie, le cache est effectué.
@Cacheable (value = "datacache", key = "# param2", condition = "# param2.length <64") Réponse publique getDatas (long param1, string param2, booléen param3) {} Dans ce cas, le cache ne sera effectué que si la longueur du deuxième paramètre est inférieure à 64
Le cache de Spring peut non seulement le cache des données, mais également effacer un stockage de cache. Ce processus est utilisé pour supprimer des données obsolètes ou des données mises en cache inutilisées. Annotation @cacheevict définit les méthodes pour effectuer la vidange du cache, ce sont des déclencheurs pour la suppression des données dans le cache.
@Cacheevict (value = "datacache") public void reloaddata () {}Cette option est très nécessaire et cette méthode sera utilisée lorsqu'une données en cache doit être effacée.
Pour activer la prise en charge du cache pour un projet de printemps, nous devons ajouter des commentaires de cache à l'espace de noms.
<Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: cache = "http://www.springframework.org/schema/cache" xmlns: xsi = "http://www.w3.org/2001/xmlsche" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsdwork http://www.springframework.org/schema/context "> <cache: annotation-driven />
Supprimer l'annotation peut désactiver le cache ou activer l'utilisation du cache dans notre classe de configuration
@Configuration @enablecaching public class appconfig {} Limitations techniques
Les paramètres de la méthode d'objet PASS doivent avoir leur propre méthode HashCode afin de calculer la clé secrète.
Au fur et à mesure qu'un objet passait et retourne en tant que paramètre, il doit être sérialisable
Mettre en œuvre la sélection
Spring fournit deux implémentations de base:
Lorsque vous les utilisez, il vous suffit de déclarer le cachemanger et l'entité de gestionnaire appropriés
Concurrenthashmap en utilisant java
<bean id = "cacheManager"> <span style = "white-espace: pre"> </span> <propriété name = "caches"> <span style = "white-espace: pre"> </span> <set> <span style = "white-espace: pre"> </span> </ property> </ bean>
Chaque crèche a besoin d'un nom, qui est reconnu par les commentaires. On peut gérer plusieurs simplecachemangers par une crèche, et cette implémentation est fondamentalement inutile.
Implémenter ehcache
Déclaration de Cachemanger
bean id = "cacheManager"> <propriété name = "cacheManager" ref = "ehcache" /> </ bean> <bean id = "ehcache"> <propriété name = "configLocation" value = "classpath: ehcache.xml" /> <propriété name = "partage" value = "true" /> </ bean>
Dans le fichier ehcache.xml est le fichier de paramètre de cache d'application:
<ehcache xsi: nonamespaceschemalocation = "ehcache.xsd" updatecheck = "true" surveilling = "autodetect" dynamicconfig = "true" maxbytesLocalheap = "150m"> <diskstore path = "java.io.tmpdir" /> <defaultCache éternel = "false" false "maxellements =" false " overflowtodisk = "false" /> <cache name = "datacache" eternal = "false" timetoidleseConds = "300" maxbytesLocalHeap = "30m" timetolivesEconds = "300" overflowtodisk = "true" diskpersistentle = "false" diskexpirereadIntervalsCondeds = "120" 120 " MemoryStoreevictionPolicy = "LRU" /> </ ehcache>
En utilisant ehcache, nous pouvons définir plusieurs paramètres différents de cache de manière très simple
Nom: Identifiant mis en cache
MaxBytesLocalHeap: définit le nombre d'octets que le cache peut utiliser pour la machine virtuelle. Si un CacheManager MaxbytesLocalHeap a été fixé, la taille déterminée du cache sera soustraite par le cacheManager. Autres pauses partagées de cache. La valeur de cette propriété est les données <bor Swember> K | K | M | M | G | G signifie kilo-kilobytes (k | k), mégaoctets (m | m) ou gigaoctets (g | g).
Éternité: définit si un élément est éternel. Si tel est le cas, le délai d'expiration sera ignoré et le projet n'est jamais expiré.
TimeToidleSeconds: Il s'agit du nombre de secondes, l'élément a été laissé dans la dernière utilisation.La La valeur par défaut est 0, et l'élément reste toujours
TIMETOLIVESECONDS: Il s'agit du nombre de secondes que le projet a vécu dans Cache.La La création de valeur par défaut est 0, et le projet sera vivant pour toujours.
MemoryStoreevictionPolicy Plunder Politique: LRU - le moins récemment utilisé et rarement utilisé FIFO - premier-in, le plus ancien élément par date de création.
DiskExpiryThreadIntervalSeconds: Le processus de forclusion contrôle le nombre de secondes entre deux séries.
Diskpersistent: permet de restaurer les objets entre deux correspondances de machines virtuelles stockées sur le disque.
OverflowTodisk: détermine si un objet peut être stocké sur le disque pour atteindre l'élément de stockage maximal.
Pour le résumer, utilisez une formule mathématique simple: expirationTime = Math.min((creationTime + timeToLive),(mostRecentTime + timeToIdle))
Ce qui précède est toute l'explication détaillée du code de cache Spring dans cet article, j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!