Help Center/ GeminiDB/ GeminiDB Redis API/ Best Practices/ GeminiDB Redis API for Session Management in Web Applications
Updated on 2025-05-07 GMT+08:00
View PDF
Share

GeminiDB Redis API for Session Management in Web Applications

Redis is widely used for session management in web applications due to its efficiency, particularly in distributed systems. This section describes how to manage sessions using GeminiDB Redis API, which is completely compatible with Redis.

Application Scenarios

  • Distributed system: Traditionally, in a distributed system, server sessions like memory-based sessions, cannot be shared across servers. GeminiDB Redis API can address this issue.
  • High performance: With a distributed and scalable architecture, GeminiDB Redis API can efficiently handle high throughput.
  • Automatic expiration: You can enable automatic expiration for keys on your GeminiDB Redis instance to effectively manage session lifecycles.

Advantages of GeminiDB Redis API in Session Management

  • High availability: GeminiDB Redis API guarantees that session data remains intact even if there is a single point of failure.
  • Scalability: Nodes can be added for cluster GeminiDB Redis instances to handle high throughput.
  • Security: The access control and encryption functions enhance session data security.

Prerequisites

You have purchased a GeminiDB Redis instance. For details, see Buying a GeminiDB Redis Instance.

Procedure

Step 1 Creating a Spring Boot Project

Use Spring Initializr to create a Spring Boot project and add the following dependencies:

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

Use Spring Boot 3.0.x or later and JDK 17 or later.

Project directory structure:

├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─huawei
│  │  │          └─sessionmanagement
│  │  │                  SessionConfig.java
│  │  │                  SessionController.java
│  │  │                  SessionManagementApplication.java
│  │  │
│  │  └─resources
│  │          application.properties

Step 2 Configuring Redis and Enabling Redis Session Management

Configure connection information of a GeminiDB Redis instance in application.properties.

spring.data.redis.host=${ip}
spring.data.redis.port=${port}
spring.data.redis.password=${password}
server.servlet.session.timeout=30 #Session timeout interval (minutes)

In the main class or configuration class of Spring Boot applications, add @EnableRedisHttpSession to enable Redis sessions.

package com.huawei.sessionmanagement;
 import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

 @EnableRedisHttpSession
 public class SessionConfig {
    //Uses Spring Session to automatically stores sessions in Redis instances.
 }

Step 3 Logging In and Out a User

Create a controller to process the login and logout logic.

package com.huawei.sessionmanagement;
 import jakarta.servlet.http.HttpSession;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;

 @RestController
 public class SessionController {
     @PostMapping("/login")
     public String login(@RequestParam String username, HttpSession session) {
         session.setAttribute("username", username);
         return "Login successful";
     }

     @PostMapping("/logout")
     public String logout(HttpSession session) {
         session.invalidate();
         return "Logout successful";
     }
 }

Step 4 Obtaining Session Information and Specifying Session Storage

Obtain session information using HttpSession and add the following code to the SessionController class:

import org.springframework.web.bind.annotation.GetMapping;
 
@GetMapping("/getSessionInfo")
public String getSessionInfo(HttpSession session) {
    String username = (String) session.getAttribute("username");
    return "Username: " + username;
}

For more precise control, you can directly use RedisTemplate to store and manage sessions.

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
@Service
public class SessionService {
 
    private final RedisTemplate<String, Object> redisTemplate;
 
    public SessionService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
 
    public void saveSession(String sessionId, Object sessionData) {
        redisTemplate.opsForValue().set(sessionId, sessionData, 30, TimeUnit.MINUTES);
    }
 
    public Object getSession(String sessionId) {
        return redisTemplate.opsForValue().get(sessionId);
    }
 
    public void deleteSession(String sessionId) {
        redisTemplate.delete(sessionId);
    }
}

By performing the preceding steps, you can efficiently use GeminiDB Redis API to manage sessions of web applications and improve application performance and scalability.

Parent Topic: Best Practices