Стратегии кеширования

public Product getProduct(Long id) {
    String cacheKey = "product:" + id;
    Product product = cacheService.get(cacheKey);
    
    if (product == null) {
        // Cache miss
        product = productRepository.findById(id);
        if (product != null) {
            cacheService.put(cacheKey, product, CACHE_TTL);
        }
    }
    
    return product;
}

public void saveProduct(Product product) {
    // Сохраняем в БД
    productRepository.save(product);
    
    // И одновременно обновляем кеш
    String cacheKey = "product:" + product.getId();
    cacheService.put(cacheKey, product, CACHE_TTL);
}

public void saveProduct(Product product) {
    // Сначала в кеш
    String cacheKey = "product:" + product.getId();
    cacheService.put(cacheKey, product, CACHE_TTL);
    
    // Асинхронно в БД
    asyncTaskExecutor.submit(() -> {
        productRepository.save(product);
    });
}

public void saveProduct(Product product) {
    // Только в БД
    productRepository.save(product);
    
    // Опционально можно инвалидировать кеш
    String cacheKey = "product:" + product.getId();
    cacheService.remove(cacheKey);
}

@Cacheable(value = "products", key = "#id")
public Product getProduct(Long id) {
    // Spring Cache автоматически применяет Read-Through
    // Если в кеше нет - метод выполнится и результат закешируется
    return productRepository.findById(id);
}

// Пример конфигурации Redis с политикой Refresh-Ahead
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(60))
        .prefixCacheNameWith("myapp:")
        .serializeKeysWith(...)
        .serializeValuesWith(...);
        
    // Настраиваем refresh-ahead (в реальном проекте нужна дополнительная логика)
    return RedisCacheManager.builder(redisConnectionFactory)
        .cacheDefaults(config)
        .build();
}
 
// Сервис, который будет вызываться по расписанию для обновления кеша
@Scheduled(fixedRate = 60000) // Каждую минуту
public void refreshCacheEntries() {
    // Находим записи, у которых TTL < 80% от максимального
    // И асинхронно их обновляем
}

@Component
public class CacheWarmer {
 
    @Autowired
    private ProductService productService;
    
    @EventListener(ApplicationReadyEvent.class)
    public void warmUpCaches() {
        log.info("Начинаю прогрев кеша...");
        
        // Загружаем самые популярные товары
        List<Long> topProductIds = productService.getTopProductIds(500);
        
        // Можно распараллелить для ускорения
        topProductIds.parallelStream().forEach(id -> {
            try {
                productService.getProduct(id); // Этот вызов заполнит кеш
            } catch (Exception e) {
                log.warn("Не удалось прогреть кеш для товара {}: {}", id, e.getMessage());
            }
        });
        
        log.info("Прогрев кеша завершен");
    }
}

@Configuration
public class CacheConfig {
 
    @Bean(name = "productCacheManager")
    public CacheManager productCacheManager() {
        // Настройка кеша для товаров
        // Возможно, с большим TTL и меньшей частотой обновлений
    }
    
    @Bean(name = "sessionCacheManager")
    public CacheManager sessionCacheManager() {
        // Настройка кеша для сессий
        // С меньшим TTL и другими параметрами
    }
}

public class ShardedCacheService {
    
    private List<CacheClient> shards;
    
    public void put(String key, Object value) {
        int shardIndex = getShardIndex(key);
        shards.get(shardIndex).put(key, value);
    }
    
    public Object get(String key) {
        int shardIndex = getShardIndex(key);
        return shards.get(shardIndex).get(key);
    }
    
    private int getShardIndex(String key) {
        // Простая хеш-функция для распределения ключей
        return Math.abs(key.hashCode() % shards.size());
    }
}

Cache<String, Object> cache = CacheBuilder.newBuilder()
    .maximumSize(10000)  // Максимальный размер кеша
    .expireAfterWrite(10, TimeUnit.MINUTES)  // TTL
    .removalListener(notification -> {
        log.debug("Запись {} удалена из кеша по причине: {}", 
                 notification.getKey(), notification.getCause());
    })
    .build();

Cache<String, Object> cache = CacheBuilder.newBuilder()
    .maximumSize(10000)
    .weigher((key, value) -> {
        // Здесь можно реализовать свою логику оценки "веса" элемента
        // Например, основываясь на частоте доступа
        return 1; // Для простоты каждый элемент имеет вес 1
    })
    .removalListener(...)
    .build();

public class WeightedCache<K, V> {
    private final int maxWeight;
    private int currentWeight = 0;
    private final Map<K, CacheEntry<V>> cache = new HashMap<>();
    
    // Функция получения веса для каждого элемента
    private final Function<V, Integer> weightFunction;
    
    // Конструктор и другие методы...
    
    public void put(K key, V value) {
        int weight = weightFunction.apply(value);
        
        // Если нужно освободить место
        while (currentWeight + weight > maxWeight && !cache.isEmpty()) {
            // Найти и удалить элемент с наименьшим приоритетом
            // (реализация зависит от выбранной стратегии)
        }
        
        cache.put(key, new CacheEntry<>(value, weight, System.currentTimeMillis()));
        currentWeight += weight;
    }
}

public class AdaptiveCacheManager {
    private Cache lruCache;
    private Cache lfuCache;
    private Cache currentActiveCache;
    
    private double lruHitRate = 0;
    private double lfuHitRate = 0;
    
    public Object get(String key) {
        // Логика выбора и переключения кеша
        updateHitRates();
        
        if (lruHitRate > lfuHitRate * 1.1) {
            currentActiveCache = lruCache;
        } else if (lfuHitRate > lruHitRate * 1.1) {
            currentActiveCache = lfuCache;
        }
        
        return currentActiveCache.get(key);
    }
    
    // Другие методы...
}

public class MultiLevelCache {
    private final Cache localCache;  // Caffeine, Guava, etc.
    private final DistributedCache distributedCache;  // Redis, Memcached
 
    public Optional<Product> get(String key) {
        // Сначала проверяем локальный кеш
        Optional<Product> result = localCache.get(key);
        
        if (result.isPresent()) {
            return result; // L1 Cache Hit
        }
        
        // Затем проверяем распределенный кеш
        result = distributedCache.get(key);
        
        if (result.isPresent()) {
            // Сохраняем в локальный кеш для следующих запросов
            localCache.put(key, result.get());
            return result; // L2 Cache Hit
        }
        
        return Optional.empty(); // Cache Miss
    }
 
    // Методы put, invalidate и т.д.
}

@Slf4j
@Component
public class CacheInvalidationListener {
    @Autowired
    private LocalCacheManager localCacheManager;
    
    @KafkaListener(topics = "cache-invalidation-events")
    public void handleInvalidationEvent(InvalidationEvent event) {
        log.debug("Получено событие инвалидации кеша: {}", event);
        localCacheManager.invalidate(event.getCacheKey());
    }
}

@Entity
public class Product {
    @Id
    private Long id;
    
    private String name;
    private BigDecimal price;
    
    @Version
    private Long version;
    
    // геттеры, сеттеры...
}

public void updateProduct(Long productId, ProductUpdateDTO updateData) {
    RLock lock = redissonClient.getLock("product:lock:" + productId);
    
    try {
        // Пытаемся получить блокировку в течение 10 секунд
        if (lock.tryLock(10, TimeUnit.SECONDS)) {
            try {
                // Критическая секция - только один поток может изменять продукт
                Product product = productRepository.findById(productId);
                // Обновляем продукт...
                productRepository.save(product);
                
                // Обновляем кеш
                cacheService.put("product:" + productId, product);
            } finally {
                lock.unlock(); // Важно всегда освобождать блокировку
            }
        } else {
            throw new ConcurrentModificationException("Не удалось получить блокировку");
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("Операция прервана", e);
    }
}

// Атомарное увеличение счетчика просмотров
redisTemplate.opsForValue().increment("product:views:" + productId);

@Transactional
public void updateProduct(Product product) {
    // Сохраняем в БД
    productRepository.save(product);
    
    // Публикуем событие об изменении
    eventPublisher.publishEvent(new ProductUpdatedEvent(product.getId()));
}
 
// В другом компоненте или сервисе
@EventListener
public void handleProductUpdated(ProductUpdatedEvent event) {
    cacheService.invalidate("product:" + event.getProductId());
    
    // Можно также инвалидировать связанные кеши
    cacheService.invalidate("category:products:" + event.getCategoryId());
}

@Transactional
public void updateProduct(Product product) {
    // Сначала инвалидируем кеш
    cacheService.invalidate("product:" + product.getId());
    
    // Затем обновляем в БД
    productRepository.save(product);
}

public Optional<Product> getWithLeakyCache(Long id) {
    String cacheKey = "product:" + id;
    Optional<Product> cachedValue = cacheService.get(cacheKey);
    
    if (cachedValue.isPresent()) {
        return cachedValue;
    } else {
        // Если данных в кеше нет, то устанавливаем случайную задержку
        // чтобы не все запросы одновременно ударили по БД
        int backoffMs = ThreadLocalRandom.current().nextInt(50, 200);
        try {
            Thread.sleep(backoffMs);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        // Еще раз проверяем кеш после задержки
        // Возможно, другой поток уже загрузил данные
        cachedValue = cacheService.get(cacheKey);
        if (cachedValue.isPresent()) {
            return cachedValue;
        }
    }
    
    // Если после повторной проверки данных все еще нет, загружаем из БД
    Product product = productRepository.findById(id).orElse(null);
    if (product != null) {
        cacheService.put(cacheKey, product, CACHE_TTL);
    }
    
    return Optional.ofNullable(product);
}

@GetMapping("/products/{id}")
public ResponseEntity<Product> getProduct(@PathVariable Long id) {
    Product product = productService.findById(id);
    
    // Настраиваем кеширование в браузере на 10 минут
    CacheControl cacheControl = CacheControl.maxAge(10, TimeUnit.MINUTES)
                                           .mustRevalidate();
    
    return ResponseEntity.ok()
                        .cacheControl(cacheControl)
                        .body(product);
}

return ResponseEntity.ok()
                    .cacheControl(CacheControl.noCache().noTransform())
                    .header("Pragma", "no-cache")
                    .header("Expires", "0")
                    .body(financialData);

String uniqueToken = UUID.randomUUID().toString();
String url = "/api/data?token=" + uniqueToken;

@Configuration
@EnableCaching
public class RedisConfig {
 
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        LettuceConnectionFactory factory = new LettuceConnectionFactory();
        factory.setHostName("redis-server");
        factory.setPort(6379);
        // Для продакшена добавить пароль и SSL
        return factory;
    }
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        
        // Настройка сериализаторов
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        serializer.setObjectMapper(mapper);
        
        template.setValueSerializer(serializer);
        template.setKeySerializer(new StringRedisSerializer());
        
        return template;
    }
 
    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))
            .prefixCacheNameWith("myapp:")
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        
        return RedisCacheManager.builder(redisConnectionFactory())
            .cacheDefaults(config)
            .withCacheConfiguration("products", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(2)))
            .withCacheConfiguration("users", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(15)))
            .build();
    }
}

@Service
public class ProductService {
 
    @Autowired
    private ProductRepository repository;
    
    @Cacheable(value = "products", key = "#id", unless = "#result == null")
    public Product getProduct(Long id) {
        return repository.findById(id).orElse(null);
    }
    
    @CacheEvict(value = "products", key = "#product.id")
    @Transactional
    public void updateProduct(Product product) {
        repository.save(product);
    }
    
    @Caching(evict = {
        @CacheEvict(value = "products", key = "#id"),
        @CacheEvict(value = "productList", allEntries = true)
    })
    @Transactional
    public void deleteProduct(Long id) {
        repository.deleteById(id);
    }
}

@Service
public class AsyncCacheService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private TaskExecutor asyncExecutor;
    
    @Autowired
    private ProductRepository repository;
    
    // Write-Behind паттерн
    public void saveProduct(Product product) {
        // Сначала сохраняем в кеш
        String cacheKey = "product:" + product.getId();
        redisTemplate.opsForValue().set(cacheKey, product, Duration.ofHours(1));
        
        // Затем асинхронно в БД
        asyncExecutor.execute(() -> {
            try {
                repository.save(product);
                log.debug("Продукт {} сохранен в БД", product.getId());
            } catch (Exception e) {
                log.error("Ошибка при сохранении продукта {} в БД: {}", 
                          product.getId(), e.getMessage(), e);
                // Механизм повторных попыток
                retryQueue.add(product);
            }
        });
    }
}

@Configuration
@EnableCaching
public class CaffeineConfig {
 
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(30, TimeUnit.MINUTES)
            .maximumSize(10_000)
            .recordStats());
        return cacheManager;
    }
    
    @Bean
    public Ticker ticker() {
        return Ticker.systemTicker();
    }
}

@Service
public class ConfigService {
 
    private final Map<String, Object> localCache = new ConcurrentHashMap<>();
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ConfigRepository repository;
    
    @Scheduled(fixedRate = 300000) // Каждые 5 минут
    public void refreshLocalCache() {
        log.info("Обновление локального кеша настроек");
        Map<String, Object> freshSettings = repository.getAllSettings();
        localCache.clear();
        localCache.putAll(freshSettings);
    }
    
    public Object getSetting(String key) {
        // Сначала проверяем локальный кеш
        Object value = localCache.get(key);
        if (value != null) {
            return value;
        }
        
        // Затем проверяем Redis
        value = redisTemplate.opsForValue().get("config:" + key);
        if (value != null) {
            localCache.put(key, value);
            return value;
        }
        
        // Наконец, обращаемся к БД
        value = repository.findByKey(key);
        if (value != null) {
            redisTemplate.opsForValue().set("config:" + key, value, Duration.ofHours(1));
            localCache.put(key, value);
        }
        
        return value;
    }
}

@Configuration
@EnableCaching
public class HazelcastConfig {
 
    @Bean
    public Config hazelcastConfig() {
        Config config = new Config();
        config.setInstanceName("hazelcast-instance")
              .setProperty("hazelcast.logging.type", "slf4j");
        
        // Настройка сетевого взаимодействия
        NetworkConfig networkConfig = config.getNetworkConfig();
        networkConfig.getJoin().getMulticastConfig().setEnabled(false);
        networkConfig.getJoin().getTcpIpConfig()
                    .setEnabled(true)
                    .addMember("192.168.1.101")
                    .addMember("192.168.1.102");
        
        // Настройка карт (аналог таблиц в Redis)
        MapConfig productsCache = new MapConfig()
            .setName("products")
            .setTimeToLiveSeconds(7200)
            .setMaxIdleSeconds(3600)
            .setEvictionPolicy(EvictionPolicy.LRU);
        
        config.addMapConfig(productsCache);
        
        return config;
    }
    
    @Bean
    public HazelcastInstance hazelcastInstance() {
        return Hazelcast.newHazelcastInstance(hazelcastConfig());
    }
    
    @Bean
    public CacheManager cacheManager() {
        return new HazelcastCacheManager(hazelcastInstance());
    }
}

@Service
public class CacheMetricsCollector {
 
@Autowired
private CacheManager cacheManager;
 
@Scheduled(fixedRate = 60000) // Раз в минуту
public void collectMetrics() {
    Map<String, CacheStats> statsMap = new HashMap<>();
    
    // Для Caffeine или Guava
    if (cacheManager instanceof CaffeineCacheManager) {
        for (String cacheName : cacheManager.getCacheNames()) {
            Cache cache = cacheManager.getCache(cacheName);
            if (cache != null && cache.getNativeCache() instanceof com.github.benmanes.caffeine.cache.Cache) {
                com.github.benmanes.caffeine.cache.Cache<?, ?> nativeCache = 
                    (com.github.benmanes.caffeine.cache.Cache<?, ?>) cache.getNativeCache();
                statsMap.put(cacheName, nativeCache.stats());
            }
        }
    }
    
    // Отправка метрик в систему мониторинга
    for (Map.Entry<String, CacheStats> entry : statsMap.entrySet()) {
        CacheStats stats = entry.getValue();
        metricsRegistry.gauge("cache.hitRate." + entry.getKey(), stats.hitRate());
        metricsRegistry.gauge("cache.missRate." + entry.getKey(), stats.missRate());
        metricsRegistry.gauge("cache.loadTime." + entry.getKey(), stats.averageLoadPenalty());
        metricsRegistry.gauge("cache.evictions." + entry.getKey(), stats.evictionCount());
    }
}
}

// Ошибочный код - не учитываем зависимости
@Cacheable("products")
public List<Product> getProductsByCategory(Long categoryId) {
    return productRepository.findByCategoryId(categoryId);
}
 
@CacheEvict(value = "products", key = "#product.id")
public void saveProduct(Product product) {
    productRepository.save(product);
    // Забыли инвалидировать список товаров в категории!
}

@Cacheable(value = "categoryProducts", key = "#categoryId")
public List<Product> getProductsByCategory(Long categoryId) {
    return productRepository.findByCategoryId(categoryId);
}
 
@Caching(evict = {
    @CacheEvict(value = "products", key = "#product.id"),
    @CacheEvict(value = "categoryProducts", key = "#product.categoryId")
})
public void saveProduct(Product product) {
    productRepository.save(product);
}

shared_buffers = 8GB