Spring Data Redis: A Step-by-Step Tutorial

Redis is a powerful in-memory data structure store, often used as a database, cache, and message broker. Spring Data Redis provides easy configuration and access to Redis from Spring applications. This tutorial will guide you through setting up Spring Data Redis in a Spring Boot 3.2 application.

Prerequisites

• JDK 17 or later
• Redis Server
• Maven or Gradle
• IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

1.1 Create a New Spring Boot Project

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

• Spring Web
• Spring Data Redis
• Spring Boot Actuator (optional, for monitoring)

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

1.2 Configure application.properties

Set up the application properties for your project to connect to the Redis server. This file is located in the src/main/resources directory.

# src/main/resources/application.properties

# Redis configuration
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password= # If Redis requires a password, set it here

Explanation:

• Configures the connection to the Redis server.

Step 2: Define a Redis Configuration Class

2.1 Create a Redis Configuration Class

Create a configuration class to set up the Redis connection factory and Redis template.

package com.example.demo.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.connection.lettuce.LettuceConnectionFactory;
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 RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @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:

• LettuceConnectionFactory: Creates a connection to the Redis server using Lettuce.
• RedisTemplate: Provides high-level abstraction to interact with Redis. Configures key and value serializers.

Step 3: Define an Entity Class

3.1 Create the Student Entity

Create an entity class to represent a student in the Redis database.

package com.example.demo.entity;

import java.io.Serializable;

public class Student implements Serializable {

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

    // Constructors, getters, and setters
    public Student() {}

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

    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 String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

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

Explanation:

• The Student class implements Serializable to allow serialization for storage in Redis.

Step 4: Create a Repository Interface

4.1 Create the StudentRepository

Create a repository interface to perform CRUD operations on the Student entity.

package com.example.demo.repository;

import com.example.demo.entity.Student;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface StudentRepository extends CrudRepository<Student, String> {
}

Explanation:

• CrudRepository<Student, String>: Provides CRUD operations for the Student entity.

Step 5: Create Service and Controller Layers

5.1 Create the StudentService

Create a service class to handle business logic related to students.

package com.example.demo.service;

import com.example.demo.entity.Student;
import com.example.demo.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class StudentService {

    @Autowired
    private StudentRepository studentRepository;

    public Iterable<Student> getAllStudents() {
        return studentRepository.findAll();
    }

    public Optional<Student> getStudentById(String id) {
        return studentRepository.findById(id);
    }

    public Student createStudent(Student student) {
        return studentRepository.save(student);
    }

    public void deleteStudent(String id) {
        studentRepository.deleteById(id);
    }
}

Explanation:

• @Service: Marks the class as a service component in Spring.
• StudentRepository: Injected to interact with the database.

5.2 Create the StudentController

Create a REST controller to expose endpoints for interacting with students.

package com.example.demo.controller;

import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Optional;

@RestController
@RequestMapping("/students")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @GetMapping
    public Iterable<Student> getAllStudents() {
        return studentService.getAllStudents();
    }

    @GetMapping("/{id}")
    public Optional<Student> getStudentById(@PathVariable String id) {
        return studentService.getStudentById(id);
    }

    @PostMapping
    public Student createStudent(@RequestBody Student student) {
        return studentService.createStudent(student);
    }

    @DeleteMapping("/{id}")
    public void deleteStudent(@PathVariable String id) {
        studentService.deleteStudent(id);
    }
}

Explanation:

• @RestController: Marks the class as a REST controller.
• @RequestMapping("/students"): Maps the controller to /students endpoint.
• @GetMapping, @PostMapping, @DeleteMapping: Maps HTTP GET, POST, and DELETE requests respectively.
• @RequestBody: Binds the HTTP request body to the Student parameter.
• @PathVariable: Binds the URI template variable to the method parameter.

Step 6: Running and Testing the Application

6.1 Run the Application

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

./mvnw spring-boot:run

6.2 Test the Endpoints

Use a tool like Postman or your browser to test the endpoints.

Create a Student

• URL: http://localhost:8080/students
• Method: POST
• Body:

  {
      "id": "1",
      "name": "John Doe",
      "email": "john.doe@example.com",
      "age": 20
  }
  

Get All Students

• URL: http://localhost:8080/students
• Method: GET

Get a Student by ID

• URL: http://localhost:8080/students/1
• Method: GET

Delete a Student

• URL: http://localhost:8080/students/1
• Method: DELETE

Conclusion

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

• Setting up a Spring Boot project with Spring Data Redis.
• Defining an entity class for Redis.
• Creating repository, service, and controller layers.
• Running and testing the application using REST endpoints.

By following these steps, you can effectively manage and interact with a Redis database in your Spring Boot applications using Spring Data Redis.