Redis in Spring Boot using RedisTemplate

byTech Blogger •April 26, 2025

0

Implementing the Repository Pattern for Redis Operations in Spring Boot using RedisTemplate

The Repository Pattern is a well-known design pattern that allows developers to manage data access while keeping the data access logic separate from the actual business logic. In this blog post, we'll explore how to implement the repository pattern for Redis operations in a Spring Boot application using RedisTemplate.

What is RedisTemplate?

RedisTemplate is a Spring abstraction that simplifies Redis operations, making it easier to work with data stored in Redis. It provides methods for CRUD operations and supports various data types, like Strings, Lists, Sets, Hashes, and more.

Prerequisites

Java Development Kit (JDK) 11 or later
Spring Boot 2.5 or later
Redis installed and running on your machine
Maven or Gradle as a build tool

Setting Up Your Spring Boot Application

Start by creating a new Spring Boot project. You can use Spring Initializr to add the required dependencies. Make sure to include:

Spring Web
Spring Data Redis
Lettuce or Jedis (Redis clients)

Once the project is created, download and extract it to your workspace.

Configure Redis in application.properties

Open the src/main/resources/application.properties file and add the following configurations:

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

Create the Model

Next, we will create a model class to represent the data we want to store in Redis. Let’s create a User class:

    
package com.example.demo.model;

import java.io.Serializable;

public class User implements Serializable {
    private String id;
    private String name;
    private String email;

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

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

    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;
    }
}

Create the User Repository

Now we will create a repository interface for the User model. This repository will define methods for performing CRUD operations on the User data:

    
package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import java.util.concurrent.TimeUnit;

@Repository
public class UserRepository {
    private final RedisTemplate<String, User> redisTemplate;

    public UserRepository(RedisTemplate<String, User> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public User save(User user) {
        redisTemplate.opsForValue().set(user.getId(), user);
        return user;
    }

    public User findById(String id) {
        return redisTemplate.opsForValue().get(id);
    }

    public void delete(String id) {
        redisTemplate.delete(id);
    }

    public void expire(String id, long timeout) {
        redisTemplate.expire(id, timeout, TimeUnit.SECONDS);
    }

    public Iterable<User> findAll() {
        // This method should be implemented based on your specific use case
        // Since Redis doesn't support a direct way to fetch all keys, 
        // consider keeping a list of all user IDs or another data structure.
        return null; // Placeholder
    }
}

Create the User Controller

Now, let's create a REST controller that will expose the CRUD operations for the User model:

    
package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserRepository userRepository;

    @Autowired
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userRepository.save(user);
        return new ResponseEntity<>(savedUser, HttpStatus.CREATED);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable String id) {
        User user = userRepository.findById(id);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable String id) {
        userRepository.delete(id);
        return ResponseEntity.noContent().build();
    }
}

Run the Application

Now that everything is set up, you can run your Spring Boot application. If using Maven, execute:

    
mvn spring-boot:run

Ensure your Redis server is running. The application should now be accessible at http://localhost:8080/api/users.

Testing the API

You can use Postman or curl commands to test the CRUD operations.

Create a User

    
curl -X POST -H "Content-Type: application/json" -d '{"id": "1", "name": "John Doe", "email": "john@example.com"}' http://localhost:8080/api/users

Retrieve a User

    
curl -X GET http://localhost:8080/api/users/1

Delete a User

    
curl -X DELETE http://localhost:8080/api/users/1

Conclusion

In this blog post, we learned how to implement the repository pattern for Redis operations in a Spring Boot application using RedisTemplate. This architecture allows for cleaner code, better separation of concerns, and easier unit testing. You can extend this pattern further by adding more complex queries, error handling, and integration with other services! Happy coding!

Tags: redis spring boot