Implementierung einer Caching -Schicht in einer Java -Anwendung mit Redis

Redis wird zum Zwischenspeichern in Java -Anwendungen verwendet, um die Leistung zu verbessern, indem die Datenbanklast reduziert und schnelles Datenabruf aktiviert wird. 1. Installieren Sie Redis mit Docker: Docker Run -d -P 6379: 6379 Redis. 2. Fügen Sie Spring-Boot-Starter-Data-Redis- und Salat-Core-Abhängigkeiten in pom.xml hinzu. 3. Konfigurieren Sie die Redis -Verbindung in application.yml mit Host-, Port- und Pooleinstellungen. V. 5. Verwenden Sie @cacheable, um aus Cache abzurufen oder auszuführen und Cache auszuführen, @cacheput, um den Cache nach der Ausführung zu aktualisieren, und @CacheeVict, um zwischengespeicherte Daten zu entfernen. 6. Definieren Sie RediscaCheManager Bean mit Entryttl (Dauer. Ofminutes (10)), um 10-minütige Ablauf zu setzen. 7. Überwachen Sie den Cache mit redis-cli-Befehlen wie Schlüssel * und erhalten Sie "Benutzer :: 1". 8. Schreiben Sie Unit -Tests zur Validierung von Cache -Hits und Misses. Zu den Best Practices gehört die Verwendung sinnvoller Schlüssel, die Vermeidung großer oder sensibler Daten im Cache, den Umgang mit Cache -Missen anmutig und optional das Erwärmen von Cache beim Start. Diese Integration mit Spring Boot vereinfacht die Caching -Implementierung und verbessert die Anwendungsleistung und Skalierbarkeit erheblich.

Durch das Hinzufügen einer Caching -Schicht zu einer Java -Anwendung unter Verwendung von Redis kann die Leistung erheblich verbessern, indem die Datenbanklast reduziert und das Abrufen von Daten beschleunigt wird. Hier erfahren Sie, wie Sie es effektiv implementieren können.

Warum Redis zum Caching verwenden?

Redis ist ein In-Memory-Datenspeicher, der für seine Geschwindigkeit, Flexibilität und Unterstützung für verschiedene Datenstrukturen bekannt ist. Es ist ideal zum Caching, weil:

• Die Daten werden in RAM gespeichert, wodurch die Les-/Schreibvorgänge von Untermillisekunden ermöglicht werden.
• Es unterstützt Ablauf (TTL), wodurch abgestandene Daten verwaltet werden.
• Es integriert sich gut in Java über Kunden wie Salat und Jedis.

Schritt 1: RETIEREN SIE REDIS und Abhängigkeiten

Stellen Sie zunächst sicher, dass Redis läuft. Sie können es lokal installieren oder Docker verwenden:

 Docker Run -d -p 6379: 6379 Redis

Fügen Sie dann die erforderlichen Abhängigkeiten zu Ihrem pom.xml (für Maven) hinzu:

 <De vorangehen>
    <gruppeID> org.springframework.boot </Groupid>
    <artifactid> Spring-Boot-Starter-Data-Redis </artifactid>
</abhängig>
<De vorangehen>
    <GruppeId> io.lettuce </Groupid>
    <artifactId> Salat-Core </artifactid>
</abhängig>

Salat ist der empfohlene Redis-Client für Spring Stiefel aufgrund seiner asynchronen und nicht blockierenden Funktionen.

Schritt 2: Konfigurieren Sie Redis im Spring Start

In application.yml oder application.properties konfigurieren Sie die Redis -Verbindung:

 Frühling:
  Redis:
    Host: Localhost
    Port: 6379
    Kopfsalat:
      Pool:
        Max-Active: 8
        Max-Idle: 8
        min-idle: 0

Sie können auch die RedisConnectionFactory und RedisTemplate bei Bedarf anpassen:

 @Konfiguration
@EnableScaching
öffentliche Klasse Redisconfig {

    @Bohne
    Public Redistemplate <String, Objekt> redistemplate (redisconnectionFactory ConnectionFactory) {
        Redistemplate <string, Object> template = new redistemplate <> ();
        template.setConnectionFactory (ConnectionFactory);
        template.setkeyserializer (neuer StringRedisserializer ());
        template.setValueSerializer (neuer genericjackson2jsonRedisserializer ());
        Rückgabevorlage;
    }
}

Durch die Verwendung GenericJackson2JsonRedisSerializer können komplexe Java -Objekte auf JSON serialisiert und in Redis gespeichert werden.

Schritt 3: Aktivationen von Caching -Anmerkungen aktivieren und verwenden

Kennzeichnen Sie Ihre Hauptantragsklasse oder eine Konfigurationsklasse mit @EnableCaching .

 @SpringbootApplication
@EnableScaching
öffentliche Klassenanwendung {
    public static void main (String [] args) {
        SpringApplication.run (application.class, args);
    }
}

Verwenden Sie nun Caching -Anmerkungen in Ihrer Serviceschicht:

 @Service
Public Class Userservice {

    @Autowired
    private userrepository userrepository;

    @Cacheable (value = "user", key = "#id")
    öffentlicher Benutzer getUserById (Long ID) {
        System.out.println ("Abrufen des Benutzers von DB:" ID);
        return userrepository.findbyId (id) .orelse (null);
    }

    @Cacheput (value = "user", key = "#user.id")
    öffentlicher Benutzeraktualisierer (Benutzerbenutzer) {
        usternepository.save (Benutzer) zurückgeben;
    }

    @Cacheevict (value = "user", key = "#id")
    public void DeleteUser (lange ID) {
        userRepository.deletebyId (id);
    }
}

• @Cacheable : Überprüft den Cache zuerst. Wenn dies vorhanden ist, gibt es den zwischengespeicherten Wert zurück; Ansonsten führt die Methode aus und zwischengespeichert das Ergebnis.
• @CachePut : Fir können immer die Methode ausführen und den Cache aktualisiert.
• @CacheEvict : Entfernt den Eintrag aus dem Cache (nützlich für Löschen von Vorgängen).

Schritt 4: Behandeln Sie den Cache -Verfalls und die Räumung um

Setzen Sie TTL (Zeit-zu-Live), um abgestandene Daten zu vermeiden. Sie können es weltweit in der Konfiguration definieren:

 @Bohne
public rediscachemanager cacheManager (redisconnectionFactory ConnectionFactory) {
    RediscacheConfiguration config = rediscacheConfiguration.DefaultCacheConfig ()
        .Entryttl (Dauer.Ofminutes (10)) // Cache läuft nach 10 Minuten ab
        .SerializeKeysWith (RedisserializationContext.SerializationPair.FromSerializer (neuer StringRedisserializer ()))
        .SerializeValuesWith (RedisserializationContext.SerializationPair.FromSerializer (New Genericjackson2JsonRedisserializer ()));

    Return RediscaCheManager.Builder (ConnectionFactory)
        .CacheDefaults (config)
        .bauen();
}

Dies stellt sicher, dass zwischengespeicherte Benutzer nach 10 Minuten automatisch entfernt werden.

Schritt 5: Überwachen und testen Sie den Cache

Verwenden Sie Redis CLI, um zwischengespeicherte Daten zu inspizieren:

 Redis-Cli
> Schlüssel *
> Holen Sie sich "Benutzer :: 1"

Schreiben Sie auch Unit -Tests, um das Caching -Verhalten zu überprüfen:

 @Prüfen
void sattenCacheSeronFirstcall () {
    UserService.getUserById (1L); // DB Hit
    UserService.getUserById (1L); // sollte zwischengespeichert werden
    // Überprüfen Sie, ob DB nur einmal aufgerufen wird
}

Verwenden Sie Tools wie Spring's CacheManager oder Protokollierung, um Hits/Misses zu bestätigen.

Best Practices

• Verwenden Sie aussagekräftige Cache -Tasten : bevorzugt @Cacheable(value = "users", key = "#id") über komplexe oder lange Schlüssel.
• Vermeiden Sie das Zwischenspeichern große oder empfindliche Daten : Halten Sie den Cache leicht und sicher.
• Plan für Cache -Misses : Ihre App sollte weiterhin funktionieren, wenn Redis gesunken ist oder Daten nicht zwischengespeichert werden.
• Verwenden Sie bei Bedarf die Cache -Erwärmung für kritische Daten während des Starts.

Grundsätzlich ist die Integration von Redis als Caching -Schicht in Java (insbesondere mit Spring Boot) unkompliziert und liefert sofortige Leistungsgewinne. Mit ordnungsgemäßer Konfiguration und intelligenter Verwendung von Anmerkungen können Sie Latenz- und Datenbankdruck reduzieren, ohne Ihren Code zu erschweren.

Das obige ist der detaillierte Inhalt vonImplementierung einer Caching -Schicht in einer Java -Anwendung mit Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!