Redis for Java Developers: Tutorial and Code Examples

Redis for Java Developers: Tutorial and Code Examples

<strong>Redis is one of the most popular NoSQL database solutions, and Java is one of the world's most popular programming languages. Although it seems natural for the two to work together, Redis doesn't come with native support for Java.</strong>

Redis is one of the most popular NoSQL database solutions, and Java is one of the world's most popular programming languages. Although it seems natural for the two to work together, Redis doesn't come with native support for Java.

Instead, Java developers who want to integrate with Redis will need to use a Java client library. Redisson is a Redis-based in-memory data grid for Java that makes it easy for Java developers to work with Redis. Redisson provides implementations of many Java data structures to be distributed and scalable so that they can run on top of the Redis server.

This article will go over a few common use cases of Redisson so that you can see how easy it is to get started writing Java code for Redis.

How to Install Redisson

The easiest way to install Redisson is by adding it as a Maven or Gradle dependency:

Maven

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

Gradle

compile 'org.redisson:redisson:3.10.5'  

You can find the latest version number of Redisson by searching the Maven central repository.

How to Compile and Run Redisson

Once Redisson has been installed, compiling and running Redisson code just requires using the Java compiler:

javac RedissonExample.java

java RedissonExample

Java Lists in Redis

The code below is a simple demonstration of how to use the RList object in Redisson. RList is a distributed and concurrent implementation of Java’s List collection.

import org.redisson.Redisson;
import org.redisson.api.RList;
import org.redisson.api.RedissonClient;

public class ListExamples {

public static void main(String[] args) {
    // connects to 127.0.0.1:6379 by default
    RedissonClient redisson = Redisson.create();

    // implements java.util.List
    RList&lt;String&gt; list = redisson.getList("myList");
    list.add("1");
    list.add("2");
    list.add("3");

    boolean contains = list.contains("1");

    System.out.println("List size: " + list.size());
    System.out.println("Is list contains value '1': " + contains);

    for (String element : list) {
        System.out.println("List element: " + element);
    }

    redisson.shutdown();
}

}

When you run the code above, you should get the following output:

List size: 3

Does list contain value '1': true

List element: 1

List element: 2

List element: 3

Java Maps in Redis

Redisson also includes RMap, a distributed and concurrent implementation of the Java Map collection:

import java.io.IOException;

import org.redisson.Redisson; import org.redisson.api.RMap; import org.redisson.api.RedissonClient;

public class MapExamples {

public static void main(String[] args) throws IOException {
    // connects to 127.0.0.1:6379 by default
    RedissonClient redisson = Redisson.create();

    // implements java.util.concurrent.ConcurrentMap
    RMap&lt;String, Integer&gt; map =  redisson.getMap("myMap");
    map.put("a", 1);
    map.put("b", 2);
    map.put("c", 3);

    boolean contains = map.containsKey("a");
    System.out.println("Map size: " + map.size());
    System.out.println("Is map contains key 'a': " + contains);

    Integer value = map.get("c");
    System.out.println("Value mapped by key 'c': " + value);

    boolean added = map.putIfAbsent("c", 4) == null;
    System.out.println("Is value mapped by key 'c' added: " + added);

    redisson.shutdown();
}

}

When you run the code above, you will see the following output:

Map size: 3
Map contains key 'a': true
Value mapped by key 'c': 3
Value mapped by key 'c' added: false

Java Locks in Redis

The code below demonstrates the usage of RLock, a distributed implementation of the reentrant lock in Java:

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class LockExamples {

public static void main(String[] args) throws InterruptedException {
    // connects to 127.0.0.1:6379 by default
    RedissonClient redisson = Redisson.create();

    // implements java.util.concurrent.locks.Lock
    RLock lock = redisson.getLock("lock");
    lock.lock();
    System.out.println("lock aquired");

    Thread t = new Thread() {
        public void run() {
            RLock lock1 = redisson.getLock("lock");
            lock1.lock();
            System.out.println("lock aquired by thread");
            lock1.unlock();
            System.out.println("lock released by thread");
        };
    };

    t.start();
    t.join(1000);

    lock.unlock();
    System.out.println("lock released");

    t.join();

    redisson.shutdown();
}

}

This code will produce the following output:

lock aquired
lock released
lock aquired by thread
lock released by thread

Java AtomicLongs in Redis

Finally, this sample code demonstrates the usage of RAtomicLong, a distributed alternative to the AtomicLong class in Java for holding long values in a concurrent environment.

import org.redisson.Redisson;
import org.redisson.api.RAtomicLong;
import org.redisson.api.RedissonClient;

public class AtomicLongExamples {

public static void main(String[] args) {
    // connects to 127.0.0.1:6379 by default
    RedissonClient redisson = Redisson.create();

    RAtomicLong atomicLong = redisson.getAtomicLong("myLong");
    System.out.println("Init value: " + atomicLong.get());

    atomicLong.incrementAndGet();

    System.out.println("Current value: " + atomicLong.get());

    atomicLong.addAndGet(10L);

    System.out.println("Final value: " + atomicLong.get());

    redisson.shutdown();
}

}

The output of this code will be:

Init value: 0
Current value: 1
Final value: 11

What are your thoughts? Let me know in the comments.

Originally published by Nikita Koksharov at https://dzone.com

Learn More

☞ Complete Java Masterclass

☞ Complete Step By Step Java For Testers

☞ Java Web Service Complete Guide - SOAP + REST + Buide App

☞ Selenium WebDriver with Java - Basics to Advanced& Interview

☞ Java Persistence: Hibernate and JPA Fundamentals

☞ Java Swing (GUI) Programming: From Beginner to Expert

☞ Java Basics: Learn to Code the Right Way

java redis

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

How to Install OpenJDK 11 on CentOS 8

What is OpenJDK? OpenJDk or Open Java Development Kit is a free, open-source framework of the Java Platform, Standard Edition (or Java SE).

Redis Transactions & Long-Running Lua Scripts

Redis Lua scripting is the popularly recommended approach for handling transactions. Learn the common Lua Scripts error and how to handle for sentinel systems. Redis offers two mechanisms for handling transactions – MULTI/EXEC based transactions and Lua scripts evaluation. Redis Lua scripting is the recommended approach and is fairly popular in usage.

Java Core (2020) | Java for beginners | Brush up your Java Skills | Get Hired

In this video we will learn about all the major concepts that come under Java Core . The course is very carefully designed and is made with keeping simplicit...

Java Multithreading Example | Multithreading in Java

Java Multithreading Tutorial With Example | Multithreading in Java. Multithreading is a process of executing multiple threads simultaneously.

Java File Class Tutorial | Java.io File Class in Java Example

Java File class represents the path of directories and files. It provides the methods for renaming, deleting, and obtaining the properties of file or directory.