Comment SpringBoot utilise @Cacheable pour la mise en cache et la récupération de valeurs

Utilisez @Cacheable pour la mise en cache et l'acquisition de valeur

1. Le rôle de @Cacheable

Les étapes pour utiliser la mise en cache consistent à implémenter la mise en cache en utilisant l'annotation @Cacheable. Nous pouvons donc d'abord parler des étapes d'utilisation du cache :

Utilisez l'annotation @EnableCaching sur la classe de démarrage principale de SpringBoot pour activer la mise en cache basée sur les annotations.

Marquez simplement l'annotation du cache

Étape 1 : activez la mise en cache basée sur les annotations et utilisez @EnableCaching pour la marquer sur la classe de démarrage principale de Springboot

//开启基于注解的缓存
@EnableCaching   
@EnableRyFeignClients
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class ZfjgAuthApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZfjgAuthApplication.class, args);
    }
}

Étape 2 : marquez l'annotation du cache

@Repository
public interface DeviceMapper {
    @Cacheable(cacheNames = "DeviceDO.deviceId")
    DeviceDO get(String deviceId);
    @CacheEvict(cacheNames = "DeviceDO.deviceId", key = "#record.deviceId")
    int insert(DeviceDO record);
}

Remarque : @Cacheable est utilisé ici L'annotation peut mettre en cache les résultats en cours d'exécution. Si vous interrogez les mêmes données à l'avenir, vous pouvez les obtenir directement à partir du cache sans appeler de méthodes.

2. Description des attributs communs

Ce qui suit est une introduction à plusieurs attributs couramment utilisés de l'annotation @Cacheable :

• cacheNames/value : utilisé pour spécifier les composants du cache Nom cacheNames/value：用来指定缓存组件的名字

• key：缓存数据时使用的 key，可以用它来指定。默认是使用方法参数的值。（这个 key 你可以使用 spEL 表达式来编写）

• keyGenerator：key 的生成器。 key 和 keyGenerator 二选一使用

• cacheManager：可以用来指定缓存管理器。从哪个缓存管理器里面获取缓存。

• condition：可以用来指定符合条件的情况下才缓存

• unless：否定缓存。当 unless 指定的条件为 true ，方法的返回值就不会被缓存。当然你也可以获取到结果进行判断。（通过 #result 获取方法结果）

• sync

key : La clé utilisée lors de la mise en cache des données, vous pouvez l'utiliser pour spécifier. La valeur par défaut consiste à utiliser la valeur du paramètre de méthode. (Vous pouvez utiliser des expressions spEL pour écrire cette clé)

keyGenerator : Générateur de clés. Utiliser key ou keyGenerator

cacheManager : peut être utilisé pour spécifier le gestionnaire de cache. À partir de quel gestionnaire de cache obtenir le cache.

condition : peut être utilisé pour spécifier la mise en cache uniquement lorsque les conditions sont remplies

sauf si : annuler la mise en cache. Lorsque la condition spécifiée par sauf est vraie, la valeur de retour de la méthode ne sera pas mise en cache. Bien entendu, vous pouvez également obtenir les résultats à des fins de jugement. (Obtenez le résultat de la méthode via #result)

sync : s'il faut utiliser le mode asynchrone.

Instructions pour l'utilisation de Cacheable dans SpringBoot

Description de la fonction

Lorsque l'annotation @Cacheable est utilisée sur une méthode, cela signifie que les résultats renvoyés par la méthode peuvent être mis en cache. C'est-à-dire que le résultat renvoyé par cette méthode sera placé dans le cache, de sorte que lorsque la méthode sera appelée avec les mêmes paramètres à l'avenir, la valeur dans le cache sera renvoyée sans réellement exécuter la méthode.

Notez qu'un point est souligné ici : les paramètres sont les mêmes. Cela devrait être facile à comprendre, car le cache ne se soucie pas de la logique d'exécution de la méthode. Ce qu'il peut déterminer, c'est : pour la même méthode, si les paramètres sont les mêmes, le résultat renvoyé est également le même. Mais si les paramètres sont différents, le cache ne peut que supposer que les résultats sont différents, donc pour une même méthode, combien de combinaisons de paramètres sont utilisées pour appeler la méthode lors de l'exécution de votre programme, théoriquement combien de clés de cache seront générées ( bien entendu, les paramètres de ces combinaisons font référence à la clé générée). Jetons un coup d'œil à quelques paramètres de @Cacheable :

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
    @AliasFor("cacheNames")
    String[] value() default {};
    @AliasFor("value")
    String[] cacheNames() default {};
    String key() default "";
    String keyGenerator() default "";
    String cacheManager() default "";
    String cacheResolver() default "";
    String condition() default "";
    String unless() default "";
    boolean sync() default false;
}

1. cacheNames & valueVous pouvez choisir d'utiliser l'un des value ou cacheNames pour spécifier le nom du cache, ce qui peut être obtenu via @Cacheable. Ceci est l'exemple d'utilisation le plus simple de @Cacheable :

@Override
@Cacheable("menu")
public Menu findById(String id) {
    Menu menu = this.getById(id);
    if (menu != null){
        System.out.println("menu.name = " + menu.getName());
    }
    return menu;
}

Dans cet exemple, le cache de menu est associé à une méthode appelée findById. S'il y a déjà un résultat dans le cache du menu, il ne sera pas exécuté lors de l'appel de cette méthode, mais le résultat mis en cache sera utilisé directement.

2. Associer plusieurs noms de cache

• En fait, selon la documentation officielle, @Cacheable prend en charge la même méthode pour associer plusieurs caches. Dans ce cas, avant d'exécuter la méthode, chacun de ces caches associés sera vérifié, et tant que

  au moins un des caches arrive
, la valeur de ce cache sera renvoyée.

• Exemple :

  @Override
      @Cacheable({"menu", "menuById"})
      public Menu findById(String id) {
          Menu menu = this.getById(id);
          if (menu != null){
              System.out.println("menu.name = " + menu.getName());
          }
          return menu;
      }
  ---------
  @GetMapping("/findById/{id}")
  public Menu findById(@PathVariable("id")String id){
      Menu menu0 = menuService.findById("fe278df654adf23cf6687f64d1549c0a");
      Menu menu2 = menuService.findById("fb6106721f289ebf0969565fa8361c75");
      return menu0;
  }

Par souci d'intuition, écrivez le paramètre id directement dans le code. Maintenant, testons-le et voyons les résultats :

3. key & keyGenerator

Un nom de cache correspond à une méthode annotée, mais une méthode peut passer des paramètres différents, et les résultats seront différents. être distingué ? Cela nécessite l'utilisation de key . Dans le framework Spring, les valeurs clés peuvent être générées de deux manières : explicitement spécifiées et automatiquement à l'aide d'un générateur de clés.

3.1 KeyGenerator génère automatiquement

🎜🎜Lorsque nous déclarons @Cacheable sans spécifier le paramètre key, toutes les clés sous le nom du cache seront automatiquement générées à l'aide de KeyGenerator en fonction des paramètres. Spring a un SimpleKeyGenerator par défaut, qui sera injecté par défaut dans la configuration automatisée du Spring Boot. Les règles de génération sont les suivantes : 🎜🎜🎜🎜Si la méthode cache n'a pas de paramètres, renvoie SimpleKey.EMPTY ; 🎜🎜🎜🎜Si la méthode cache a un paramètre, renvoie une instance du paramètre ; 🎜🎜🎜🎜Si le cache ; La méthode a plusieurs paramètres, renvoie une SimpleKey contenant tous les paramètres ; 🎜🎜🎜🎜Le générateur de clé par défaut nécessite que les paramètres aient des implémentations valides des méthodes hashCode() et equals(). Alternativement, vous pouvez personnaliser le keyGenerator et le spécifier via celui-ci. Je ne donnerai pas ici une introduction détaillée à KeyGenerator. Si vous êtes intéressé, vous pouvez jeter un œil au code source. En fait, il utilise hashCode pour effectuer des opérations d'addition et de multiplication. Semblable aux calculs de hachage pour String et ArrayList. 🎜🎜🎜3.2 Spécifier explicitement la clé🎜🎜

相较于使用 KeyGenerator 生成，spring 官方更推荐显式指定 key 的方式，即指定 @Cacheable 的 key 参数。

即便是显式指定，但是 key 的值还是需要根据参数的不同来生成，那么如何实现动态拼接呢？SpEL（Spring Expression Language，Spring 表达式语言） 能做到这一点。下面是一些使用 SpEL 生成 key 的例子。

@Override
    @Cacheable(value = {"menuById"}, key = "#id")
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }
    @Override
    @Cacheable(value = {"menuById"}, key = "'id-' + #menu.id")
    public Menu findById(Menu menu) {
        return menu;
    }
    @Override
    @Cacheable(value = {"menuById"}, key = "'hash' + #menu.hashCode()")
    public Menu findByHash(Menu menu) {
        return menu;
    }

官方说 key 和 keyGenerator 参数是互斥的，同时指定两个会导致异常。

4. cacheManager & cacheResolver

缓存管理器CacheManager用于管理（寻找）某种缓存。通常来讲，缓存管理器是与缓存组件类型相关联的。我们知道，spring 缓存抽象的目的是为使用不同缓存组件类型提供统一的访问接口，以向开发者屏蔽各种缓存组件的差异性。那么 CacheManager 就是承担了这种屏蔽的功能。spring 为其支持的每一种缓存的组件类型提供了一个默认的 manager，如：RedisCacheManager 管理 redis 相关的缓存的检索、EhCacheManager 管理 ehCache 相关的缓等。

CacheResolver，缓存解析器是用来管理缓存管理器的，CacheResolver 保持一个 cacheManager 的引用，并通过它来检索缓存。CacheResolver 与 CacheManager 的关系有点类似于 KeyGenerator 跟 key。spring 默认提供了一个 SimpleCacheResolver，开发者可以自定义并通过 @Bean 来注入自定义的解析器，以实现更灵活的检索。

大多数情况下，我们的系统只会配置一种缓存，所以我们并不需要显式指定 cacheManager 或者 cacheResolver。Spring允许我们在系统中配置多个缓存组件，这时我们需要进行明确的指定。指定的方式是使用 @Cacheable 的 cacheManager 或者 cacheResolver 参数。

按照官方文档，cacheManager 和 cacheResolver 是互斥参数，同时指定两个可能会导致异常。

5. sync

是否同步，true/false。在一个多线程的环境中，某些操作可能被相同的参数并发地调用，这样同一个 value 值可能被多次计算（或多次访问 db），这样就达不到缓存的目的。针对这些可能高并发的操作，我们可以使用 sync 参数来告诉底层的缓存提供者将缓存的入口锁住，这样就只能有一个线程计算操作的结果值，而其它线程需要等待，这样就避免了 n-1 次数据库访问。

sync = true 可以有效的避免缓存击穿的问题。

6. condition

调用前判断，缓存的条件。有时候，我们可能并不想对一个方法的所有调用情况进行缓存，我们可能想要根据调用方法时候的某些参数值，来确定是否需要将结果进行缓存或者从缓存中取结果。例如，当我查询用户时按年龄分组，我只需缓存那些年龄大于 35 的结果。那么 condition 能实现这种效果。

SpEL 支持的表达式可以作为 condition 的值，结果为 true 或 false。如果表达式结果为 true，则调用方法时会执行正常的缓存逻辑（查缓存-有就返回-没有就执行方法-方法返回不空就添加缓存）；否则，调用方法时就好像该方法没有声明缓存一样（即无论传入了什么参数或者缓存中有些什么值，都会执行方法，并且结果不放入缓存）。下面举个例子：

我们看一下数据库，以这两条数据为例：

　　

我们首先定义一个带条件的缓存方法：

@Override
    @Cacheable(value = {"menuById"}, key = "#id", condition = "#conditionValue > 1")
    public Menu findById(String id, Integer conditionValue) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }

然后分两种情况调用（为了直观可见，直接将 id 写在代码中）：

@GetMapping("/findById/{id}")
    public Menu findById(@PathVariable("id")String id){
        Menu menu0 = menuService.findById("fe278df654adf23cf6687f64d1549c0a", 0);
        Menu menu2 = menuService.findById("fb6106721f289ebf0969565fa8361c75", 2);
        return menu0;
    }

虽然两次请求都调用了方法，但只有第二次请求缓存了"微服务测试2"。只有在满足条件 condition 的情况下才会进行调用，这样才能将结果缓存。接下来我们再请求一遍，看下结果和打印：

可以看到，“微服务测试2”由于已经有了缓存，所以没有再执行方法体。而“微服务测试0”又一次执行了。

7. unless

执行后判断，不缓存的条件。SpEL 可以支持表达式结果为 true 或 false，用于 unless。当结果为 true 时，不缓存。举个例子：

我们先清除 redis 中的数据。然后看看 mysql 中的数据：

　　

然后编写一个缓存方法（在该方法中，result代表方法的返回值。关于）：

@Override
    @Cacheable(value = {"menuById"}, key = "#id", unless = "#result.type == 'folder'")
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }

然后调用该方法：

@GetMapping("/findById/{id}")
    public Menu findById(@PathVariable("id")String id){
        Menu menu0 = menuService.findById("fe278df654adf23cf6687f64d1549c0a");
        Menu menu2 = menuService.findById("fb6106721f289ebf0969565fa8361c75");
        return menu0;
    }

可以看到，两次都执行了方法体（其实，unless 条件就是在方法执行完毕后调用，所以它不会影响方法的执行），但是结果只有 menu.type = ‘page’ 的缓存了，说明 unless 参数生效了。

8. condition VS unless ？

既然 condition 和 unless 都能决定是否进行缓存，那么同时指定这两个参数并且结果相冲突的时候，会怎么样呢？我们来试一试。

首先清除 redis 数据，然后在缓存方法上加上 condition=“true”，如：

@Override
    @Cacheable(value = {"menuById"}, key = "#id", condition = "true", unless = "#result.type == 'folder'")
    public Menu findById(String id) {
        Menu menu = this.getById(id);
        if (menu != null){
            System.out.println("menu.name = " + menu.getName());
        }
        return menu;
    }

其它代码不变，我们来看一下缓存结果和打印：

可以看到，虽然两次调用都执行了，但是，type=‘folder’ 的还是被排除了。在这种情况下，unless 的优先级高于 condition。接着，我们将condition设为“false”，再进行尝试，结果是：

可以看到，两次调用的结果都没有缓存。在这种情况下，优先使用condition而不是unless。总结起来就是：

• condition 不指定相当于 true，unless 不指定相当于 false

• condition = false，一定不会缓存；

• condition = true，且 unless = true，不缓存；

• condition = true，且 unless = false，缓存；

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!