Spring Boot: Redis CRUD Repository findById or findAll always returns Optional.empty (null)

Well, I also raised a defect to spring-data-redis repository on GitHub for the same but the defect got closed by one of the maintainers of this repository without even posting any proper solution. He just gave a reference to an existing issue that was even closed without posting any solution. Here is the link to that issue.

https://github.com/spring-projects/spring-data-redis/issues/2130

Hence, while doing some research, I came across a solution that I am sharing here which worked in my case.

The solution is not to use the default CRUD repository methods implemented by Spring Boot, instead, write your own repository class having methods with your criteria to store and fetch the data from the Redis cache. That's it, now you should be able to store/fetch the data using the repository methods across your project.

I am posting an example below for reference.

Custom Repository Interface

package com.test.cache.repository;

import java.io.IOException;
import java.util.Map;

import com.test.cache.entity.OTPValidationLogCache;

public interface OTPValidationLogCacheRepository {

    void save(OTPValidationLogCache customer);
    OTPValidationLogCache find(Long id);
    Map<?,?> findAll() throws IOException;
    void update(OTPValidationLogCache customer);
    void delete(Long id);
}

Custom Repository Interface Implementation

package com.test.cache.repository;

import java.io.IOException;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ScanOptions.ScanOptionsBuilder;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.test.cache.entity.OTPValidationLogCache;
import com.test.configuration.AppConfig;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Maps;

@Repository
public class OTPValidationLogCacheRepositoryImpl implements OTPValidationLogCacheRepository {
    
    private String key;
    
    private RedisTemplate redisTemplate;
    private HashOperations hashOperations;
    private ObjectMapper objMapper;
    
    @Autowired
    public OTPValidationLogCacheRepositoryImpl(RedisTemplate redisTemplate, ObjectMapper objmapper) {
        this.redisTemplate = redisTemplate;
        this.objMapper = objmapper;
    }
    
    @PostConstruct
    private void init() {
        hashOperations = redisTemplate.opsForHash();
    }
    
    @Override
    public void save(OTPValidationLogCache otpvalCache) {
        hashOperations.put(key.concat(otpvalCache.getId().toString()), otpvalCache.getId(), otpvalCache);
        setExpiryTime(key.concat(String.valueOf(otpvalCache.getId())), AppConfig.getUserBanDurationInSeconds());
    }

    @Override
    public OTPValidationLogCache find(Long id) {
        return (OTPValidationLogCache) hashOperations.get(key.concat(String.valueOf(id)), id);
    }

    @Override
    public Map findAll() throws IOException {
        Map<Integer, OTPValidationLogCache> values = Maps.newHashMap();
        Cursor c =  hashOperations.scan(OTPValidationLogCache.class, new ScanOptionsBuilder().match(key.concat("*")).build());
        AtomicInteger count = new AtomicInteger(1);
        c.forEachRemaining(element ->
                {
                    values.put(count.getAndIncrement(), objMapper.convertValue(element, OTPValidationLogCache.class));
                }
                );
        c.close();
        return values;
    }

    @Override
    public void update(OTPValidationLogCache customer) {
        hashOperations.put(key, customer.getId(), customer);
    }

    @Override
    public void delete(Long id) {
        hashOperations.delete(key, id);
    }
    
    private void setExpiryTime(String key, Long timeout)
    {
        redisTemplate.expire(key, Duration.ofSeconds(timeout));
    }

    public synchronized void setKey(String key)
    {
        this.key = key;
    }
}

Hope this helps others who may encounter this issue in the future.

Also, there is one more alternative available for this issue, that is switching to a different library provider such as Redisson, however, I have not tried it yet, so if you want, you may try and check.