Connect Redis in Spring Boot: Maven & Gradle Configuration

Redis is a popular in-memory data store that is widely used for caching, session management, and real-time data processing in modern web applications. Integrating Redis with Spring Boot can significantly improve application performance and scalability. In this blog, we will go through the configuration of connecting Redis to a Spring Boot application, enabling you to harness the power of this fast and efficient data store.

Prerequisites:

Before we begin, make sure you have the following prerequisites in place:

1. JDK (Java Development Kit) installed on your system.
2. A working Spring Boot project.
3. Redis installed and running on your local machine or a remote server.

Note: For this tutorial, we are using our basic skeleton project for springboot. You can also download the project from here.

Step 1: Add Redis Dependencies

To get started, you need to include the necessary Redis dependencies in your Spring Boot project. Open your project’s pom.xml file (if using Maven) or build.gradle (if using Gradle) and add the following dependenciez:

For Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

For Gradle:

implementation 'org.springframework.boot:spring-boot-starter-data-redis'

Step 2: Configure Redis Connection

Next, you need to configure the Redis connection properties in your Spring Boot application. Create or open the application.properties (or application.yml) file and add the following properties:

# Redis server properties
spring.redis.host=your-redis-server-host #localhost
spring.redis.port=6379

Make sure to replace your-redis-server-host with the hostname or IP address of your Redis server. If Redis is running on the default port (6379), you can omit the spring.redis.port property.

Step 3: Create the User Entity

Create a User entity class that will be stored in Redis. We’ll also annotate it with JPA annotations for mapping purposes.

import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;

@RedisHash("users")
public class User {

    @Id
    private String id;
    private String username;
    private String email;

    // Constructors, getters, and setters (omitted for brevity)
    public String getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

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

Step 4: Create the UserRepository

Create a UserRepository interface that extends org.springframework.data.repository.CrudRepository. This interface will handle CRUD operations for the User entity.

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends CrudRepository<User, String> {
    // No additional methods needed for basic CRUD operations
}

Step 5: Implement CRUD Operations in Service

Create a UserService class that interacts with the UserRepository and provides CRUD functionalities.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.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 deleteUser(String id) {
        userRepository.deleteById(id);
    }
}

Step 6: Create Controller for REST API

Create a REST controller that exposes endpoints for interacting with users.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

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

    @GetMapping("/{id}")
    public User getUserById(@PathVariable String id) {
        return userService.getUserById(id).orElse(null);
    }

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

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

Step 7: Run and Test the Application

Now that every_thing is set up, run the Spring Boot application. It will start, and you can access the REST API endpoints to perform CRUD operations on the User entity.

Example API’s usage:

• Create a new user: POST http://localhost:8080/users
  Request Body as JSON: {"username": "john_doe", "email": "[email protected]"}
• Retrieve a user by ID: GET http://localhost:8080/users/{id}
• Retrieve all users: GET http://localhost:8080/users
• Delete a user by ID: DELETE http://localhost:8080/users/{id}

Conclusion:

Congratulations! You have successfully implemented CRUD operations using Redis in a Spring Boot application. Now you have a basic understanding of how to connect Redis to Spring Boot and youtilize it as an efficient in-memory data store for your web applications.

Find this project on Github.

Also Read How to Protect Sensitive Data in a Java Project Like Spring Boot.

Read our Blog on How to Provide Initial Default Data for Models in Spring Boot