Битва Java-кешей: Сравниваем Ehcache, Caffeine и Hazelcast

CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
    .withCache("multiLayeredCache", 
        CacheConfigurationBuilder.newCacheConfigurationBuilder(
            String.class, User.class,
            ResourcePoolsBuilder.newResourcePoolsBuilder()
                .heap(1000, EntryUnit.ENTRIES)
                .offheap(10, MemoryUnit.MB)
                .disk(100, MemoryUnit.MB, true)
        )
    )
    .build();
cacheManager.init();

@Configuration
@EnableCaching
public class CacheConfig {
 
    @Bean
    public CacheManager cacheManager() {
        CachingProvider provider = Caching.getCachingProvider();
        CacheManager cacheManager = provider.getCacheManager();
        
        MutableConfiguration<String, User> configuration = 
            new MutableConfiguration<String, User>()
                .setTypes(String.class, User.class)
                .setStoreByValue(false)
                .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_DAY));
        
        cacheManager.createCache("users", configuration);
        return cacheManager;
    }
}
 
@Service
public class UserService {
    
    @Autowired
    private UserRepository repository;
    
    @Cacheable(value = "users", key = "#id")
    public User getUserById(String id) {
        System.out.println("Fetching user from database: " + id);
        return repository.findById(id).orElse(null);
    }
    
    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        return repository.save(user);
    }
    
    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(String id) {
        repository.deleteById(id);
    }
}

// Пример конфигурации с разными TTL для разных типов данных
CacheConfiguration<String, TariffPlan> tariffConfig = CacheConfigurationBuilder
    .newCacheConfigurationBuilder(String.class, TariffPlan.class, 
        ResourcePoolsBuilder.heap(500).offheap(50, MemoryUnit.MB))
    .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofHours(12)))
    .build();
 
CacheConfiguration<String, LoyaltyProgram> loyaltyConfig = CacheConfigurationBuilder
    .newCacheConfigurationBuilder(String.class, LoyaltyProgram.class, 
        ResourcePoolsBuilder.heap(200))
    .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofMinutes(30)))
    .build();
 
cacheManager.createCache("tariffPlans", tariffConfig);
cacheManager.createCache("loyaltyPrograms", loyaltyConfig);

CacheEventListenerConfigurationBuilder cacheEventListenerConfiguration = 
    CacheEventListenerConfigurationBuilder
        .newEventListenerConfiguration(new CacheEventLogger(), 
            EventType.CREATED, EventType.EXPIRED)
        .unordered().asynchronous();
 
CacheConfiguration<Long, User> userCacheConfiguration = 
    CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, User.class,
        ResourcePoolsBuilder.heap(10000))
    .add(cacheEventListenerConfiguration)
    .build();

// Пример конфигурации Caffeine с Window TinyLFU (используется по умолчанию)
Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .build();

@Configuration
@EnableCaching
public class CaffeineCacheConfig {
 
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("users", "accounts");
        cacheManager.setCaffeine(caffeineCacheBuilder());
        return cacheManager;
    }
    
    Caffeine<Object, Object> caffeineCacheBuilder() {
        return Caffeine.newBuilder()
            .initialCapacity(100)
            .maximumSize(500)
            .expireAfterAccess(5, TimeUnit.MINUTES)
            .recordStats();
    }
}

@Service
public class UserService {
 
    @Cacheable(value = "users", key = "#id")
    public User getUser(Long id) {
        // Загрузка из базы данных
        return userRepository.findById(id).orElse(null);
    }
    
    @CachePut(value = "users", key = "#user.id")
    public User saveUser(User user) {
        return userRepository.save(user);
    }
    
    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

LoadingCache<String, CompletableFuture<Product>> asyncCache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .buildAsync(key -> CompletableFuture.supplyAsync(() -> 
        productRepository.findById(key).orElse(null)));

@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    // L1: Caffeine локальный кеш
    Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(1, TimeUnit.MINUTES);
    
    // L2: Redis распределенный кеш
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(10));
    
    // Композитный менеджер кешей
    Map<String, CacheConfiguration> cacheConfigs = new HashMap<>();
    cacheConfigs.put("users", CacheConfiguration.defaultCacheConfig()
        .withCaffeine(caffeine)
        .withRedis(redisCacheConfiguration));
    
    return new CompositeCacheManager(cacheConfigs);
}

Cache<String, User> cache = Caffeine.newBuilder()
    .weakKeys()
    .softValues()
    .maximumSize(100_000)
    .build();

Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats()
    .build();
 
// Получение статистики
CacheStats stats = cache.stats();
System.out.println("Hit rate: " + stats.hitRate());
System.out.println("Average load penalty: " + stats.averageLoadPenalty() + " ns");

Cache<String, Document> cache = Caffeine.newBuilder()
    .maximumWeight(10_000_000)
    .weigher((key, document) -> document.sizeInBytes())
    .build();

// Функция, определяющая, на каком узле будет храниться ключ
int partitionId = (key.hashCode() & 0x7fffffff) % PARTITION_COUNT;

// Создание экземпляра Hazelcast с конфигурацией по умолчанию
HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance();
 
// Получение распределенной Map
IMap<String, Customer> customers = hazelcastInstance.getMap("customers");
 
// Операции записи/чтения работают как с обычной Map
customers.put("c1", new Customer("Tom", "Smith"));
Customer customer = customers.get("c1");

Config config = new Config();
NetworkConfig network = config.getNetworkConfig();
 
// Настройка TCP/IP обнаружения узлов
JoinConfig join = network.getJoin();
join.getMulticastConfig().setEnabled(false);
join.getTcpIpConfig()
    .setEnabled(true)
    .addMember("10.10.1.10")
    .addMember("10.10.1.11");
 
// Запуск узла с указанной конфигурацией
HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance(config);

Config config = new Config();
config.getMapConfig("customers")
    .setBackupCount(2)       // Синхронные бэкапы
    .setAsyncBackupCount(1); // Асинхронные бэкапы

IMap<String, Employee> employees = hazelcastInstance.getMap("employees");
 
// Вычисление средней зарплаты, операция выполняется на серверах 
// там, где физически находятся данные
double averageSalary = employees.aggregate(Aggregators.doubleAvg("salary"));

public class HybridCacheService<K, V> {
    private final Cache<K, V> localCache;
    private final IMap<K, V> distributedCache;
    
    // Сначала проверяем локальный кеш, затем распределенный
    public V get(K key) {
        V value = localCache.getIfPresent(key);
        if (value == null) {
            value = distributedCache.get(key);
            if (value != null) {
                localCache.put(key, value);
            }
        }
        return value;
    }
    
    // Обновляем оба кеша
    public void put(K key, V value) {
        localCache.put(key, value);
        distributedCache.set(key, value);
    }
    
    // Инвалидируем оба кеша
    public void invalidate(K key) {
        localCache.invalidate(key);
        distributedCache.delete(key);
    }
}

Config config = new Config();
config.getSplitBrainProtectionConfig("default")
    .setEnabled(true)
    .setMinimumClusterSize(3); // Кворум - минимальное число узлов

Config config = new Config();
config.getPersistenceConfig()
    .setEnabled(true)
    .setBaseDir(new File("/opt/hazelcast/persistence"));