Using Jedis for Direct Redis Interaction

Jedis is a lightweight Redis client for Java. To begin:

1. Add Maven dependencies:

<dependencies>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>5.0.0</version>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.10.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

2. Establish a connection:

@BeforeEach
void setup() {
    jedis = new Jedis("114.55.236.21", 6379);
    jedis.auth("123456");
    jedis.select(0);
}

3. Perform basic operations:

@Test
void testStringValue() {
    jedis.set("username", "alice");
    String value = jedis.get("username");
    System.out.println(value);
}

4. Close the connection:

@AfterEach
void cleanup() {
    if (jedis != null) {
        jedis.close();
    }
}

Managing Connections with JedisPool

Since Jedis instances are not thread-safe, using a connection pool improves performance and resource management.

1. Create a connection factory:

public class RedisConnectionManager {
    private static final JedisPool pool;

    static {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(8);
        config.setMaxIdle(8);
        config.setMinIdle(0);
        config.setMaxWaitMillis(200);

        pool = new JedisPool(config, "114.55.236.21", 6379, 1000, "123456");
    }

    public static Jedis getRedisClient() {
        return pool.getResource();
    }
}

2. Use the pooled connection:

public class HashOperationsTest {
    private Jedis client;

    @BeforeEach
    void setup() {
        client = RedisConnectionManager.getRedisClient();
    }

    @Test
    void testHashOperations() {
        client.hset("profile:101", "name", "bob");
        client.hset("profile:101", "age", "30");
        Map<String, String> data = client.hgetAll("profile:101");
        System.out.println(data);
    }

    @AfterEach
    void cleanup() {
        if (client != null) client.close();
    }
}

Integrating Redis with Spring Boot via Spring Data Redis

Spring Boot simplifies Redis integration using spring-boot-starter-data-redis, which defaults to Lettuce but supports Jedis as well.

1. Add required dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
</dependency>

2. Configure Redis in application.yml:

spring:
  data:
    redis:
      host: 114.55.236.21
      port: 6379
      password: 123456
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0
          max-wait: 200ms

3. Use RedisTemplate:

@SpringBootTest
class RedisTemplateTest {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void testBasicString() {
        redisTemplate.opsForValue().set("counter", 42);
        Object val = redisTemplate.opsForValue().get("counter");
        System.out.println(val);
    }
}

By default, RedisTemplate uses JDK serialization, which produces unreadable keys and values. To improve this, configure custom serializers.

Custom Seiralization with JSON

1. Define a Redis configuraton:

@Configuration
public class RedisSerializationConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        var stringSerializer = RedisSerializer.string();
        var jsonSerializer = new GenericJackson2JsonRedisSerializer();

        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        return template;
    }
}

2. Store and retrieve objects:

@Test
void storeUserObject() {
    User user = new User(101, "charlie", 28);
    redisTemplate.opsForValue().set("user:101", user);

    User retrieved = (User) redisTemplate.opsForValue().get("user:101");
    System.out.println(retrieved);
}

This approach embeds class metadata (@class) in every serialized object, wich can bloat storage at scale.

Manual Serialization for Efficiency

To avoid metadata overhead, manually serialize objects using a library like FastJSON.

1. Add FastJSON dependency:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.35</version>
</dependency>

2. Manually handle serialization:

@Test
void manualJsonHandling() {
    User user = new User(102, "diana", 32);
    String json = JSONObject.toJSONString(user);
    redisTemplate.opsForValue().set("user:102", json);

    String rawJson = (String) redisTemplate.opsForValue().get("user:102");
    User restored = JSONObject.parseObject(rawJson, User.class);
    System.out.println(restored);
}