1. Qu'est-ce que le cache de cache
Le mot cache est venu d'abord de la conception du processeur
Lorsque le CPU souhaite lire une données, il regarde d'abord à partir du cache CPU, et le lit immédiatement et l'envoie au CPU pour le traitement s'il est trouvé; S'il n'est pas trouvé, il est lu à partir de la mémoire relativement lente et envoyé au CPU pour le traitement. Dans le même temps, le bloc de données où se trouve ces données est appelé dans le cache, afin que l'ensemble du bloc de données puisse être lu à partir du cache à l'avenir sans appeler la mémoire. C'est ce mécanisme de lecture qui rend le taux de hit du cache de lecture du CPU très élevé (la plupart des CPU peuvent atteindre environ 90%), ce qui signifie que 90% des données que le CPU lira la prochaine fois est dans le cache du processeur, et seulement environ 10% doivent être lues de mémoire. Cela fait gagner considérablement le temps du CPU pour lire la mémoire directement, et rend également impossible pour le CPU de lire les données sans attendre. En général, l'ordre dans lequel le CPU lit les données est d'abord mis en cache puis la mémoire.
Plus tard, nous sommes allés d'abord au cache disque dur, puis au cache d'application, au cache de navigateur, au cache Web, etc.!
Le cache est roi! !
Cache de printemps
Spring Cache est un ensemble complet de solutions de mise en cache des applications données par les applications Spring.
Spring Cache lui-même ne fournit pas d'implémentation de cache, mais utilise des interfaces unifiées et des spécifications de code, des configurations, des annotations, etc. pour vous permettre d'utiliser divers caches dans les applications de printemps sans avoir à prêter trop d'attention aux détails du cache. Avec le cache de printemps, vous pouvez l'utiliser facilement
Diverses implémentations de cache, y compris ConcurrentMap, Ehcache 2.x, JCache, Redis, etc.
La définition du cache au printemps
La définition du cache au printemps, y compris dans l'interface org.springframework.cache.cache.
Il fournit principalement les méthodes suivantes
// Obtenez la valeur en fonction de la touche spécifiée <T> T Get (touche d'objet, classe <T> Type) // Enregistrez la valeur spécifiée dans le cache en fonction de la clé de touche correspondante put (touche d'objet, valeur d'objet); // recycler la valeur spécifiée vide Evict (clé d'objet)
Il n'est pas difficile de voir dans la définition que le cache est en fait une structure de valeur clé. Nous exploitons la valeur correspondante via une clé spécifiée.
Gestionnaire de cache
Cache est une collection de valeurs clés, mais dans notre projet, il peut y avoir différents caches de divers sujets commerciaux, tels que les caches d'utilisateur, les caches de département, etc. Ces caches sont logiquement séparées. Afin de distinguer ces caches, org.springframework.cache.cacheManager est fourni pour gérer divers caches. Cette interface ne contient que deux méthodes
// Obtenez le cache du sujet correspondant en fonction du nom Cache getCache (nom de chaîne); // Obtenez le cache de tous les sujets de collection <string> getCachenames ();
Dans cette interface, l'ajout et la suppression des opérations ne peuvent pas être effectués sur le cache. Ces opérations doivent être effectuées en interne par diverses implémentations de CacheManager et ne doivent pas être divulguées.
Cache basé sur l'annotation
En théorie, le fonctionnement du cache des données n'est pas très pertinent pour l'entreprise elle-même. Nous devons séparer les opérations de lecture et d'écriture de Cache à partir de la logique du code principal. La façon dont le printemps est séparée est basée sur l'annotation (bien sûr, comme JSR-107, etc. est également basée sur l'annotation).
Spring fournit une série d'annotations, notamment @Cacheable, @Cacheput, @Cacheevict et d'autres annotations pour simplifier notre fonctionnement des caches. Ces annotations se trouvent dans le package org.springframework.cache.annotation.
2. Exemples
Un exemple simple d'utilisation de Spring Boot en utilisant le cache Spring
Créons un exemple basé sur le cache de démarrage de printemps étape par étape
Créez un nouveau projet Spring Boot et introduisez les dépendances suivantes
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <GroupId> org.springFramework.boot </prôdId> <ArtefactId> Spring-Boot-starter-test </ artifactid> <ccope> test </cope> </dependency> </Dependances>
Parmi eux, Spring-Boot-Starter-Cache est la principale dépendance du cache.
Modifiez la classe d'application et ajoutez l'annotation qui permet Cache @enableCaching
@ SpringbootApplication @ pertinerCachingPublic classe CacheSIMPleApplication {public static void main (String [] args) {SpringApplication.run (cacheSimpleApplication.class, args); }}@EnableCache Annotation démarre le mécanisme de mise en cache de Spring, qui permettra à l'application de détecter toutes les annotations liées au cache et de commencer à fonctionner. Il créera également un haricot CacheManager qui peut être injecté et utilisé par notre application.
Créer une nouvelle classe RestController
@ RestController @ requestmapping ("/") CACHECONTOLLER CacheController {@Autowired Private CachetService CacheTestService; / ** * Obtenez des informations basées sur l'ID * * @param id * @return * / @getmapping ("{id}") Public String test (@Pathvariable ("id") String id) {return cachetService.get (id); } / ** * Supprimer des informations sur un id * * @param id * @return * / @deletemapping ("{id}") public String Delete (@Pathvariable ("id") String id) {return cacheTService.delete (id); } / ** * Enregistrer des informations sur un ID * * @param id * @return * / @postmapping public String Save (@RequestParam ("id") String id, @RequestParam ("Value") String Value) {return CacheTestService.Save (id, Value); } / ** * Informations sur un nouvel ID * * @param id * @return * / @putmapping ("{id}") public String Update (@Pathvariable ("id") String id, @RequestParam ("value") String Value) {return CacheTestService.update (id, valeur); }}Cette classe appelle un service pour implémenter le fonctionnement réel de l'ajout, de la suppression, de la modification et de la vérification.
Mise en œuvre du service
Ensuite, nous voulons implémenter notre service
@ServicePublic Class SimpleCachetEstServiceImpl implémente CacheTestService {Private Static Final Logger Logger = LoggerFactory.GetLogger (SimpleCacheTestServiceImplL.Class); Map final privé <string, string> entités = new hashmap <> (); public SimpleCacheTestServiceImpl () {entités.put ("1", "Ce n ° 1"); } @Autowired Private Cachemanager CacheManager; @Override @Cacheable (cachenames = "test") public String get (String id) {// Enregistrez l'heure de la génération de données, utilisé pour tester et comparer longtemps = new Date (). GetTime (); // Imprime le CacheManager Logger.info utilisé ("Le CacheManager est" + CacheManager); // imprime le journal logger.info ("obtenir la valeur par id =" + id + ", le temps est" + heure); return "get value by id =" + id + ", la valeur est" + entités.get (id); } @Override public String Delete (String id) {return entities.reMove (id); } @Override public String Save (String id, string value) {Logger.info ("Save Value" + Value + "avec Key" + id); entités.put (id, valeur); valeur de retour; } @Override public String Update (String id, string value) {return entities.put (id, valeur); }}cache
Tout d'abord, ajoutez l'annotation @cacheable à la méthode GET et exécutez le test de code.
Nous utilisons Postman pour les tests, l'adresse de test est http: // localhost: 8080/1, le navigateur répond pour obtenir la valeur par id = 1, la valeur ISTHIS n ° 1, la console du serveur imprime deux lignes de journaux
Obtenir la valeur par id = 1, la valeur ISTHIS n ° 1 Obtenez la valeur par id = 1, le temps est 1516004770216
Mais lorsque nous actualisons à nouveau l'adresse du navigateur, le navigateur revient normalement, mais la console n'imprime plus. La raison en est que lorsque nous l'appelons la deuxième fois, Spring n'exécute plus la méthode, mais obtient directement la valeur mise en cache. Le cache de ressort cache la valeur de retour de la fonction comme la clé du cache nommé test.
Ici, nous utilisons l'annotation @cacheable, et les noms de cache de l'annotation spécifient le cache qui est lu ici. Ici, nous rechercherons l'objet Cache dont la clé est ID dans le cachename = "test".
Supprimer les données mises en cache
Dans le programme ci-dessus, si nous supprimons la valeur spécifiée via la demande de suppression et envoyons la demande de suppression à http: // localhost: 8080/1, pour le moment, la valeur a été supprimée de la carte, mais lorsque nous obtenons la demande à http: // localhost: 8080/1, nous pouvons toujours obtenir la valeur. En effet, lorsque nous supprimons les données, nous n'avons pas supprimé les données dans le cache. Dans la méthode GET précédente, le résultat de l'opération de la méthode est toujours enregistré. Spring ne le lira pas, mais lira directement le cache. Pour le moment, nous ajoutons des annotations avant la méthode
@ Override @ cacheevict (cachenames = "test") public String Delete (String id) {return entités.reMove (id);}Après les tests, appelez d'abord la demande GET, la valeur de retour sera correctement affichée en tant que valeur GET par id = 1, la valeur est 1
Puis appelez la demande de suppression. Supprimez les données du cache et de la carte et appelez à nouveau la demande GET. À l'heure actuelle, la valeur Get By id = 1, la valeur est nul, ce qui signifie que la valeur a en effet été supprimée du cache.
Ici, nous utilisons l'annotation @cacheevict. Cachenames spécifie les données de cache à supprimer. Par défaut, les paramètres de la méthode seront utilisés comme clé supprimée.
Mettre à jour le cache
Lorsque le programme atteint ce point, si nous exécutons la demande de poste, le corps de la demande est id = 1 & value = new1. À l'heure actuelle, la console imprime Enregistrer la valeur nouvelle Valeur1 avec la clé 1, et le code enregistre la valeur sur la carte, mais lorsque nous exécutons la demande GET, nous constaterons que la valeur de retour est toujours dans l'état précédent. C'est ce que nous pouvons utiliser
@ Override @ cacheput (cachenames = "test", key = "#id") public String Save (String id, string value) {logger.info ("enregistrer la valeur" + valeur + "avec key" + id); retour entités.put (id, valeur);}Réexécutez le code, nous envoyons d'abord une demande de suppression pour supprimer les données de la carte et du cache. Ensuite, envoyez une demande de message et rédigez les données sur la carte. Enfin, si vous envoyez une demande GET, vous constaterez que la valeur peut être récupérée correctement maintenant et que la console n'imprime pas le journal des données obtenues à partir de la carte.
L'annotation @cacheput est utilisée ici. La fonction de cette annotation est d'écrire la valeur de retour de la méthode dans le cache spécifié par les noms de cachette en fonction de la clé donnée.
De même, nous devons ajouter l'annotation @cacheput à la méthode de put afin que la modification puisse également actualiser les données mises en cache.
À ce stade, une application de cache simple comprenant l'addition, la suppression, la modification et la requête est terminée.
3. Points clés
Quelques notes
Avis
@Cacheable et @cacheput mettra tous les deux le résultat d'exécution de la méthode dans le cache en fonction de la touche spécifiée. Lorsque @Cacheable est exécuté, il détectera d'abord s'il existe des données dans le cache. Si c'est le cas, il sera lu directement à partir du cache. Sinon, exécutez la méthode et placez la valeur de retour dans le cache, @Cacheput exécutera d'abord la méthode, puis écrivez le résultat d'exécution dans le cache. La méthode utilisant @cacheput sera certainement exécutée
L'exemple de code complet se trouve sur https://github.com/ldwqh0/cache-test
Résumer
Ce qui précède est la méthode d'utilisation du cache de cache dans Spring Boot qui vous est présenté par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!