Redis Lettuce Integration with Java Spring Boot

• Extremely fast read/write operations

• Data persistence and replication

• Support for multiple data structures (lists, sets, hashes, bitmaps)

• Clustered setup for high availability and scaling

• Lettuce.io
• Jedis

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfig {
}

@Value("${redis.host}")
private String redisHost;

@Value("${redis.port}")
private int redisPort;

@Bean(destroyMethod = "shutdown")
ClientResources clientResources() {
    return DefaultClientResources.create();
}

@Bean
public RedisStandaloneConfiguration redisStandaloneConfiguration() {
    return new RedisStandaloneConfiguration(redisHost, redisPort);
}

@Bean
public ClientOptions clientOptions() {
    return ClientOptions.builder()
        .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
        .autoReconnect(true)
        .build();
}

• It enables concurrent Redis communication from multiple threads.

• It avoids creating connections on the fly, improving performance.

• Configuration is defined once and reused.

• It simplifies the setup of Redis clusters.

@Bean
LettucePoolingClientConfiguration lettucePoolConfig(ClientOptions options, ClientResources dcr) {
    return LettucePoolingClientConfiguration.builder()
        .poolConfig(new GenericObjectPoolConfig())
        .clientOptions(options)
        .clientResources(dcr)
        .build();
}

@Bean
public RedisConnectionFactory connectionFactory(
        RedisStandaloneConfiguration redisStandaloneConfiguration,
        LettucePoolingClientConfiguration lettucePoolConfig) {
    return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolConfig);
}

@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
@Primary
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<Object, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

@Value("${app.environment}")
private String ENV;

@Value("${taskScheduler.poolSize}")
private int tasksPoolSize;

@Value("${taskScheduler.defaultLockMaxDurationMinutes}")
private int lockMaxDuration;

@Bean
public LockProvider lockProvider(RedisConnectionFactory connectionFactory) {
    return new RedisLockProvider(connectionFactory, ENV);
}

@Bean
public ScheduledLockConfiguration taskSchedulerLocker(LockProvider lockProvider) {
    return ScheduledLockConfigurationBuilder
        .withLockProvider(lockProvider)
        .withPoolSize(tasksPoolSize)
        .withDefaultLockAtMostFor(Duration.ofMinutes(lockMaxDuration))
        .build();
}

// add
template.opsForHash().put(collection, hkey, OBJECT_MAPPER.writeValueAsString(object));

// delete
template.opsForHash().delete(collection, hkey);

// get
OBJECT_MAPPER.readValue(
    String.valueOf(template.opsForHash().get(collection, hkey)), 
    class
);

template.getConnectionFactory().getConnection().ping() != null

@Repository
@Slf4j
public class CacheRepository<T> implements DataCacheRepository<T> {

    @Autowired
    RedisTemplate template; // and we're in business
    
    private static final ObjectMapper OBJECT_MAPPER;
    private static final TimeZone DEFAULT_TIMEZONE = TimeZone.getTimeZone("UTC");

    static {
        OBJECT_MAPPER = new ObjectMapper();
        OBJECT_MAPPER.setTimeZone(DEFAULT_TIMEZONE);
    }
    
    // implement methods
    
   @Override
   public boolean add(String collection, String hkey, T object) {

       try {
           String jsonObject = OBJECT_MAPPER.writeValueAsString(object);
           template.opsForHash().put(collection, hkey, jsonObject);
           return true;
       } catch (Exception e) {
           log.error("Unable to add object of key {} to cache collection '{}': {}",
                   hkey, collection, e.getMessage());
           return false;
       }
   }
   
   @Override
   public boolean delete(String collection, String hkey) {
       try {
           template.opsForHash().delete(collection, hkey);
           return true;
       } catch (Exception e) {
           log.error("Unable to delete entry {} from cache collection '{}': {}", hkey, collection, e.getMessage());
           return false;
       }
   }

   @Override
   public T find(String collection, String hkey, Class<T> tClass) {
       try {
           String jsonObj = String.valueOf(template.opsForHash().get(collection, hkey));
           return OBJECT_MAPPER.readValue(jsonObj, tClass);
       } catch (Exception e) {
           if(e.getMessage() == null){
               log.error("Entry '{}' does not exist in cache", hkey);
           } else {
               log.error("Unable to find entry '{}' in cache collection '{}': {}", hkey, collection, e.getMessage());
           }
           return null;
       }
   }
   
   @Override
   public Boolean isAvailable() {
       try{
           String status = template.getConnectionFactory().getConnection().ping();

           if (status != null) {
               return true;
           }

       } catch (Exception e) {
           log.warn("Redis server is not available at the moment.");
       }

       return false;
   }
   
   @Override
   public Boolean isAvailable() {
       try{
           return template.getConnectionFactory().getConnection().ping() != null;
       } catch (Exception e) {
           log.warn("Redis server is not available at the moment.");
       }
       return false;
   }
    
}

// you can also have this be false if you want to cover that case
when(potatoesRepository.isAvailable()).thenReturn(true); 

// add method returns true if successful
when(potatoesRepository.addPotato(anyString(), any(Potato.class))).thenReturn(true);

// calls super class find method and returns null
when(potatoesRepository.findPotato(anyString())).thenReturn(null); 

// test fail case
// ...

when(potatoesRepository.findPotato(anyString())).thenReturn(potato);

// test success case
//...

• Defining a TTL (time-to-live) for saved data

• Triggering a delete call when data changes on the provider side

• Scheduling a method to clean certain collections periodically

• Using LRU (Least Recently Used) eviction policies (Redis LRU Docs) https://redis.io/topics/lru-cache](https://redis.io/topics/lru-cache)