src/main/java/com/packagemanagement/infrastructure/cache/RedisCacheService.java - master - Chebarik/PackageManagement

src/main/java/com/packagemanagement/infrastructure/cache/RedisCacheService.java
111 строк4 KB
Николай Мехоношин
Implemented non functional requirements
14 апр 2026, 18:37
14 апр 2026, 18:372e86838
package com.packagemanagement.infrastructure.cache;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.packagemanagement.application.port.CacheService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Duration;
import java.util.Optional;
import java.util.Set;

@Service
public class RedisCacheService implements CacheService {

    private static final Logger log = LoggerFactory.getLogger(RedisCacheService.class);
    private static final Duration DEFAULT_TTL = Duration.ofMinutes(30);

    private final RedisTemplate<String, Object> redisTemplate;
    private final ObjectMapper objectMapper;

    public RedisCacheService(RedisTemplate<String, Object> redisTemplate,
                             @Qualifier("redisObjectMapper") ObjectMapper objectMapper) {
        this.redisTemplate = redisTemplate;
        this.objectMapper = objectMapper;
    }

    @Override
    public <T> Optional<T> get(String key, Class<T> type) {
        try {
            Object value = redisTemplate.opsForValue().get(key);
            if (value == null) {
                log.info("CACHE MISS: key '{}' not found in Redis", key);
                return Optional.empty();
            }
            
            if (value instanceof String jsonString) {
                T result = objectMapper.readValue(jsonString, type);
                log.info("CACHE HIT: retrieved '{}' from Redis (type: {})", key, type.getSimpleName());
                return Optional.ofNullable(result);
            }
            
            log.info("CACHE MISS: key '{}' has unexpected type", key);
            return Optional.empty();
        } catch (Exception e) {
            log.warn("CACHE ERROR: failed to get key '{}': {}", key, e.getMessage());
            return Optional.empty();
        }
    }

    @Override
    public void put(String key, Object value) {
        put(key, value, DEFAULT_TTL);
    }

    @Override
    public void put(String key, Object value, Duration ttl) {
        try {
            String jsonValue = objectMapper.writeValueAsString(value);
            redisTemplate.opsForValue().set(key, jsonValue, ttl);
            log.info("CACHE PUT: stored '{}' in Redis (TTL: {}, size: {} bytes)", key, ttl, jsonValue.length());
        } catch (JsonProcessingException e) {
            log.warn("CACHE ERROR: failed to serialize key '{}': {}", key, e.getMessage());
        } catch (Exception e) {
            log.warn("CACHE ERROR: failed to store key '{}': {}", key, e.getMessage());
        }
    }

    @Override
    public void evict(String key) {
        try {
            Boolean deleted = redisTemplate.delete(key);
            if (Boolean.TRUE.equals(deleted)) {
                log.info("CACHE EVICT: removed '{}' from Redis", key);
            } else {
                log.info("CACHE EVICT: key '{}' was not in Redis", key);
            }
        } catch (Exception e) {
            log.warn("CACHE ERROR: failed to evict key '{}': {}", key, e.getMessage());
        }
    }

    @Override
    public void evictByPattern(String pattern) {
        try {
            Set<String> keys = redisTemplate.keys(pattern);
            if (keys != null && !keys.isEmpty()) {
                redisTemplate.delete(keys);
                log.info("CACHE EVICT: removed {} keys matching pattern '{}': {}", keys.size(), pattern, keys);
            } else {
                log.info("CACHE EVICT: no keys found matching pattern '{}'", pattern);
            }
        } catch (Exception e) {
            log.warn("CACHE ERROR: failed to evict by pattern '{}': {}", pattern, e.getMessage());
        }
    }

    @Override
    public boolean exists(String key) {
        try {
            Boolean exists = redisTemplate.hasKey(key);
            return Boolean.TRUE.equals(exists);
        } catch (Exception e) {
            log.warn("Error checking cache key existence {}: {}", key, e.getMessage());
            return false;
        }
    }
}