How to Integrate Redis with Spring Boot Session Management

Using Redis for session management in Spring Boot enhances performance, scalability, and resilience. This guide provides a step-by-step approach to integrating Redis with Spring Boot for session handling.

1. Add Required Dependencies

Include the following dependencies in your pom.xml to enable Redis session management:

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

2. Configure Redis for Session Management

Add the following properties in application.properties or application.yml to configure Redis for session storage:

spring.redis.host=localhost
spring.redis.port=6379
spring.session.store-type=redis
spring.session.timeout=1800 # Session timeout in seconds (30 minutes)

If Redis requires authentication, include:

spring.redis.password=yourpassword

3. Enable Redis Session Management in Spring Boot

Annotate the main application class with @EnableRedisHttpSession to enable session management:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

@SpringBootApplication
@EnableRedisHttpSession
public class RedisSessionApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisSessionApplication.class, args);
    }
}

4. Configure a Redis Connection Factory (Optional)

If custom configuration is needed, create a Redis configuration class:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.RedisConnectionFactory;

@Configuration
public class RedisConfig {
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }
}

5. Store and Retrieve Session Data

You can store session attributes in a Spring MVC controller:

import jakarta.servlet.http.HttpSession;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/session")
public class SessionController {
    @GetMapping("/set")
    public String setSession(HttpSession session) {
        session.setAttribute("username", "JohnDoe");
        return "Session data set";
    }

    @GetMapping("/get")
    public String getSession(HttpSession session) {
        return "Stored username: " + session.getAttribute("username");
    }
}

6. Testing Redis-Based Sessions

6.1 Start Redis Server

If you haven’t already, start a Redis server using Docker:

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

6.2 Test Session Persistence

1. Run the Spring Boot application.

2. Open a browser or use Postman to set session data:

   • http://localhost:8080/session/set

3. Retrieve session data using:

   • http://localhost:8080/session/get

4. Restart the application and access /session/get to confirm session persistence.

6.3 Verify Stored Sessions in Redis

Use the Redis CLI to check active sessions:

redis-cli
keys *
get spring:session:sessions:<session_id>

7. Expiring and Deleting Sessions

Spring Boot automatically removes expired sessions based on spring.session.timeout. You can also delete sessions manually:

@DeleteMapping("/invalidate")
public String invalidateSession(HttpSession session) {
    session.invalidate();
    return "Session invalidated";
}

Conclusion

Integrating Redis with Spring Boot for session management enhances scalability and ensures high performance by offloading session storage from the application server. With proper configuration, session persistence across multiple instances becomes seamless.