Spring Data Redis Tutorial

Spring Data Redis provides easy configuration and access to Redis from Spring applications. Redis is an in-memory data store often used as a database, cache, and message broker. In this tutorial, we will cover how to set up and use Spring Data Redis in a Spring Boot application.

Prerequisites

JDK 17 or later
Maven or Gradle
Docker (optional, for running Redis locally)
Spring Boot (version 3.2+ recommended)
IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

Use Spring Initializr to create a new project with the following configuration:

Project: Maven Project
Language: Java
Spring Boot: 3.2.x
Dependencies: Spring Web, Spring Data Redis

Download and unzip the project, then open it in your IDE.

Example Spring Boot Application

We will create a simple Spring Boot application that interacts with Redis to store and retrieve data.

1.1 Application Class

package com.example.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RedisApplication {

    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class, args);
    }
}

Step 2: Running Redis Locally

If you have Docker installed, you can run Redis using the following command:

docker run --name redis -d -p 6379:6379 redis

Alternatively, you can install Redis on your local machine by following the installation instructions for your operating system from the Redis website.

Step 3: Configure Redis in Spring Boot

3.1 Add Redis Configuration

Add the following configuration to your src/main/resources/application.properties file:

# src/main/resources/application.properties

spring.redis.host=localhost
spring.redis.port=6379

3.2 Create a Redis Configuration Class

Create a configuration class named RedisConfig in the com.example.redis.config package.

package com.example.redis.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

Explanation:

RedisTemplate<String, Object>: Provides high-level abstractions for Redis interactions.
StringRedisSerializer: Serializes keys as strings.
GenericJackson2JsonRedisSerializer: Serializes values as JSON using Jackson.

Step 4: Create a Redis Repository

Create a repository interface named UserRepository in the com.example.redis.repository package. This interface will define methods for interacting with Redis.

package com.example.redis.repository;

import com.example.redis.model.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends CrudRepository<User, String> {
}

Step 5: Create a User Model

Create a model class named User in the com.example.redis.model package.

package com.example.redis.model;

import java.io.Serializable;

public class User implements Serializable {

    private String id;
    private String name;
    private int age;

    public User() {
    }

    public User(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    // Getters and setters

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Step 6: Create a Service Class

Create a service class named UserService in the com.example.redis.service package.

package com.example.redis.service;

import com.example.redis.model.User;
import com.example.redis.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public Optional<User> getUserById(String id) {
        return userRepository.findById(id);
    }

    public Iterable<User> getAllUsers() {
        return userRepository.findAll();
    }

    public void deleteUserById(String id) {
        userRepository.deleteById(id);
    }
}

Step 7: Create a REST Controller

Create a controller class named UserController in the com.example.redis.controller package.

package com.example.redis.controller;

import com.example.redis.model.User;
import com.example.redis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Optional;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    public User saveUser(@RequestBody User user) {
        return userService.saveUser(user);
    }

    @GetMapping("/{id}")
    public Optional<User> getUserById(@PathVariable String id) {
        return userService.getUserById(id);
    }

    @GetMapping
    public Iterable<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @DeleteMapping("/{id}")
    public void deleteUserById(@PathVariable String id) {
        userService.deleteUserById(id);
    }
}

Step 8: Test the Application

8.1 Run the Application

Run the Spring Boot application using your IDE or the command line:

./mvnw spring-boot:run

8.2 Verify Redis Operations

Use a tool like Postman or curl to test the endpoints.

Create a User:
- URL: http://localhost:8080/users
- Method: POST
- Body:
```
{
  "id": "1",
  "name": "Ramesh Fadatare",
  "age": 30
}
```
Get a User by ID:
- URL: http://localhost:8080/users/1
- Method: GET
Get All Users:
- URL: http://localhost:8080/users
- Method: GET
Delete a User by ID:
- URL: http://localhost:8080/users/1
- Method: DELETE

You should see the correct responses and verify that the data is stored and retrieved from Redis.

Conclusion

In this tutorial, you have learned how to set up and use Spring Data Redis in a Spring Boot application. We covered:

Setting up a Spring Boot project with Redis dependencies.
Running Redis locally using Docker.
Configuring Redis in Spring Boot.
Creating a Redis repository and a model.
Creating a service and a REST controller to interact with Redis.
Testing the application to verify Redis operations.

By following these steps, you can leverage Redis to improve the performance and scalability of your Spring Boot applications.

Java Guides

Search This Blog