Adding environmental setup for Redis phase. Adding Redis to my Docker Compose YAML and application.yml, adding a Redis Config file, a Repository file for Tasks and Redis, and then a Redis-Lua file for implementing a Redis-based Distributed Lock. Have not yet adjusted any of the pre-existing infrastructure.

Author: timan-z

springqpro-backend/docker-compose.yml

@@ -11,6 +11,15 @@ services:
       - "5432:5432"
     volumes:
       - pgdata:/var/lib/postgresql
+  redis:
+    image: redis:7-alpine # Chosen intentionally - 7 becase stable, alpine because smaller size (better for CI stuff and deployment on AWS eventually).
+    container_name: springqpro-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    command: ["redis-server", "--save", "", "--appendonly", "no"]
 
 volumes:
   pgdata:
+  redis-data:

springqpro-backend/src/main/java/com/springqprobackend/springqpro/config/RedisConfig.java

@@ -0,0 +1,42 @@
+package com.springqprobackend.springqpro.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+// 2025-11-21-REDIS-PHASE-NOTE: THIS FILE CREATES CONNECTION FACTORY AND REDIS TEMPLATE W/ JACKSON SERIALIZER:
+@Configuration
+public class RedisConfig {
+    @Bean
+    public LettuceConnectionFactory redisConnectionFactory(
+            @Value("${spring.redis.host}") String host,
+            @Value("${spring.redis.port") int port
+    ) {
+        RedisStandaloneConfiguration cfg = new RedisStandaloneConfiguration(host, port);
+        return new LettuceConnectionFactory(cfg);
+    }
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+        // Use Jackson JSON serializer for values -- keeps Task metadata readable and avoids Java native serialization pitfalls.
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
+        GenericJackson2JsonRedisSerializer jackson = new GenericJackson2JsonRedisSerializer(mapper);
+        template.setKeySerializer(new StringRedisSerializer());
+        template.setValueSerializer(jackson);
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setHashValueSerializer(jackson);
+        template.afterPropertiesSet();
+        return template;
+    }
+}

springqpro-backend/src/main/java/com/springqprobackend/springqpro/redis/RedisDistributedLock.java

@@ -0,0 +1,44 @@
+package com.springqprobackend.springqpro.redis;
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.script.DefaultRedisScript;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.util.Collections;
+import java.util.UUID;
+
+/* 2025-11-21-REDIS-PHASE-NOTE:
+- Safe lock using SET key value NX PX ms and a Lua script unlock that checks token (prevents deleting another holder’s lock).
+- How to use: String token = lock.tryLock("task:lock:"+id, 10000); if(token!=null){ try { ... } finally { lock.unlock(...); } }
+SO BASICALLY, safe lock happens using SET NX PX, and we use a Lua script to unlock it. That's how this is going to work.
+*/
+@Component
+public class RedisDistributedLock {
+    // Field(s):
+    private final RedisTemplate<String, Object> redis;
+    private final DefaultRedisScript<Long> releaseScript;
+    // Constructor(s):
+    public RedisDistributedLock(RedisTemplate<String, Object> redis) {
+        this.redis = redis;
+        // [FOR UNLOCKING] -> Lua script: if redis.get(KEY)==ARGV[1] then del(KEY) return 1 else return 0 end.
+        String lua =
+                "if redis.call('get', KEYS[1]) == ARGV[1] " +
+                        "then return redis.call('del', KEYS[1]) " +
+                        "else return 0 end";
+        releaseScript = new DefaultRedisScript<>();
+        releaseScript.setScriptText(lua);
+        releaseScript.setResultType(Long.class);
+    }
+    // Methods:
+    public String tryLock(String key, long ttlMs) {
+        String token = UUID.randomUUID().toString();
+        Boolean ok = redis.opsForValue().setIfAbsent(key, token, Duration.ofMillis(ttlMs));
+        if(Boolean.TRUE.equals(ok)) return token;
+        return null;
+    }
+    public boolean unlock(String key, String token) {
+        Long res = redis.execute(releaseScript, Collections.singletonList(key), token);
+        return res != null && res > 0;
+    }
+}

springqpro-backend/src/main/java/com/springqprobackend/springqpro/redis/Redis_Lua_Note.md

@@ -0,0 +1,24 @@
+Redis supports server-side scripting using Lua (a lightweight, high-level, multi-paradigm programming language primarily designed
+for embedded use within applications. It's known for its simplicity, efficiency, and ease of integration with other languages,
+particularly C and C++), whcih allows for extending Redis' functionality and performing complex operations atomically.
+
+- Lua scripts execute as a single, atomic unit. This means that either the entire script completes successfully, or none of its
+operations are applied, ensuring data consistency even with multiple commands. This eliminates the need for explicit transactions
+or pipelines for atomicity within the script's execution.
+
+- Lua scripts can implement complex business logic, conditional execution, and custom data manipulations that aren't possible
+w/ individual Redis commands. They can access and modify Redis data structures and utilize most of the standard Redis commands
+through the redis.call() and redis.pcall() functions within the script.
+
+- Lua scripts are executed using the EVAL command, which takes the script itself, the number of keys the script will access,
+and then the keys and arguments as separate parameters. For subsequent executions of the same script, EVALSHA can be used with the 
+script's SHA1 digest for efficiency, avoiding repeated transmission of the full script.
+
+- Arguments passed to a Lua script are divided into KEYS and ARGV:
+- KEYS are used to specify the keys the script will interact with, allowing Redis to properly route commands in a clustered environment.
+- ARGV contains additional arguments or data needed by the script. Within the Lua script, these are accessible as tables KEYS[1], KEYS[2], etc.., and ARGV[1], ARGV[2], etc.
+- Important **NOTE**: Lua tables are 1-indexed (they start at index 1 instead of 0).
+
+- Error Handling: Lua scripts can manage errors within the script itself, allowing for more robust and self-contained logic.
+- Use Cases: Lua scripting is particularly useful for implementing atomic operations like distributed locks, counters with conditional increments, complex data migrations, or custom commands that combine multiple Redis operations.
+  (**Obviously in my case, I'm going to be using it for Distributed Locks**).

springqpro-backend/src/main/java/com/springqprobackend/springqpro/redis/TaskRedisRepository.java

@@ -0,0 +1,45 @@
+package com.springqprobackend.springqpro.redis;
+
+import com.springqprobackend.springqpro.domain.TaskEntity;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+
+// A thin cache abstraction. Keep logic here so you can change eviction/format later.
+// Note: We cache TaskEntity (DB representation) rather than domain Task. This fits DDD: cache the authoritative persisted shape.
+
+/* 2025-11-21-REDIS-PHASE-NOTE:
+- This file is a thin cache abstraction.
+- We'll be caching TaskEntity (DB representation, not domain Task). This is good DDD (Domain-Driven Design): Cache the authoritative persisted shape.
+*/
+@Component
+public class TaskRedisRepository {
+    // Field(s):
+    private static final String TASK_KEY_PREFIX = "task:";
+    private final RedisTemplate<String, Object> redis;
+    private final Duration ttl;
+    // Constructor(s):
+    public TaskRedisRepository(RedisTemplate<String, Object> redis, @Value("${cache.task.ttl-seconds:600}") long ttlSeconds) {
+        this.redis = redis;
+        this.ttl = Duration.ofSeconds(ttlSeconds);
+    }
+    // Method(s):
+    private String key(String id) {
+        return TASK_KEY_PREFIX + id;
+    }
+    public void put(TaskEntity entity) {
+        if(entity == null || entity.getId() == null) return;
+        redis.opsForValue().set(key(entity.getId()), entity, ttl);
+    }
+    public TaskEntity get(String id) {
+        Object o = redis.opsForValue().get(key(id));
+        if(o instanceof TaskEntity) return (TaskEntity) o;
+        return null;
+    }
+    public void delete(String id) {
+        redis.delete(key(id));
+    }
+    // DEBUG:+NOTE:+TO-DO: I can add other methods like exists(), setIfAbsent() and so on...
+}

springqpro-backend/src/main/resources/application.yml

@@ -13,6 +13,22 @@ spring:
       hibernate:
         format_sql: true
 
+  redis:
+    host: ${REDIS_HOST:localhost}
+    port: ${REDIS_PORT:6379}
+    timeout: 2000ms
+    lettuce:
+      pool:
+        enabled: true
+        max-active: 8
+        max-idle: 8
+        min-idle: 0
+
+# Redis cache defaults for my Task entities.
+cache:
+  task:
+    ttl-seconds: 600  # 10 minutes
+
 graphql:
   graphiql:
     enabled: true  # enable in-browser GraphiQL UI