1. @EnableCaching : principalement utilisé pour activer la prise en charge de la mise en cache basée sur les annotations, utilisée dans la classe Application
@EnableCaching //SpringBoot开启缓存注解支持
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
ConfigurableApplicationContext app = SpringApplication.run(DemoApplication.class, args);
}
2. @CacheConfig : Cette annotation est ajoutée à la classe pour extraire la configuration publique du cache.
L'ajout de l'annotation @CacheConfig à l'en-tête de classe équivaut à ajouter le composant spécifié par cacherName ou value à l'annotation de cache sur chaque method , et ce composant provient de @CacheConfig, qui est utilisé pour coordonner toutes les classes de gestion qui utilisent @Cacheable et @ CachePut ... et les propriétés publiques dans la méthode d'annotation d'annotation @CacheEvict , ces propriétés publiques incluent cacheNames, keyGenerator, cacheManager et cacheResolver
@CaaheConfig.(caaheNames - "comment")service
public class CommsntService {
@Autowired
private CommentRepository commentRepository;
public Comment findById(int comment. id){
Comment comment = commentRepository.findById(commenc..id).get ();
return comment;
}
}
Dans le code ci-dessus, l'annotation @CacheConfig est marquée sur la classe CommentService et l'attribut cacheNames. est utilisé pour définir l'espace de cache pour commenter, de sorte que l'attribut cacheNames correspondant puisse être omis lors de l'utilisation des annotations de cache sur toutes les méthodes de cette classe. .
Il convient de noter que si @CacheConfig est utilisé sur la classe, l'annotation définit une certaine propriété (telle que cacheNames), et en même temps, la même propriété est définie dans la méthode de classe en utilisant l'annotation de cache, puis la valeur de la propriété utilisera le "principe de proximité" La sélection est soumise à la valeur de l'attribut dans l'annotation sur la méthode.
3. @CachePut : cette annotation est utilisée pour définir le cache
Indique que le cache est mis à jour lors de l'appel de la méthode. Il appelle d'abord la méthode cible par défaut, puis stocke le résultat d'exécution de la méthode cible dans le cache. Cependant, il convient de noter que si vous souhaitez conserver le cache mis à jour de manière synchrone , la clé utilisée dans cette annotation doit être la même que celle du cache. La clé reste la même.
La différence avec @cacheable est que @cacheable s'exécute avant la méthode cible, mais après la méthode cible, car il doit d'abord obtenir le résultat de la méthode cible. @Cacheable ne peut pas utiliser #result, car la méthode marquée avec @Cacheable peut ne pas être appelée et le résultat peut ne pas être obtenu. Ses attributs sont fondamentalement les mêmes que @cacheable, à l'exception d'un attribut indiquant s'il est asynchrone (sync)
@CachePut(value="dep",key="#department.id")
public Department updateDepartment(Department department){
System.out.println("更新信息："+department);
departmentDao.updateDepartment(department);
return department;
}
4. @Cacheable(value="accountCache") : cette annotation est principalement destinée à la configuration de la méthode, qui peut mettre en cache les résultats en fonction des paramètres de requête de la méthode. Par exemple, si la valeur existe dans le cache, les données mises en cache seront S'il n'est pas dans le cache, alors stocké dans le cache ;
Ce commentaire signifie que lorsque cette méthode est appelée, elle sera interrogée à partir d'un cache nommé accountCache. Sinon, la méthode réelle (c'est-à-dire l'interrogation de la base de données) sera exécutée et le résultat de l'exécution sera stocké dans le cache, sinon ce seront des objets retournés dans le cache . La clé dans le cache ici est le paramètre userName et la valeur est l'objet Account. Le cache "accountCache" est le nom défini dans spring*.xml.
Les attributs:
- value/cacheNames : spécifiez le nom de l'espace de cache et faites correspondre les attributs. Vous pouvez choisir l'un des deux.
- clé : spécifie la clé des données dans le cache. La valeur du paramètre de méthode est utilisée par défaut et les expressions SPEL peuvent également être utilisées.
- keyGenerator : spécifie le générateur de la clé des données mises en cache, qui peut être utilisé avec l'attribut key.
- cacheManager : spécifie le gestionnaire de cache
- cacheResolver : spécifie le résolveur de cache, qui peut être utilisé avec l'attribut cacheManager.
- condition : spécifie que la mise en cache des données doit être effectuée lorsqu'une certaine condition est remplie.
- sauf si : spécifie de ne pas mettre en cache les données lorsqu'une certaine condition est remplie.
- sync : spécifie s'il faut utiliser la mise en cache asynchrone, la valeur par défaut est false.
5. @CacheEvict : Cette annotation est utilisée pour nettoyer le cache
Commentez pour marquer la méthode pour vider le cache, effectuez d'abord l'appel de méthode, puis videz le cache.
Faites attention à l'un des @CacheEvict(value="accountCache", key="#account.getName()"), la clé dans laquelle est utilisée pour spécifier la clé du cache, car nous utilisons le champ de nom de l'objet compte lors de l'enregistrement, il est donc également nécessaire d'obtenir la valeur de name à partir de l'objet paramètre account comme clé. Le # devant signifie qu'il s'agit d'une expression SpEL, et cette expression peut traverser l'objet paramètre de la méthode.
Cette annotation fournit deux attributs spéciaux :
Attribut allEntries : indique s'il faut effacer toutes les paires clé-valeur du cache spécifié, c'est-à-dire s'il faut effacer tous les caches. Lorsqu'il est défini sur true, toutes les paires clé-valeur du cache seront effacées. La valeur par défaut est false, c'est-à-dire selon la clé pour vider le cache. Il est donc utilisé avec l'attribut key.
Attribut beforeInvocation : indique s'il faut vider le cache spécifié avant l'appel de la méthode annotée @CacheEvict. La valeur par défaut est false, c'est-à-dire que le cache est vidé après l'appel de la méthode. Lorsqu'il est défini sur true, le cache est vidé avant l'appel de la méthode . La différence entre vider le cache avant ou après l'appel de la méthode est de savoir s'il y aura une exception lorsque la méthode sera appelée. S'il n'y a pas d'exception, il n'y a pas de différence entre les deux paramètres. Si une exception se produit, la définir pour effacer le cache après l'appel de la méthode ne fonctionnera pas, car la méthode L'appel a échoué.
@CacheEvict(value = "dep",key = "#id"/*,beforeInvocation = true*//*,allEntries = true*/)
public boolean delDep(int id){
boolean flag=false;
try{
departmentDao.deleteDepartmentById(id);
flag=true;
}catch(Exception e){
e.printStackTrace();
}
return flag;
}
6. @Caching : cette annotation peut regrouper le nettoyage du cache, la configuration et d'autres opérations
Il est utilisé pour la gestion du cache de données pour les règles complexes, qui peuvent être appliquées à des classes ou des méthodes. L'annotation @Caching contient trois attributs : Cacheable, put et evict, correspondant aux trois annotations de @Cacheable, @CachePut et @CacheEvict respectivement
@Caching(cacheable={
8cacheable (gacheNames ="comment".,key = "帮id")},
put = {
RCachePut(cacheNames = "comment".,key.= "#result.author")})
public Comment getcoiment(int comment id){
return commentRepository.fi.ndByld(comment id).get();
}
Dans le code ci-dessus, les deux annotations @Cacheable et @CachePut sont imbriquées à l'aide des attributs cacheable et put. L'id et l'auteur sont respectivement utilisés comme valeur de clé de cache, et le résultat de la requête Comment est utilisé comme valeur de cache pour la gestion du cache.