Comment utiliser le cache dans le projet SpringBoot

Avant-propos

La mise en cache peut améliorer efficacement les performances et la stabilité du système en stockant en mémoire les données fréquemment consultées, réduisant ainsi la pression sur les sources de données sous-jacentes telles que les bases de données. Je pense que tout le monde l'a plus ou moins utilisé dans ses projets, et notre projet ne fait pas exception. Cependant, lorsque j'ai récemment révisé le code de l'entreprise, l'écriture était très stupide et basse. L'écriture approximative est la suivante :

public User getById(String id) {
	User user = cache.getUser();
    if(user != null) {
        return user;
    }
    // 从数据库获取
    user = loadFromDB(id);
    cahce.put(id, user);
	return user;
}

In. En fait, Spring Boot fournit une puissante abstraction de mise en cache qui facilite l'ajout de mise en cache à votre application. Cet article expliquera comment utiliser les différentes annotations de cache fournies par Spring pour implémenter les meilleures pratiques de mise en cache.

Activer la mise en cache @EnableCaching

La plupart des projets sont désormais des projets SpringBoot Nous pouvons ajouter l'annotation @EnableCaching à la classe de démarrage pour activer la fonction de mise en cache. @EnableCaching来开启缓存功能。

@SpringBootApplication
@EnableCaching
public class SpringCacheApp {

    public static void main(String[] args) {
        SpringApplication.run(Cache.class, args);
    }
}

既然要能使用缓存，就需要有一个缓存管理器Bean，默认情况下，@EnableCaching 将注册一个ConcurrentMapCacheManager的Bean，不需要单独的 bean 声明。ConcurrentMapCacheManager将值存储在ConcurrentHashMap的实例中，这是缓存机制的最简单的线程安全实现。

自定义缓存管理器

默认的缓存管理器并不能满足需求，因为她是存储在jvm内存中的，那么如何存储到redis中呢？这时候需要添加自定义的缓存管理器。

1.添加依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.配置Redis缓存管理器

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
            .disableCachingNullValues()
            .serializeValuesWith(SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory())
            .cacheDefaults(redisCacheConfiguration)
            .build();

        return redisCacheManager;
    }
}

现在有了缓存管理器以后，我们如何在业务层面操作缓存呢？

我们可以使用@Cacheable、@CachePut 或@CacheEvict 注解来操作缓存了。

@Cacheable

该注解可以将方法运行的结果进行缓存，在缓存时效内再次调用该方法时不会调用方法本身，而是直接从缓存获取结果并返回给调用方。

例子1：缓存数据库查询的结果。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(value = "myCache", key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }
}

在此示例中，@Cacheable 注解用于缓存 getEntityById()方法的结果，该方法根据其 ID 从数据库中检索 MyEntity 对象。

但是如果我们更新数据呢？旧数据仍然在缓存中？

@CachePut

然后@CachePut 出来了, 与 @Cacheable 注解不同的是使用 @CachePut 注解标注的方法，在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式写入指定的缓存中。@CachePut 注解一般用于更新缓存数据，相当于缓存使用的是写模式中的双写模式。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @CachePut(value = "myCache", key = "#entity.id")
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }
}

@CacheEvict

标注了 @CacheEvict 注解的方法在被调用时，会从缓存中移除已存储的数据。@CacheEvict 注解一般用于删除缓存数据，相当于缓存使用的是写模式中的失效模式。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

     @CacheEvict(value = "myCache", key = "#id")
    public void deleteEntityById(Long id) {
        repository.deleteById(id);
    }
}

@Caching

@Caching 注解用于在一个方法或者类上，同时指定多个 Spring Cache 相关的注解。

例子1：@Caching注解中的evict属性指定在调用方法 saveEntity 时失效两个缓存。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(value = "myCache", key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

    @Caching(evict = {
        @CacheEvict(value = "myCache", key = "#entity.id"),
        @CacheEvict(value = "otherCache", key = "#entity.id")
    })
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }

}

例子2：调用getEntityById方法时，Spring会先检查结果是否已经缓存在myCache缓存中。如果是，Spring 将返回缓存的结果而不是执行该方法。如果结果尚未缓存，Spring 将执行该方法并将结果缓存在 myCache 缓存中。方法执行后，Spring会根据@CacheEvict注解从otherCache缓存中移除缓存结果。

@Service
public class MyService {

    @Caching(
        cacheable = {
            @Cacheable(value = "myCache", key = "#id")
        },
        evict = {
            @CacheEvict(value = "otherCache", key = "#id")
        }
    )
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

}

例子3：当调用saveData方法时，Spring会根据@CacheEvict注解先从otherCache缓存中移除数据。然后，Spring 将执行该方法并将结果保存到数据库或外部 API。

方法执行后，Spring 会根据@CachePut注解将结果添加到 myCache、myOtherCache 和 myThirdCache 缓存中。Spring 还将根据@Cacheable注解检查结果是否已缓存在 myFourthCache 和 myFifthCache

@Service
public class MyService {

    @Caching(
        put = {
            @CachePut(value = "myCache", key = "#result.id"),
            @CachePut(value = "myOtherCache", key = "#result.id"),
            @CachePut(value = "myThirdCache", key = "#result.name")
        },
        evict = {
            @CacheEvict(value = "otherCache", key = "#id")
        },
        cacheable = {
            @Cacheable(value = "myFourthCache", key = "#id"),
            @Cacheable(value = "myFifthCache", key = "#result.id")
        }
    )
    public MyEntity saveData(Long id, String name) {
        // Code to save data to a database or external API
        MyEntity entity = new MyEntity(id, name);
        return entity;
    }

}

Puisque vous souhaitez pouvoir utiliser la mise en cache, vous avez besoin d'un bean gestionnaire de cache. Par défaut, @EnableCaching enregistrera un bean ConcurrentMapCacheManager, et aucun bean séparé n'est disponible. déclaration requise. ConcurrentMapCacheManager stocke les valeurs dans une instance de ConcurrentHashMap, qui est l'implémentation thread-safe la plus simple du mécanisme de mise en cache. 🎜🎜Gestionnaire de cache personnalisé🎜🎜Le gestionnaire de cache par défaut ne peut pas répondre aux besoins car il est stocké dans la mémoire jvm, alors comment le stocker dans redis ? À ce stade, vous devez ajouter un gestionnaire de cache personnalisé. 🎜🎜1. Ajouter des dépendances🎜

@CacheConfig(cacheNames={"myCache"})
@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

    @CachePut(key = "#entity.id")
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }

    @CacheEvict(key = "#id")
    public void deleteEntityById(Long id) {
        repository.deleteById(id);
    }
}

🎜2. Configurer le gestionnaire de cache Redis🎜

//when id >10, the @CachePut works. 
@CachePut(key = "#entity.id", condition="#entity.id > 10")
public void saveEntity(MyEntity entity) {
	repository.save(entity);
}


//when result != null, the @CachePut works.
@CachePut(key = "#id", condition="#result == null")
public void saveEntity1(MyEntity entity) {
	repository.save(entity);
}

🎜Maintenant que nous avons le gestionnaire de cache, comment exploiter le cache au niveau métier ? 🎜🎜Nous pouvons utiliser l'annotation @Cacheable, @CachePut ou @CacheEvict pour faire fonctionner le cache. 🎜🎜@Cacheable🎜🎜Cette annotation peut mettre en cache les résultats de l'exécution de la méthode. Lorsque la méthode est à nouveau appelée dans le délai du cache, la méthode elle-même ne sera pas appelée, mais les résultats seront obtenus directement du cache et renvoyés au demandeur. 🎜🎜🎜🎜Exemple 1 : Cache Les résultats de la requête de base de données. 🎜

//方法调用完成之后，清理所有缓存
@CacheEvict(value="myCache",allEntries=true)
public void delectAll() {
    repository.deleteAll();
}

//方法调用之前，清除所有缓存
@CacheEvict(value="myCache",beforeInvocation=true)
public void delectAll() {
    repository.deleteAll();
}

🎜Dans cet exemple, l'annotation @Cacheable est utilisée pour mettre en cache les résultats de la méthode getEntityById() de la base de données en fonction de son ID</code > Récupérez l'objet MyEntity. 🎜🎜Mais et si nous mettions à jour les données ? D'anciennes données toujours en cache ? 🎜🎜@CachePut🎜🎜 Puis <code>@CachePut est sorti. La différence avec l'annotation @Cacheable est d'utiliser la méthode d'annotation @CachePut. exécution Au lieu de vérifier s'il y a des résultats précédemment exécutés dans le cache, la méthode sera exécutée à chaque fois et les résultats de l'exécution seront écrits dans le cache spécifié sous la forme de paires clé-valeur. L'annotation @CachePut est généralement utilisée pour mettre à jour les données du cache, ce qui équivaut au cache utilisant le mode double écriture en mode écriture. 🎜rrreee🎜@CacheEvict🎜🎜La méthode annotée avec @CacheEvict supprimera les données stockées du cache lorsqu'elle sera appelée. L'annotation @CacheEvict est généralement utilisée pour supprimer les données mises en cache, ce qui équivaut au cache utilisant le mode échec en mode écriture. 🎜🎜🎜rrreee🎜@Caching 🎜 🎜L'annotation @Caching est utilisée pour spécifier plusieurs annotations liées à Spring Cache sur une méthode ou une classe en même temps. 🎜🎜🎜🎜Exemple 1 : < L'attribut evict dans l'annotation code>@Caching spécifie que les deux caches sont invalidés lorsque la méthode saveEntity est appelée. 🎜rrreee🎜Exemple 2 : lors de l'appel de la méthode getEntityById, Spring vérifiera d'abord si le résultat a été mis en cache dans le cache myCache. Si tel est le cas, Spring renverra le résultat mis en cache au lieu d'exécuter la méthode. Si le résultat n'est pas déjà mis en cache, Spring exécutera la méthode et mettra en cache le résultat dans le cache myCache. Une fois la méthode exécutée, Spring supprimera le résultat mis en cache du cache otherCache selon l'annotation @CacheEvict. 🎜rrreee🎜Exemple 3 : lors de l'appel de la méthode saveData, Spring supprimera d'abord les données du cache otherCache selon l'annotation @CacheEvict. Spring exécutera ensuite la méthode et enregistrera les résultats dans une base de données ou une API externe. 🎜🎜Une fois la méthode exécutée, Spring ajoutera les résultats au cache myCache, myOtherCache et myThirdCache selon le @CachePut annotation au milieu. Spring vérifiera également si le résultat a été mis en cache dans les caches myFourthCache et myFifthCache en fonction de l'annotation @Cacheable. Si le résultat n'est pas déjà mis en cache, Spring le mettra en cache dans le cache approprié. Si le résultat a déjà été mis en cache, Spring renverra le résultat mis en cache au lieu de réexécuter la méthode. 🎜

@Service
public class MyService {

    @Caching(
        put = {
            @CachePut(value = "myCache", key = "#result.id"),
            @CachePut(value = "myOtherCache", key = "#result.id"),
            @CachePut(value = "myThirdCache", key = "#result.name")
        },
        evict = {
            @CacheEvict(value = "otherCache", key = "#id")
        },
        cacheable = {
            @Cacheable(value = "myFourthCache", key = "#id"),
            @Cacheable(value = "myFifthCache", key = "#result.id")
        }
    )
    public MyEntity saveData(Long id, String name) {
        // Code to save data to a database or external API
        MyEntity entity = new MyEntity(id, name);
        return entity;
    }

}

@CacheConfig

通过@CacheConfig 注解，我们可以将一些缓存配置简化到类级别的一个地方，这样我们就不必多次声明相关值：

@CacheConfig(cacheNames={"myCache"})
@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

    @CachePut(key = "#entity.id")
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }

    @CacheEvict(key = "#id")
    public void deleteEntityById(Long id) {
        repository.deleteById(id);
    }
}

Condition & Unless

• condition作用：指定缓存的条件（满足什么条件才缓存），可用 SpEL 表达式（如 #id>0，表示当入参 id 大于 0 时才缓存）

• unless作用 : 否定缓存，即满足 unless 指定的条件时，方法的结果不进行缓存，使用 unless 时可以在调用的方法获取到结果之后再进行判断（如 #result == null，表示如果结果为 null 时不缓存）

//when id >10, the @CachePut works. 
@CachePut(key = "#entity.id", condition="#entity.id > 10")
public void saveEntity(MyEntity entity) {
	repository.save(entity);
}


//when result != null, the @CachePut works.
@CachePut(key = "#id", condition="#result == null")
public void saveEntity1(MyEntity entity) {
	repository.save(entity);
}

清理全部缓存

通过allEntries、beforeInvocation属性可以来清除全部缓存数据，不过allEntries是方法调用后清理，beforeInvocation是方法调用前清理。

//方法调用完成之后，清理所有缓存
@CacheEvict(value="myCache",allEntries=true)
public void delectAll() {
    repository.deleteAll();
}

//方法调用之前，清除所有缓存
@CacheEvict(value="myCache",beforeInvocation=true)
public void delectAll() {
    repository.deleteAll();
}

SpEL表达式

Spring Cache注解中频繁用到SpEL表达式，那么具体如何使用呢？

SpEL 表达式的语法

Spring Cache可用的变量

最佳实践

通过Spring缓存注解可以快速优雅地在我们项目中实现缓存的操作，但是在双写模式或者失效模式下，可能会出现缓存数据一致性问题（读取到脏数据），Spring Cache 暂时没办法解决。最后我们再总结下Spring Cache使用的一些最佳实践。

• 只缓存经常读取的数据：缓存可以显着提高性能，但只缓存经常访问的数据很重要。很少或从不访问的缓存数据会占用宝贵的内存资源，从而导致性能问题。

• 根据应用程序的特定需求选择合适的缓存提供程序和策略。SpringBoot 支持多种缓存提供程序，包括 Ehcache、Hazelcast 和 Redis。

• 使用缓存时请注意潜在的线程安全问题。对缓存的并发访问可能会导致数据不一致或不正确，因此选择线程安全的缓存提供程序并在必要时使用适当的同步机制非常重要。

• 避免过度缓存。缓存对于提高性能很有用，但过多的缓存实际上会消耗宝贵的内存资源，从而损害性能。在缓存频繁使用的数据和允许垃圾收集不常用的数据之间取得平衡很重要。

• 使用适当的缓存逐出策略。使用缓存时，重要的是定义适当的缓存逐出策略以确保在必要时从缓存中删除旧的或陈旧的数据。

• 使用适当的缓存键设计。缓存键对于每个数据项都应该是唯一的，并且应该考虑可能影响缓存数据的任何相关参数，例如用户 ID、时间或位置。

• 常规数据（读多写少、即时性与一致性要求不高的数据）完全可以使用 Spring Cache，至于写模式下缓存数据一致性问题的解决，只要缓存数据有设置过期时间就足够了。

• 特殊数据（读多写多、即时性与一致性要求非常高的数据），不能使用 Spring Cache，建议考虑特殊的设计（例如使用 Cancal 中间件等）。

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!