Using Redisson for Distributed Locks in Spring Boot

The article builds on a previous discussion of five Redis distributed‑lock solutions and presents Redisson as a superior, concise approach for implementing distributed locks within a Spring Boot project.

Redisson is a Java in‑memory data grid built on Netty that wraps native Redis data structures (Hash, List, Set, String, Geo, HyperLogLog, etc.) into familiar Java collections and provides high‑level distributed primitives such as Lock, MultiLock, ReadWriteLock, Semaphore, and more.

To start, add the Redisson Maven dependency:

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.15.5</version>
</dependency>

Create a configuration class that builds a RedissonClient for a single‑node Redis server:

@Configuration
public class MyRedissonConfig {
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() throws IOException {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
}

Acquire a re‑entrant lock with simple code and expose it via a REST endpoint for testing:

@ResponseBody
@GetMapping("test-lock")
public String TestLock() {
    RLock lock = redisson.getLock("WuKong-lock");
    lock.lock();
    try {
        System.out.println("Lock acquired, thread ID: " + Thread.currentThread().getId());
        Thread.sleep(10000);
    } catch (Exception e) {
        // handle
    } finally {
        lock.unlock();
        System.out.println("Lock released, thread ID: " + Thread.currentThread().getId());
    }
    return "test lock ok";
}

The article demonstrates that the lock blocks other threads until it is released and shows that Redisson’s watchdog automatically extends the lock’s TTL (default 30 seconds) to avoid deadlocks when a node crashes.

Additional distributed primitives are covered: a read‑write lock ( RReadWriteLock) with shared read and exclusive write semantics, and a semaphore ( RSemaphore) used to model a parking‑lot scenario. Example code for acquiring and releasing a semaphore is provided.

Redisson also supports advanced lock types such as FairLock, MultiLock, RedLock, PermitExpirableSemaphore, and CountDownLatch, which can be explored in the official documentation.

Overall, Redisson offers a concise "king‑level" solution for distributed synchronization in Java backend services, simplifying configuration and usage compared with raw Redis commands.