Effizientes Caching in Spring: Redis-Cache und In-Memory-Cache in Spring einrichten

In der Welt der Java-Entwicklung ist die effiziente Verwaltung von Daten ein entscheidender Faktor für die Leistungsfähigkeit von Anwendungen. Eine bewährte Methode, um die Zugriffszeiten zu optimieren, ist die Implementierung von Caching. In diesem Artikel werden wir uns darauf konzentrieren, wie man Redis-Cache und In-Memory-Cache in einer Spring-Anwendung einrichtet, um die Leistung zu steigern.

Vorteil eines Redis-Cache wäre dass er Persistenz anbietet und so auch nach einem Neustart der Applikation weiterhin die gecachten Daten bereithält. Dafür ist ein direkter In-Memory-Cache natürlich noch performanter, vor allem wenn der Redis-Server über das Netzwerk abgefragt wird. Hier muss man je nach Anwendungsfall abwägen, welcher Cache hier optimal eingesetzt werden kann.

Redis-Cache in Spring einrichten

Redis, als schneller und leistungsstarker In-Memory-Datenbank, ist eine beliebte Wahl für das Caching in Spring-Anwendungen. Hier sind die Schritte, um Redis-Cache in Spring einzurichten:

1. Abhängigkeiten hinzufügen:
   
   Fügen Sie die erforderlichen Abhängigkeiten zu Ihrer pom.xml-Datei hinzu.
   Die zentrale Caching-Abstraktion, die von Spring bereitgestellt wird, befindet sich im Modul spring-context.

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.3</version>
</dependency>Code-Sprache: HTML, XML (xml)

2. Konfiguration erstellen:
   Konfigurieren Sie Redis in Ihrer application.properties-Datei.

spring.redis.host=localhost
spring.redis.port=6379

3. Cache-Konfiguration hinzufügen:
   Fügen Sie die @EnableCaching-Annotation Ihrer Konfigurationsklasse hinzu und erstellen Sie eine Bean-Methode für den Redis-Cache-Manager und den In-Memory-Cache:

@Configuration
@EnableCaching
public class CacheConfig {

    private static final int MAX_REDIS_ENTRY_TTL_IN_MINUTES = 60;
    private static final String REDIS_CACHE_NAMES_PREFIX = "my_module_name";

    @Bean
    @Primary
    public RedisCacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {

        var redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(MAX_REDIS_ENTRY_TTL_IN_MINUTES))
            .prefixCacheNameWith(REDIS_CACHE_NAMES_PREFIX)
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new GenericJackson2JsonRedisSerializer()));

        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(redisCacheConfiguration)
            .build();
    }

    @Bean
    public CacheManager inMemoryCacheManager() {
        return new ConcurrentMapCacheManager();
    }
}
Code-Sprache: PHP (php)

Methoden cachen und Auswahl des Cache Managers

Nach erfolgter Konfiguration kann man die Rückgabe-Werte beliebiger Methoden cachen, um so z.B. eine erneute (zeitaufwändige) Datenbank-Abfrage zu vermeiden. Herzu verwenden wir die Annotation @Cacheable.

@Cacheable(value = "country_by_ip", cacheManager = "inMemoryCacheManager")
public String getCountryByIp(String ip) {
   return this.ipService.getCountryByIp(ip);
}Code-Sprache: JavaScript (javascript)

Bei Verwendung des Redis-Cache kann die Option cacheManager weggelassen werden, da wir diesen in unserer Konfiguration als @Primary gekennzeichnet haben.

@Cacheable(value = "country_by_ip")
public String getCountryByIp(String ip) {
   return this.ipService.getCountryByIp(ip);
}Code-Sprache: JavaScript (javascript)

Fazit

Die Integration von Redis-Cache und In-Memory-Cache in Spring-Anwendungen bietet eine effiziente Möglichkeit, die Leistung zu verbessern und die Antwortzeiten zu optimieren. Die Wahl zwischen den beiden hängt von den Anforderungen Ihrer Anwendung und den spezifischen Nutzungsszenarien ab. Experimentieren Sie mit beiden Ansätzen, um die optimale Lösung für Ihre Anwendung zu finden und eine reibungslose Benutzererfahrung sicherzustellen.