{"id":656,"date":"2026-04-04T22:33:11","date_gmt":"2026-04-04T21:33:11","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=656"},"modified":"2026-06-16T22:37:58","modified_gmt":"2026-06-16T21:37:58","slug":"redis-in-java-caching-pub-sub-und-session-management-mit-spring-data-redis","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=656","title":{"rendered":"Redis in Java \u2013 Caching, Pub\/Sub und Session-Management mit Spring Data Redis"},"content":{"rendered":"\n

Redis ist der Schweizer Taschenmesser unter den Datenbanken: extrem schnell, vielf\u00e4ltig einsetzbar und nativ auf Performance optimiert. W\u00e4hrend relationale Datenbanken auf Festplattenpersistenz und ACID-Transaktionen optimiert sind, gl\u00e4nzt Redis als In-Memory-Datenbank mit Sub-Millisekunden-Latenz. Spring Data Redis macht die Integration in Spring-Boot-Projekte nahtlos.<\/p>\n\n\n\n

Redis als Cache<\/h2>\n\n\n\n

Die h\u00e4ufigste Anwendung von Redis in Java-Projekten ist das Caching. Spring Boot bietet mit @Cacheable<\/code> eine deklarative Schnittstelle \u2013 das Backend tauscht man \u00fcber die Konfiguration aus.<\/p>\n\n\n\n

Abh\u00e4ngigkeiten:<\/p>\n\n\n

<dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>org.springframework.boot<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>spring-boot-starter-data-redis<\/artifactId<\/span>><\/span>\n<\/dependency<\/span>><\/span>\n<dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>org.springframework.boot<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>spring-boot-starter-cache<\/artifactId<\/span>><\/span>\n<\/dependency<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Konfiguration f\u00fcr Redis als Cache-Backend:<\/p>\n\n\n
@Configuration\n@EnableCaching\npublic<\/span> class<\/span> CacheConfig<\/span> <\/span>{\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n
spring.cache.type=redis\nspring.data.redis.host=localhost\nspring.data.redis.port=6379\nspring.cache.redis.time-to-live=10m\n<\/code><\/span><\/pre>\n\n\n
Cacheable Service:<\/p>\n\n\n
@Service\npublic<\/span> class<\/span> ProduktService<\/span> <\/span>{\n\n    @Cacheable(value = \"produkte\"<\/span>, key = \"#id\"<\/span>)\n    public<\/span> Produkt findById(Long id) {\n        <em>\/\/ Nur beim ersten Aufruf (Cache Miss) \u2013 danach aus Redis<\/em><\/span>\n        return<\/span> produktRepository.findById(id)\n            .orElseThrow();\n    }\n\n    @CacheEvict(value = \"produkte\"<\/span>, key = \"#id\"<\/span>)\n    public<\/span> void update(Long id, ProduktUpdate update) {\n        <em>\/\/ Cache-Eintrag wird nach dem Update gel\u00f6scht<\/em><\/span>\n        produktRepository.update(id, update);\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Spring pr\u00fcft vor dem Methodenaufruf, ob der Schl\u00fcssel im Redis-Cache existiert. Wenn ja, wird die Methode \u00fcbersprungen und der gecachte Wert zur\u00fcckgegeben. @CacheEvict<\/code> entfernt den Eintrag nach schreibenden Operationen.<\/p>\n\n\n\n
RedisTemplate f\u00fcr direkten Zugriff<\/h2>\n\n\n\n
F\u00fcr granulare Operationen bietet Spring Data Redis das RedisTemplate<\/code>:<\/p>\n\n\n
@Bean\npublic RedisTemplate<String<\/span>, Produkt> redisTemplate(\n        RedisConnectionFactory factory) {\n    RedisTemplate<String<\/span>, Produkt> template = new<\/span> RedisTemplate<>();\n    template.setConnectionFactory(factory);\n    template.setKeySerializer(new<\/span> StringRedisSerializer());\n    template.setValueSerializer(\n        new<\/span> Jackson2JsonRedisSerializer<>(Produkt.class));\n    return<\/span> template;\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Direkte Nutzung:<\/p>\n\n\n
<em>\/\/ Speichern mit TTL<\/em><\/span>\nredisTemplate.opsForValue()\n    .set(\"produkt:42\"<\/span>, produkt, Duration.ofMinutes(30<\/span>));\n\n<em<\/span>><\/span>\/\/ TTL pr\u00fcfen<\/em<\/span>><\/span><\/span>\nLong ttl = redisTemplate.getExpire(\"produkt:42\"<\/span>); <em<\/span>><\/span>\/\/ in Sekunden<\/em<\/span>><\/span><\/span>\n\n<em<\/span>><\/span>\/\/ Atomar inkrementieren<\/em<\/span>><\/span><\/span>\nLong aufrufe = redisTemplate.opsForValue()\n    .increment(\"counter:produkt:42\"<\/span>);\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Redis bietet neben einfachen Key-Value-Operationen auch Listen, Sets, Sorted Sets und Hashes als native Datenstrukturen \u2013 alle \u00fcber redisTemplate.opsForList()<\/code>, .opsForSet()<\/code> etc. ansprechbar.<\/p>\n\n\n\n
Pub\/Sub mit Redis<\/h2>\n\n\n\n
Redis kann als Message Broker fungieren \u2013 f\u00fcr einfache Ereignisbenachrichtigungen ohne den Overhead von Kafka oder RabbitMQ.<\/p>\n\n\n\n
Konfiguration:<\/p>\n\n\n
@Configuration\npublic<\/span> class<\/span> RedisPubSubConfig<\/span> <\/span>{\n\n    @Bean\n    public<\/span> RedisMessageListenerContainer container(\n            RedisConnectionFactory factory,\n            MessageListenerAdapter adapter) {\n        RedisMessageListenerContainer container =\n            new<\/span> RedisMessageListenerContainer();\n        container.setConnectionFactory(factory);\n        container.addMessageListener(adapter,\n            new<\/span> PatternTopic(\"bestellungen.*\"<\/span>));\n        return<\/span> container;\n    }\n\n    @Bean\n    public<\/span> MessageListenerAdapter adapter(\n            BestellungSubscriber subscriber) {\n        return<\/span> new<\/span> MessageListenerAdapter(subscriber, \"onMessage\"<\/span>);\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Subscriber:<\/p>\n\n\n
@Component\npublic class<\/span> BestellungSubscriber<\/span> <\/span>{\n\n    public void<\/span> onMessage(String<\/span> nachricht) {\n        log.info(\"Neue Bestellung: {}\"<\/span>, nachricht);\n        <em<\/span>><\/span>\/\/ Lager aktualisieren, E-Mail versenden ...<\/em<\/span>><\/span><\/span>\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Publisher:<\/p>\n\n\n
redisTemplate<\/span>.convertAndSend<\/span>(\n    \"bestellungen<\/span>.neu<\/span>\", bestellungJson<\/span>);\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Pub\/Sub eignet sich f\u00fcr Szenarien wie Cache-Invalidation \u00fcber Service-Grenzen hinweg oder Echtzeit-Benachrichtigungen. F\u00fcr garantierte Zustellung (At-Least-Once) sollte man jedoch auf Kafka oder Redis Streams ausweichen.<\/p>\n\n\n\n
Redis Streams<\/h2>\n\n\n\n
Redis Streams (seit Redis 5.0) bieten eine persistente Nachrichtenstruktur mit Consumer Groups \u2013 ideal f\u00fcr Event-Driven-Architekturen, bei denen Nachrichten nicht verloren gehen d\u00fcrfen:<\/p>\n\n\n
<em>\/\/ Nachricht schreiben<\/em><\/span>\nMap<\/span><String<\/span>, String<\/span>> body = Map<\/span>.of(\n    \"produktId\"<\/span>, \"42\"<\/span>, \"menge\"<\/span>, \"3\"<\/span>);\nredisTemplate.opsForStream()\n    .add(StreamRecords.string(body)\n        .withStreamKey(\"bestellungen\"<\/span>));\n\n<em<\/span>><\/span>\/\/ Consumer Group erstellen (einmalig)<\/em<\/span>><\/span><\/span>\nredisTemplate.opsForStream().createGroup(\n    \"bestellungen\"<\/span>, \"lager-service\"<\/span>);\n\n<em<\/span>><\/span>\/\/ Nachrichten lesen<\/em<\/span>><\/span><\/span>\nList<MapRecord<String<\/span>, String<\/span>, String<\/span>>> records =\n    redisTemplate.opsForStream().read(\n        Consumer.from(\"lager-service\"<\/span>, \"instanz-1\"<\/span>),\n        StreamReadOptions.empty().count(10<\/span>),\n        StreamOffset.create(\"bestellungen\"<\/span>,\n            ReadOffset.lastConsumed()));\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Im Gegensatz zu Pub\/Sub bleiben Nachrichten in Streams erhalten und k\u00f6nnen von mehreren Consumer Groups unabh\u00e4ngig konsumiert werden. Spring Data Redis unterst\u00fctzt Streams nativ \u00fcber opsForStream()<\/code>.<\/p>\n\n\n\n
Spring Session mit Redis<\/h2>\n\n\n\n
Session-Management mit Redis verteilt HTTP-Sessions \u00fcber mehrere Server-Instanzen, ohne dass der Client an eine bestimmte Instanz gebunden wird (Sticky Sessions):<\/p>\n\n\n
<dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>org.springframework.session<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>spring-session-data-redis<\/artifactId<\/span>><\/span>\n<\/dependency<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Konfiguration:<\/p>\n\n\n
spring.session.store-type=redis\nspring.session.redis.flush-mode=on_save\nspring.session.timeout=30m\n<\/code><\/span><\/pre>\n\n\n
Danach ist jede HTTP-Session automatisch in Redis gespeichert \u2013 alle Server-Instanzen teilen sich die Sessions. Ein Load Balancer kann Requests frei verteilen, ohne dass der Benutzer seinen Login verliert. Aufr\u00e4umen \u00fcbernimmt Redis \u00fcber den TTL-Mechanismus.<\/p>\n\n\n\n
Performance-Vergleich<\/h2>\n\n\n\n
Operation<\/th>Redis (lokal)<\/th>PostgreSQL<\/th>Faktor<\/th><\/tr><\/thead>
Einfaches GET<\/td>~0,1 ms<\/td>~2 ms<\/td>20\u00d7<\/td><\/tr>
Query mit Index<\/td>~0,5 ms<\/td>~5 ms<\/td>10\u00d7<\/td><\/tr>
Schreiben (single)<\/td>~0,3 ms<\/td>~8 ms<\/td>25\u00d7<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Die Zahlen variieren je nach Hardware und Netzwerk, aber die Gr\u00f6\u00dfenordnung macht klar: Redis ist f\u00fcr Hot-Paths und Caching ideal.<\/p>\n\n\n\n
Fazit<\/h2>\n\n\n\n
Redis erg\u00e4nzt klassische relationale Datenbanken ideal. Als Caching-Layer reduziert es die Last auf PostgreSQL\/MySQL, als Pub\/Sub-Broker erm\u00f6glicht es ereignisgesteuerte Architekturen, und als Session-Store entkoppelt es den Anwendungszustand vom Server. Spring Data Redis abstrahiert die Redis-Kommunikation hinter gewohnten Spring-Idiomen wie @Cacheable<\/code>, RedisTemplate<\/code> und MessageListenerAdapter<\/code>. Die nahtlose Integration macht Redis zur ersten Wahl f\u00fcr performante Java-Anwendungen.<\/p>\n\n\n\n
Hinweis zur Lizenz:<\/strong> Seit Version 7.4 (M\u00e4rz 2024) ist Redis nicht mehr unter der BSD-Lizenz verf\u00fcgbar, sondern dual lizenziert unter RSALv2 und SSPLv1. F\u00fcr die meisten Entwickler \u00e4ndert sich dadurch nichts \u2013 interne und pers\u00f6nliche Nutzung bleibt frei. Wer eine echte Open-Source-Alternative sucht, findet mit Valkey<\/strong> (Linux Foundation) einen kompatiblen Fork unter BSD-Lizenz.<\/p>\n","protected":false},"excerpt":{"rendered":"
Redis ist der Schweizer Taschenmesser unter den Datenbanken: extrem schnell, vielf\u00e4ltig einsetzbar und nativ auf Performance optimiert. W\u00e4hrend relationale Datenbanken auf Festplattenpersistenz und ACID-Transaktionen optimiert sind, gl\u00e4nzt Redis als In-Memory-Datenbank mit Sub-Millisekunden-Latenz. Spring Data Redis macht die Integration in Spring-Boot-Projekte nahtlos. Redis als Cache Die h\u00e4ufigste Anwendung von Redis in Java-Projekten ist das Caching. Spring […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4,5],"tags":[],"class_list":["post-656","post","type-post","status-publish","format-standard","hentry","category-plain_java","category-spring"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/656","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=656"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/656\/revisions"}],"predecessor-version":[{"id":657,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/656\/revisions\/657"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=656"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=656"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=656"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}