Caching
A cache transparently stores data so that future requests for that data can be served faster. If requested data is contained in the cache (cache hit), this request can be served by simply reading the cache, which is faster. Otherwise (cache miss), the data has to be recomputed or fetched from its original storage location such as a database, mainframe or service API, which is slower.
Hazelcast IMDG is the leading in-memory data grid solution. Its caching solution enables organizations to predictably scale mission-critical enterprise and Cloud-based applications by providing in-memory access to frequently used data. Hazelcast IMDG stores frequently accessed data in-memory across an elastically scalable data grid. This enables any network of machines to dynamically cluster and pool both memory and processors to accelerate application performance. Machines may also be virtualized as JVM instances in Cloud IaaS, container and virtualization deployments.
Cache Access Patterns
Hazelcast IMDG allows you to cache when connected to a persistent data store such as a relational database. The most common access patterns are read-through, write-through, and write-behind.
Read-Through
Applications retrieve data directly from Hazelcast IMDG using familiar Map and other popular data structure API calls including open standards such as JCache. Read-through is transparent: The data will be read from the underlying data store only if it is not available in the cache. The retrieval call made by the application is unaware that Hazelcast may be calling the back-end store in the event of a cache miss. To establish the link between Hazelcast IMDG and the back-end store, application developers write pluggable query code that is executed by Hazelcast in the event of a cache miss.
Write-Through
In write-through pattern, records are synchronously and automatically persisted to data store whenever it is updated in cache. Hazelcast IMDG provides many configuration options to simplify your architecture while addressing your caching use case.
Write-Behind
You can use the write-behind mode to put modified entries to the data store asynchronously after a configurable delay. Unlike write-through, write-behind mode is cache-first. That is why write-behind is faster. You do not have to wait for the data to be persisted to the actual data store.
Near Cache
Near Cache is highly recommended for data structures that are mostly read. When an object is fetched from a remote member, it is put to local cache, so subsequent requests are handled by local member retrieving from local cache.
Near Cache gives Hazelcast IMDG users a huge advantage over NoSQL solutions like Redis, Cassandra, MongoDB, etc. which do not have near caching capabilities. In benchmark comparisons, Hazelcast IMDG Map is already 56% faster than Redis without using near cache. Enabling near cache makes Hazelcast IMDG 500% or 5 times faster than Redis. If you are using Hazelcast near cache feature in client-server deployments, microsecond response times can be achieved with the right serialization. Check the NoSQL use case to learn more about how you can benefit from Hazelcast IMDG as a NoSQL data store.
Hazelcast IMDG Features for Caching
Hazelcast IMDG ships out of the box with best-in-class features to cover all your caching scenarios:
JCache:Hazelcast IMDG enables organizations to seamlessly integrate with JCache, the Java standard for accessing frequently used objects from RAM, thus providing a standard and easy-to-use way to deliver extreme application performance. Learn more about JCache Provider use case.
Cache-as-a-Service: Hazelcast IMDG lets you implement a Cache-as-a-Service layer by providing a scalable, reliable and fast caching solution. Applications can use Hazelcast as a side-cache to their database, or hide the database behind the caching service and allow Hazelcast to load data from RBDMS, NoSQL or other storage. Learn more about the Cache-as-a-Service use case.
Hibernate Second Level Cache: Hazelcast IMDG provides a distributed 2LC for your Hibernate entities, collections and queries to greatly improve your application performance as commonly used data can be held in memory in the application tier. Learn more about the Hibernate 2LC use case.
Spring Cache Integration: Hazelcast IMDG ships out of the box with support for Spring Cache which allows it to plug in to any Spring application which supports these methods. Hazelcast IMDG can be used as cache for applications based on the Spring Framework –distributing shared data in real-time. Learn more about the Spring Cache integration use case.
Web Sessions: Hazelcast IMDG provides web session clustering. User sessions are maintained in the Hazelcast cluster, using multiple copies for redundancy. In the event of an application server failure, the load balancer redirects to a new application server which has access to the user session. The hand off to the new application server is seamless for the user. This provides the highest level of customer experience. Web session clustering use case is available for Tomcat and Jetty using native integration, and any application server using filters.
Management Center: Enables you to monitor and manage your members that are running Hazelcast IMDG. In addition to monitoring the overall state of your clusters, you can also analyze and browse your data structures in detail, update map configurations, and take thread dump from members. Learn more about Management Center.
High-Density Caching: Hazelcast IMDG Enterprise HD scales up data sizes using High-Density Memory Store, a way for Java applications to access multiple terabytes of memory per cluster member without long and unpredictable garbage collection pauses. This memory store provides the benefits of “off-heap” memory using a variety of proprietary high-performance memory management techniques.
WAN Replication: Allows you to keep multiple Hazelcast IMDG clusters in sync by replicating their state over WAN environments such as the Internet. Hazelcast IMDG supports both Active-Passive and Active-Active modes to most common scenarios. Learn more about WAN Replication.
Hot Restart Store: A high-performance option included in Hazelcast IMDG Enterprise HD in addition to the basic reliability options (write-through and write-behind). This persistence feature provides fast cluster restarts by storing the states of the cluster members on disk in a format specially designed for restart performance and to work in concert with SSDs. Learn more about Hot Restart.
Security Suite: A rich set of JAAS-based security features that you can use to authenticate cluster members and clients, in order to perform authorization checks on client operations. Socket Interceptor, Security Interceptor, Encryption, SSL, Credentials and ClusterLoginModule, Cluster Member Security, and Native Client Security are the main components of the security suite. Learn more about the Security Suite.
Rolling Upgrade: Allows you to upgrade your running Hazelcast IMDG cluster without service disruption, data loss, and interruption to execution. You can upgrade your Hazelcast IMDG members and clients in a running cluster without interrupting operations. Learn more about the Rolling Upgrade capabilities.
Enterprise PaaS Deployments: Certified native images enable you to run IMDG Enterprise and Enterprise HD in the leading enterprise cloud container environments including Pivotal Cloud Foundry and Red Hat OpenShift Container Platform. Learn more about Enterprise PaaS Deployments.
Products in this Use Case:
Learn More
