Feature Comparison: Redis vs Apache Ignite

Redis and Apache Ignite are two popular and highly similar technologies - but what's the best way to do a comparison between Redis and Apache Ignite?

Redis is an open-source, in-memory data structure store used to implement a NoSQL key-value database. The Redis project includes support for many different abstract data structures and is compatible with many programming languages, including Java.

Apache Ignite, meanwhile, is an open-source, in-memory computing platform and distributed database that is optimized for large volumes of data. As a product of the Apache Software Foundation, Apache Ignite offers a native SQL API for the Java programming language.

They're both open-source database projects that work well with Java - so what's the difference between Redis and Apache Ignite? By installing a third-party Redis Java client such as Redisson, you can significantly enhance the features that Redis has to offer. Below, we'll do a point-by-point feature comparison of Redis and Apache Ignite.

Distributed collections
Redis + Redisson Apache Ignite
Map
Multimap
Set
List
Queue
Deque
SortedSet
ScoredSortedSet
PriorityQueue
PriorityDeque
DelayedQueue
TransferQueue
RingBuffer
TimeSeries

Both Redis+Redisson and Apache Ignite have implementations of various Java collections in order to smooth the learning curve for Java developers.

Apache Ignite has most of the data structures from the java.util.concurrent framework, including:

  • Map
  • Set
  • List
  • Queue

Redis+Redisson has all of the above distributed Java collections and more, including:

  • Multimap
  • Deque
  • SortedSet
  • ScoredSortedSet
  • PriorityQueue
  • PriorityDeque
  • DelayedQueue
  • TransferQueue
  • RingBuffer
Distributed locks and synchronizers
Redis + Redisson Apache Ignite
Lock
Semaphore
CountDownLatch
FairLock
MultiLock
ReadWriteLock
PermitExpirableSemaphore

Both Redis+Redisson and Apache Ignite also include multiple distributed locks and synchronizers in Java - yet Redis again comes out on top in this category.

Apache Ignite has implementations of:

  • Lock
  • Semaphore
  • CountDownLatch

Redis+Redisson includes the above classes, as well as:

  • FairLock
  • MultiLock
  • ReadWriteLock
  • PermitExpirableSemaphore
Distributed objects
Redis + Redisson Apache Ignite
Object holder
AtomicLong
Publish/Subscribe
AtomicDouble
Geospatial
BitSet
BloomFilter
BinaryStream
HyperLogLog
RateLimiter

Redis+Redisson and Apache Ignite also offer a grab bag of various Java distributed objects. Apache Ignite includes:

  • Object holder
  • AtomicLong
  • Publish/Subscribe

Redis+Redisson includes all of these objects and more:

  • AtomicDouble
  • Geospatial
  • BitSet
  • BloomFilter
  • BinaryStream
  • HyperLogLog
  • RateLimiter
Advanced cache support
Redis + Redisson Apache Ignite
JCache API
JCache API with near cache (up to 45x faster)
Near Cache

Caching is one of the most important features that a database can support, particularly for distributed applications. Being able to cache data on multiple machines can often speed up database-heavy applications by orders of magnitude.

Both Redis+Redisson and Apache Ignite include support for the "near cache": a small local cache that stores frequently accessed data on the heap. What's more, both Redis+Redisson and Apache Ignite include an API for JCache, the standard Java caching API.

However, where Redis+Redisson truly excels is in the performance of JCache. Only Redis+Redisson includes a JCache API with near caching that can execute operations up to 45 times faster.

API architecture
Redis + Redisson Apache Ignite
Asynchronous API partial support
Reactive API
RxJava2 API

The asynchronous, reactive, and RxJava2 programming models are all related ways of performing asynchronous and parallel programming in Java. Using these three models is a time-tested way to speed up and optimize your distributed applications in Java.

If you want to use them, however, you'll have to choose Redis+Redisson. Apache Ignite only offers partial support for the asynchronous API, and no support at all for the reactive and RxJava2 APIs. Redis+Redisson, meanwhile, includes support for all three.

Transactions
Redis + Redisson Apache Ignite
Transactions API

Java transactions are a paradigm that allow developers to execute multiple commands within a single step. Both Redis+Redisson and Apache Ignite offer ACID-compliant transactions to ensure that all statements within a single transaction either succeed or fail. More specifically, both Redis+Redisson and Apache Ignite include support for both Spring transaction management.

Distributed services
Redis + Redisson Apache Ignite
ExecutorService
MapReduce
SchedulerService
RemoteService
LiveObjectService
Integration with frameworks
Redis + Redisson Apache Ignite
Spring Cache
Spring Cache with near cache (up to 45x faster)
Hibernate Cache
Hibernate Cache with near cache (up to 5x faster)
Tomcat Session Manager
Spring Session
Statistics monitoring 20 different statistics monitoring systems including JMX Own monitoring tool
Security
Redis + Redisson Apache Ignite
Authentication
Authorization
SSL support
Custom data serialization
Redis + Redisson Apache Ignite
JSON codec
JDK Serialization
Avro codec
Smile codec
CBOR codec
MsgPack codec
Kryo codec
FST codec
LZ4 compression codec
Snappy compression codec
Stability and ease of use
Redis + Redisson Apache Ignite
Fully-managed services support
(AWS Elasticache, Azure Cache, IBM Bluemix...)
Large memory amount handling

Both Redis+Redisson and Apache Ignite are capable of handling very large amounts of memory, which makes them ideal for performance-intensive applications.

However, between Redis+Redisson and Apache Ignite, only Redis includes support for fully managed services such as AWS ElastiCache and Azure Redis Cache. Apache Ignite does not have support from large cloud providers such as AWS and Microsoft, so you'll have to manage the deployment yourself if you want to use one of these providers.

Conclusion

With the head-to-head comparison between Redis and Apache Ignite complete, let's see how the two solutions stack up. Redis+Redisson is by far the winner when it comes to features such as distributed collections, locks, synchronizers, and objects, as well as custom data serialization and high performance.

Looking to enhance the power of your Redis database with a feature-rich Redis Java client? Check out the Redisson project, with use cases for everything from caching and scaling Java applications to distributed data processing and task scheduling.

Similar articles