À propos de l'annotation Spring Redis pour implémenter le mécanisme de mise en cache

La colonne suivante du Tutoriel Redis vous présentera le mécanisme de mise en cache implémenté par les annotations Spring Redis. J'espère que cela sera utile aux amis dans le besoin !

1. Configuration XML

 <bean id="poolConfigTax" class="redis.clients.jedis.JedisPoolConfig">  
        <property name="maxIdle" value="${redis_tax.maxIdle}" />  
        <property name="minIdle" value="${redis_tax.minIdle}" />  
        <property name="maxTotal" value="${redis_tax.maxTotal}" />
        <property name="testOnBorrow" value="${redis_tax.testOnBorrow}" />  
    </bean>  
    <!-- Tax redis 数据库  -->
    <bean id="connectionFactoryTax" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"   
        p:host-name="${redis_tax.host}" p:port="${redis_tax.port}" p:password="${redis_tax.pass}"  p:pool-config-ref="poolConfigTax"
        p:database="0"/>  
    <!--redis操作模版,使用该对象可以操作redis  -->  
    <bean id="redisTemplateTax" class="org.springframework.data.redis.core.RedisTemplate" >    
        <property name="connectionFactory" ref="connectionFactoryTax" />    
        <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can&#39;t cast to String！！  -->    
        <property name="keySerializer" >    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />    
        </property>    
        <property name="valueSerializer" >    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />    
        </property>    
        <property name="hashKeySerializer">    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
        </property>    
        <property name="hashValueSerializer">    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>    
        </property>    
        <!--开启事务  -->  
        <property name="enableTransactionSupport" value="false"></property>  
    </bean>   
    <!-- 配置RedisCacheManager -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplateTax" />
    </bean>
    <cache:annotation-driven cache-manager="redisCacheManager"/>

2 Explication détaillée des annotations de cache @Cacheable, @CacheEvict, @CachePut
1 Explication détaillée de l'utilisation de @Cacheable
1. ça a servi ? Utilisé sur des méthodes ou des classes.
2. Quelle est la différence entre ces deux usages ?
Utilisé sur une méthode pour indiquer : la valeur de retour de cette méthode sera mise en cache
Utilisé sur une classe pour indiquer : toutes les méthodes de la classe supportent cette annotation
3. Quel est le résultat après utilisation ? La prochaine fois que cette méthode sera appelée avec la même méthode et les mêmes paramètres, la valeur sera obtenue directement du cache sans qu'il soit nécessaire de réexécuter la méthode.
4. Comment la valeur de retour est-elle stockée dans le cache ? Stockée dans le cache sous forme de paires clé-valeur, la valeur est la valeur de retour et la clé est générée par deux stratégies : la stratégie par défaut et la stratégie personnalisée
5. Comment utiliser la stratégie par défaut et la stratégie par défaut ?
Stratégie par défaut : double épissage "::" après la valeur, liste de paramètres formels, lorsque le paramètre formel est un objet, utilisez le format json :

@CacheConfig(cacheNames="enterprise")//<!-- 声明缓存使用的缓存名称 -->
public interface EnterpriseRepo extends JpaRepository<Enterprise, Integer>,JpaSpecificationExecutor<Enterprise>{
    @Cacheable(value="cash1")
    Enterprise findByid(Integer id);

    @CachePut(value="cash1")
    Enterprise save(Enterprise enterprise);

}

Stratégie personnalisée : l'attribut clé est utilisé pour spécifier Spring Le résultat renvoyé par la méthode cache est la clé correspondante. Cette propriété prend en charge les expressions SpringEL. Lorsque nous ne spécifions pas cet attribut, Spring utilisera la stratégie par défaut pour générer les clés.

La stratégie personnalisée signifie que nous pouvons spécifier notre clé via l'expression EL de Spring. Les expressions EL peuvent ici utiliser des paramètres de méthode et leurs propriétés correspondantes. Lors de l'utilisation des paramètres de méthode, nous pouvons utiliser directement "#parameter name" ou "#pparameter index". Voici quelques exemples d’utilisation de paramètres comme clés.

@Cacheable(value="users", key="#id")

   public User find(Integer id) {
      return null;
   }

   @Cacheable(value="users", key="#p0")
   public User find(Integer id) {
      return null;
   }

   @Cacheable(value="users", key="#user.id")
   public User find(User user) {
      return null;
   }

   @Cacheable(value="users", key="#p0.id")
   public User find(User user) {
      return null;
   }

En plus des paramètres de méthode ci-dessus en tant que clés, Spring nous fournit également un objet racine qui peut être utilisé pour générer des clés. Grâce à cet objet racine, nous pouvons obtenir les informations suivantes.

Lorsque nous voulons utiliser les propriétés de l'objet racine comme clé, nous pouvons également omettre "#root", car Spring utilise les propriétés de l'objet racine par défaut. Par exemple :

@Cacheable(value={"users", "xxx"}, key="caches[1].name")

public User find(User user) {
   return null;
}

6. L'attribut condition spécifie la condition d'occurrence

Parfois, nous ne souhaitons pas mettre en cache tous les résultats de retour d'une méthode. Cette fonction peut être réalisée via l'attribut condition. L'attribut condition est vide par défaut, ce qui signifie que toutes les situations d'appel seront mises en cache. Sa valeur est spécifiée via une expression SpringEL. Lorsqu'elle est vraie, cela signifie mise en cache ; lorsqu'elle est fausse, cela signifie aucune mise en cache, c'est-à-dire que la méthode sera exécutée à chaque appel de la méthode. L'exemple suivant indique que la mise en cache n'aura lieu que lorsque l'identifiant de l'utilisateur est un nombre pair.

@Cacheable(value={"users"}, key="#user.id", condition="#user.id%2==0")
public User find(User user) {
   System.out.println("find user by user " + user);
   return user;
}

2. @CachePut

Dans un environnement qui prend en charge Spring Cache, pour les méthodes annotées avec @Cacheable, Spring vérifiera s'il existe un élément de cache avec la même clé dans le Cache avant chacune. exécution. , si elle existe, la méthode ne sera plus exécutée, mais le résultat sera obtenu directement du cache et renvoyé sinon, il sera exécuté et le résultat renvoyé sera stocké dans le cache spécifié. @CachePut peut également déclarer une méthode pour prendre en charge la fonctionnalité de mise en cache. La différence avec @Cacheable est que la méthode annotée avec @CachePut ne vérifiera pas s'il y a des résultats précédemment exécutés dans le cache avant l'exécution. Au lieu de cela, la méthode sera exécutée à chaque fois et les résultats de l'exécution seront stockés sous forme de clé. paires de valeurs dans le cache spécifié.
Généralement utilisé dans les méthodes de sauvegarde et de mise à jour.

@CachePut peut également être annoté sur les classes et les méthodes. Les attributs que nous pouvons spécifier lors de l'utilisation de @CachePut sont les mêmes que @Cacheable.

@CachePut("users")//La méthode sera exécutée à chaque fois et le résultat sera stocké dans le cache spécifié

public User find(Integer id) {
      return null;
}

3 @CacheEvict

@CacheEvict est utilisé pour annoter les méthodes ou les classes qui doivent vider les éléments du cache. Lorsqu'il est marqué sur une classe, cela signifie que l'exécution de toutes les méthodes qu'elle contient déclenchera l'opération de vidage du cache. Les attributs qui peuvent être spécifiés par @CacheEvict incluent value, key, condition, allEntries et beforeInvocation. La sémantique de la valeur, de la clé et de la condition est similaire aux attributs correspondants de @Cacheable. Autrement dit, la valeur indique sur quel cache l'opération de suppression se produit (correspondant au nom du cache) ; la clé indique quelle clé doit être effacée. Si elle n'est pas spécifiée, la clé générée par la condition par défaut indique les conditions ; sous lequel l'opération de compensation a lieu. Présentons les deux nouveaux attributs allEntries et beforeInvocation.
1. Attribut allEntries
allEntries est un type booléen, indiquant si tous les éléments du cache doivent être effacés. La valeur par défaut est false, ce qui signifie que ce n'est pas nécessaire. Lorsque allEntries est spécifié comme true, Spring Cache ignorera la clé spécifiée. Parfois, nous devons effacer tous les éléments du cache en même temps, ce qui est plus efficace que de supprimer les éléments un par un.

@CacheEvict(value="users", allEntries=true)
public void delete(Integer id) {
   System.out.println("delete user by id: " + id);
}

2. attribut beforeInvocation
L'opération d'effacement est déclenchée par défaut une fois la méthode correspondante exécutée avec succès, c'est-à-dire que l'opération d'effacement ne sera pas déclenchée si la méthode ne parvient pas à revenir en raison du lancement d'un exception. Vous pouvez utiliser beforeInvocation pour modifier l'heure à laquelle l'opération de suppression est déclenchée. Lorsque nous spécifions que la valeur de l'attribut est vraie, Spring effacera l'élément spécifié dans le cache avant d'appeler cette méthode.

@CacheEvict(value="users", beforeInvocation=true)
public void delete(Integer id) {
   System.out.println("delete user by id: " + id);
}

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!