Persistence top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:


1. Overview

When caching in Redis, it can be useful to clear the whole cache when it becomes invalid.

In this short tutorial, we'll learn how to delete all the keys present in Redis, both in specific databases and across all databases.

First, we'll look at the command line. Then, we'll see how to accomplish the same thing using the APIs and the Java client.

2. Running Redis

We'll need an installation of Redis to work with. There are installation instructions for Mac and Linux in the Redis quickstart. It's probably easier to run Redis in docker.

Let's start a test Redis server:

docker run --name redis -p 6379:6379 -d redis:latest

And, we can run redis-cli to test that this server is working:

docker exec -it redis redis-cli

This drops us into the cli shell, where the command ping will test whether the server is up:> ping

We exit the redis-cli with CTRL+C.

3. Redis Commands

Let's start with the Redis commands to delete everything.

There are two major commands to delete the keys present in Redis: FLUSHDB and FLUSHALL. We can use the Redis CLI to execute these commands.

The FLUSHDB command deletes the keys in a database. And the FLUSHALL command deletes all keys in all databases.

We can execute these operations in a background thread using the ASYNC option. This is useful if the flush takes a long time, as making the command ASYNC stops it from blocking until it's complete.

We should note that the ASYNC option is available from Redis 4.0.0.

4. Working with the Java Client

Now, let's see how to use the Jedis Java client for deleting keys.

4.1. Dependencies

First, we'll need to add the Maven dependency for Jedis:


To make testing easier, let's also use an embedded Redis server:


4.2. Starting an Embedded Redis

We'll create an embedded Redis server to test with, by running it on an available port:

RedisService redisServer = new RedisServer(port);

Our Jedis client is then created with localhost as the host name, and the same port:

Jedis jedis = new Jedis("localhost", port);

5. Flushing a Single Database

Let's put some data into the database and check that it's remembered:

String key = "key";
String value = "value";
jedis.set(key, value);
String received = jedis.get(key);
assertEquals(value, received);

Now let's flush the database using the flushDB method:



As we can see, attempting to retrieve the value after flushing returns null.

6. Clearing All Databases

Redis provides multiple databases, which are numbered. We can add data to different databases by using the select command before we add our values:;
jedis.set("key1", "value1");;
jedis.set("key2", "value2");

We should now have one key in each of our two databases:;
assertEquals("value1", jedis.get("key1"));
assertEquals("value2", jedis.get("key2"));

The flushDB method will only clear the current database. In order to clear all the databases, we use the flushAll method:


We can test that this has worked:;

7. Time Complexity

Redis is a fast data store that scales well. However, flush operations can take longer when there is more data.

The time complexity of the FLUSHDB operation is O(N), where N is the number of keys in the database. If we use the FLUSHALL command, the time complexity is again O(N), but here, N is the number of keys in all databases.

8. Conclusion

In this article, we saw how to run Redis and the redis-cli in Docker, and how to use the Jedis client for Java with an embedded Redis server.

We saw how to keep data in different Redis databases and how to use the flush commands to clear one or more of them.

As always, the source code for this article is available over on GitHub.

Persistence bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Comments are closed on this article!