Spring Redis Error Handle

Měl jsem úplně stejný problém. Vyvíjím nějaké datové služby proti databázi pomocí Redis jako úložiště mezipaměti prostřednictvím anotací Spring Caching. Pokud se server Redis stane nedostupným, chci, aby služby nadále fungovaly, jako by nebyly v mezipaměti, spíše než házet výjimky.

Nejprve jsem vyzkoušel vlastní CacheErrorHandler, mechanismus poskytovaný Springem. Úplně to nefungovalo, protože zpracovává pouze RuntimeExceptions a stále umožňuje věci jako java.net.ConnectException vyhodit věci do povětří.

Nakonec jsem rozšířil RedisTemplate a přepsal jsem několik metod execute() tak, aby zaznamenávaly varování namísto šíření výjimek. Vypadá to jako trochu hack a možná jsem přepsal příliš málo metod execute() nebo příliš mnoho, ale ve všech mých testovacích případech to funguje jako kouzlo.

Tento přístup má však důležitý provozní aspekt. Pokud se server Redis stane nedostupným, musíte jej před opětovným zpřístupněním vyprázdnit (vyčistit záznamy). V opačném případě existuje možnost, že začnete načítat položky mezipaměti, které obsahují nesprávná data kvůli aktualizacím, které mezitím proběhly.

Níže je uveden zdroj. Klidně to použijte. Doufám, že to pomůže.

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.serializer.RedisSerializer;


/**
 * An extension of RedisTemplate that logs exceptions instead of letting them propagate.
 * If the Redis server is unavailable, cache operations are always a "miss" and data is fetched from the database.
 */
public class LoggingRedisTemplate<K, V> extends RedisTemplate<K, V> {

    private static final Logger logger = LoggerFactory.getLogger(LoggingRedisTemplate.class);


    @Override
    public <T> T execute(final RedisCallback<T> action, final boolean exposeConnection, final boolean pipeline) {
        try {
            return super.execute(action, exposeConnection, pipeline);
        }
        catch(final Throwable t) {
            logger.warn("Error executing cache operation: {}", t.getMessage());
            return null;
        }
    }


    @Override
    public <T> T execute(final RedisScript<T> script, final List<K> keys, final Object... args) {
        try {
            return super.execute(script, keys, args);
        }
        catch(final Throwable t) {
            logger.warn("Error executing cache operation: {}", t.getMessage());
            return null;
        }
    }


    @Override
    public <T> T execute(final RedisScript<T> script, final RedisSerializer<?> argsSerializer, final RedisSerializer<T> resultSerializer, final List<K> keys, final Object... args) {
        try {
            return super.execute(script, argsSerializer, resultSerializer, keys, args);
        }
        catch(final Throwable t) {
            logger.warn("Error executing cache operation: {}", t.getMessage());
            return null;
        }
    }


    @Override
    public <T> T execute(final SessionCallback<T> session) {
        try {
            return super.execute(session);
        }
        catch(final Throwable t) {
            logger.warn("Error executing cache operation: {}", t.getMessage());
            return null;
        }
    }
}