Welcome back! In the previous lesson, we explored Redis Pipelines, which optimize command execution by batching multiple commands. Today, we’ll focus on Redis Transactions, a powerful feature that queues a group of commands for execution in a single, sequential operation.

By the end of this lesson, you will understand how to implement transactions in Redis using a conceptual approach.

Redis Transactions allow you to queue multiple commands and then execute them sequentially once you commit (using EXEC). This is often described as an atomic operation, but it’s important to note:

• Atomic Execution: Commands within a transaction are sent to Redis as a block.
• (Partial) All or Nothing: If a command fails at queue time (e.g., invalid command), the entire transaction is discarded. However, if a command fails at runtime (e.g., a type error), Redis will still execute the other commands. For example, if you queue syncCommands.set("key1", "value1") and syncCommands.incr("key1") in a transaction, and incr() fails at runtime due to key1 being non-numeric, the set() command will still execute. This demonstrates that atomicity in Redis transactions applies only to queuing, not to execution.
• Isolation: Transactions prevent other clients from executing commands on the keys being modified until the transaction completes.
• Queuing of Commands: Commands are queued after a transaction is initiated with MULTI and only execute on EXEC.

In short, Redis discards the entire transaction if a command cannot be queued correctly, but does not roll back commands if a runtime error occurs after the transaction is committed.

Here’s how to conceptually implement a basic transaction using Redis with Lettuce:

1. Start a Transaction: Initiate a Redis transaction context that allows you to queue commands.

2. Queue Commands: Add the necessary Redis commands to the queue. For instance, you might want to set a key-value pair or increment a counter.

3. Commit the Transaction: Execute all queued commands in a single operation. The server commits these commands and executes them atomically.

4. Handle Results: Process the results returned by the server, indicating the success or failure of each command.

Example:

Java
Copy to clipboard
1import io.lettuce.core.RedisClient;
2import io.lettuce.core.api.StatefulRedisConnection;
3import io.lettuce.core.api.sync.RedisCommands;
4import io.lettuce.core.TransactionResult;
5
6public class Main {
7
8    public static void main(String[] args) {
9        // Create a RedisClient with the appropriate URI
10        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
11
12        // Open a connection
13        StatefulRedisConnection<String, String> connection = redisClient.connect();
14            
15        // Obtain synchronous commands
16        RedisCommands<String, String> syncCommands = connection.sync();
17            
18        // Start a transaction
19        syncCommands.multi();
20            
21        // Queue commands
22        syncCommands.set("key1", "value1");
23        syncCommands.incr("counter");
24                
25        // Commit the transaction
26        TransactionResult transactionResult = syncCommands.exec();
27                
28        // Print the transaction results
29        transactionResult.forEach(result -> System.out.println("Result: " + result));
30    }
31}

While Redis Transactions ensure commands are executed sequentially, runtime errors can still occur. The “all commands succeed or none do” concept applies only to queue-time errors:

• Runtime Errors: If you queue valid commands, but one fails during execution (for example, incrementing a non-numeric key), the successful execution of other commands still occurs. The failed command returns an error.

Example:

Java
Copy to clipboard
1import io.lettuce.core.RedisClient;
2import io.lettuce.core.api.StatefulRedisConnection;
3import io.lettuce.core.api.sync.RedisCommands;
4import io.lettuce.core.TransactionResult;
5
6public class Main {
7
8    public static void main(String[] args) {
9        // Create a RedisClient with the appropriate URI
10        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
11
12        // Open a connection
13        StatefulRedisConnection<String, String> connection = redisClient.connect();
14            
15        // Obtain synchronous commands
16        RedisCommands<String, String> syncCommands = connection.sync();
17            
18        // Start a transaction
19        syncCommands.multi();
20            
21        // Queue commands
22        syncCommands.set("key2", "value2");
23        syncCommands.incr("key2"); // Will fail at runtime since "key2" is not numeric
24                
25        // Commit the transaction
26        TransactionResult transactionResult = syncCommands.exec();
27                
28        // Print the transaction results
29        transactionResult.forEach(result -> System.out.println("Result: " + result));
30    }
31}

If you need to discard a transaction before committing, perhaps due to unforeseen changes:

Java
Copy to clipboard
1import io.lettuce.core.RedisClient;
2import io.lettuce.core.api.StatefulRedisConnection;
3import io.lettuce.core.api.sync.RedisCommands;
4
5public class Main {
6
7    public static void main(String[] args) {
8        // Create a RedisClient with the appropriate URI
9        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
10
11        // Open a connection
12        StatefulRedisConnection<String, String> connection = redisClient.connect();
13            
14        // Obtain synchronous commands
15        RedisCommands<String, String> syncCommands = connection.sync();
16            
17        // Start a transaction
18        syncCommands.multi();
19            
20        // Queue commands
21        syncCommands.set("tempKey", "tempValue");
22                
23        // Discard the transaction
24        syncCommands.discard();
25        System.out.println("Transaction discarded.");
26    }
27}

• Transactions: Queue commands with atomicity-utilizing operations, guaranteeing sequence execution with partial atomicity where feasible—entire transactions are discarded if a queue-time error arises. Runtime errors don’t halt the transaction but affect only specific commands.
• Pipelines: Batch multiple commands to minimize round trips without guaranteeing sequential isolation or atomicity. Errors in commands don't influence others in the batch.

Transactions remain crucial for data consistency and simplifying workflows:

1. Sequential Execution: Prevents interleaving from other clients upon EXEC.
2. Simplified Logic: You can group dependent commands, avoiding the complexities of separate operations.
3. Partial Atomicity: Ensures that if a command cannot be queued, nothing is executed, and runtime errors don’t cancel the transaction.

With these fundamentals covered, you’re ready to apply Redis Transactions using your preferred implementation approach. Next, let’s move on to the practice section to experiment with Redis Transactions hands-on!