La mise en cache peut être considérée comme un moyen très efficace et simple d'accélérer la réponse du service. Dans le domaine de la mise en cache, il existe de nombreux cadres bien connus, tels que Ehcache, Guava, Hazelcast, etc. En tant que base de données de valeur clé, Redis est également devenu un outil de mise en cache de données populaire en raison de sa fonctionnalité.
De la manière traditionnelle, le code de traitement du cache est très gonflé.
Par exemple: nous devons ajouter une fonction de requête à la fonction de cache, qui nécessite environ trois étapes.
1. Avant l'exécution de la fonction, nous devons vérifier s'il existe des données dans le cache. S'il existe, retournez les données mises en cache.
2. S'il n'existe pas, il doit être interrogé dans les données de la base de données.
3. Enfin, stockez les données dans le cache. Lorsque cette fonction est appelée la prochaine fois, vous pouvez utiliser les données en cache directement pour réduire la pression sur la base de données.
Alors, quelle quantité de code est nécessaire pour implémenter les trois étapes ci-dessus? Voici un exemple:
La partie rouge de l'image ci-dessus est tout le code de modèle, mais le code qui est vraiment lié à cette fonction ne représente que 1/5. Pour toutes les fonctions qui doivent implémenter les fonctions de cache, un code de modèle gonflé est requis. C'est une solution extrêmement inélégante.
Alors, comment pouvons-nous ramener le code gonflé au temps le plus frais?
AOP n'est-il pas la meilleure solution à ce code de style modèle? Heureusement, nous n'avons plus besoin de mettre en œuvre les sections par nous-mêmes. SpringCache nous a fourni une bonne section. Il nous suffit de faire des configurations simples pour revenir à celle d'origine, comme ce qui suit:
Vous n'avez qu'à ajouter de l'annotation. Vous n'avez même pas besoin de modifier le code d'origine. Êtes-vous impatient de l'essayer?
Il n'y a que trois étapes pour configurer SpringCache:
Étape 1: ajouter des dépendances pertinentes:
<dependency> <proupId> redis.clients </rom grouped> <Artifactid> jedis </retifactid> <version> 2.9.0 </ version> </dependency> <dependency> <proupId> org.springframework.data </prouprid> <Artifactid> Spring-data-redis </ptetifactid> <version> 1.6.0.release <groupId> org.apache.commons </proupId> <Artifactid> Commons-Lang3 </ ArfactId> <DERNÉRATEUR> 3.3.2 </ version> </ Dependency>
Étape 2: Configurer SpringCache, Redis Connection et autres informations
applicationContext-dedis.xml
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/mvc" xmlns: cache = "http://www.springframeworkwork.org/schema/cache" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xssd http://www.springframework.org/schema/context http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.2.xsd "> <! - Fichier de configuration Chargement -> <contexte: propriété-PlaceHerhder location =" classpath: *. Properties "/> <cache: annotation-dwroven: cache-manager = "cacheManager" /> <! - Redis Connection Pool -> <bean id = "poolConfig"> <propriété name = "maxidle" value = "$ {redis.maxidle}" /> <propriété name = "maxwaitmilis" value = "$ {redis.maxwait}" /> <propriété name = "Testonbrunw" Value = "$ {redis.testonBorrow}" /> </Ean> <! - Connection Factory -> <bean id = "JedisconnectionFactory" p: host-name = "$ {redis.host}" p: port = "$ {redis.port}" p: mot de passe = "$ {redis.pass}" p: Pool-Config-ref = " Template -> <bean id = "redesttemplate"> <propriété name = "ConnectionFactory" ref = "jedisconnectionfactory" /> </ank> <bean id = "cacheManager"> <propriété name = "caches"> <set> <! - Vous pouvez configurer plusieurs redis ici -> <an bean> <propriété name = "redestemlate" Ref = "redistemplate" <! - Le nom correspondant au nom doit être utilisé dans l'annotation de la classe ou de la méthode -> </EAN> </set> </prophem> </bEAN> </bars>fichier redis.properties:
# Redis Paramètres # Server IP redis.host = 192.168.100.55 # server port redis.port = 6379 # server pass redis.pass = # use dbindex redis.database = 0 #max idel instance de jedisredis.maxidle = 300 #if wait trop long, lance jediscexection instance Jedis, ce que vous obtenez, c'est tout utiledis.testonborrow = true
La troisième étape consiste à écrire la classe d'implémentation d'interface de cache
Spring ne fournit qu'une interface abstraite pour le cache et appelle les fonctions via des interfaces. Il n'y a pas de classe d'implémentation spécifique, nous devons donc mettre en œuvre nous-mêmes des opérations spécifiques.
Dans la configuration ci-dessus, nous pouvons voir que chaque classe d'implémentation injectera une instance Redetemplate, et nous pouvons utiliser Redis via Redistemplate
package com.cky.rest.utils; import java.io.serializable; import org.apache.commons.lang3.serializationutils; import org.springframework.cache.cache; import org.springframework.cache.support.simplevalwapper; import org.spring org.springframework.data.redis.connection.redisconnection; import org.springframework.data.redis.core.rediscallback; import org.springframework.data.redis.core.redistetemplate; public class rediscache met en œuvre cache {private redestemplate <string, objet> redisteemplate; nom de chaîne privé; @Override public void clear () {System.out.println ("---------------"); redidetemplate.execute (new redisCallback <string> () {@Override public String doInredis (Redisconnection Connection) lève DataAccessException {connection.flushdb (); return "ok";}}); } @Override public void evict (objet clé) {System.out.println ("-----------------"); chaîne finale keyf = key.toString (); Redistetemplate.ExECUTE (New RedisCallback <long> () {@Override public long DoInredis (Redisconnection Connection) lève DataAccessException {return Connection.del (keyf.getBytes ());}}); } @Override public ValueWrapper get (objet Key) {System.out.println ("-----------------------" + key.toString ()); chaîne finale keyf = key.toString (); Objet objet = null; object = redetemplate.execute (new redécallback <objet> () {@Override Object DoinRedis (connexion Redisconnection) lève DataCessexception {byte [] key = keyf.getBytes (); byte [] value = connection.get (key); if (value == null) {system.out.println ("-------------------"); SerializationUtils.deserialize (valeur);}}); ValueWrapper obj = (objet! = Null? New SimpleValuewrapper (objet): null); System.out.println ("--------------------------------------" + Obj); retour obj; } @Override public void put (clé d'objet, valeur objet) {System.out.println ("-----------------------"); System.out.println ("key ----:" + key); System.out.println ("key ----:" + valeur); Final String KeyString = key.toString (); Valeur d'objet final = valeur; LiveTime long final = 86400; Redistetemplate.execute (New RedisCallback <long> () {@Override public long Doinredis (Redisconnection Connection) lève DataCessexception {byte [] keyb = keystring.getBytes (); byte [] valueb = serializationutils.serialize (if (sérialise) Connection.Expire (KeyB, LiveTime);} Retour 1l;}}); } @Override public <t> t get (objet arg0, class <t> arg1) {// TODO Méthode générée automatique Stub return null; } @Override public String getName () {return this.name; } @Override Public Object getNatiVECache () {return this.redistemplate; } @Override public ValueWrapper Putifabsent (objet arg0, objet arg1) {// TODO Méthode générée automatique Stub return null; } public redesttemplate <String, objet> getRedistEemplate () {return reistemplate; } public void setRedistemplate (reidemplate <string, object> redesttemplate) {this.redistemplate = reditemplate; } public void setName (string name) {this.name = name; }}Il y a eu deux erreurs pendant le processus de configuration:
1.xxxx.classnotfoundException Enfin, j'ai trouvé que le téléchargement du pot est incomplet. Supprimez simplement le dossier de package JAR correspondant du référentiel local Maven et téléchargez-le à nouveau.
2.xxxx.MethodNotFoundException Cette situation est la mauvaise version, il suffit de passer à la version dans la première étape.
Utilisation d'annotations communes à SpringCache:
@Cacheable Annotation
L'annotation la plus couramment utilisée mettra en cache la valeur de retour de la méthode annotée. Comment cela fonctionne est: consultez d'abord le cache, si aucune méthode n'est exécutée et que le résultat est mis en cache, puis les données sont renvoyées. Le nom du cache de cette annotation doit être spécifié et correspond à la valeur de nom d'un cache dans les caches dans CacheManager. Peut être spécifié à l'aide de la valeur ou des noms de cache.
Si aucun attribut de clé n'est spécifié, Spring utilisera le générateur de touches primaires par défaut pour générer des clés primaires. Vous pouvez également personnaliser la clé primaire et les expressions de Spel peuvent être utilisées dans la clé. comme suit:
@Cacheable (cachenames = ”contenu”, key = ”# user.userid”) public utilisateur getuser (utilisateur utilisateur) {xxxxx}Vous pouvez utiliser l'attribut de condition pour ajouter des conditions au cache, comme suit:
@Cacheable (cachenames = ”contenu”, key = ”# user.userid”, condition = ”# user.age <40”) public utilisateur getuser (utilisateur utilisateur) {xxxxx}@Cacheput Annotation
Exécutez d'abord la méthode, puis remettez la valeur de retour dans le cache. Peut être utilisé comme mise à jour en cache.
@Cacheevict Annotation
Cette annotation est responsable de la suppression explicite des données du cache. Habituellement, les données en cache ont une date d'expiration et les données seront également supprimées à leur expiration.
Cette annotation a deux attributs supplémentaires:
Si les allerries suppriment toutes les entrées de cache.
AVANTInvocation: Complétez l'opération de retrait avant ou après la méthode appelée. Vrai / faux
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.