«Top»

Caches are a standard technique for increasing performance when transferring
data. Caches are widely deployed in both, hardware (CPU, disks, etc), and
software.

Our series on software caches in Java application servers
will introduce current implementations
(Ehcache, Hazelcast,
Infinispan),
and to point out their specific strengths and weaknesses.

Before we start examining the specific implementations, we finish our introduction
with an overview and categorization of related work and Big Data solutions:

• 0.2: Caches and Big Data.

The remainder of our series is structured as follows:

Part 1: Example Application

Part 01 introduces an example application,
using the Cache as a stand-alone, temporary data store for user events.
The example application is introduced together with a ConcurrentMap-based reference
implementation, and will subsequently be refactored to using Caches in the following parts.

There are a lot of more advanced applications for caches in Java server environments,
some of them are listed in JSR 107:

• client side caching of Web service calls
• caching of expensive computations such as rendered images
• caching of database rows
• caching of NoSQL data in-process
• Servlet response caching
• caching of domain object graphs

Our starting point is a simple, stand-alone example for an handmade cache used for logging
user based events:

• 1.1: Brief introduction to the features of the User Event Cache.
• 1.2: REST interface exposed.
• 1.3: The common data types used.
• 1.4: Reference implementation with a ConcurrentHashMap.

Part 2: Local Cache

Part 02 shows the basic implementation of local caches,
as defined in JSR 107.
Subsequently, the example application is implemented using the three
respective caches: Ehcache,
Hazelcast, and
Infinispan.

• 2.1: Introduction to JSR 107.
• 2.2: Local cache with Ehcache.
• 2.3: Local cache with Hazelcast.
• 2.4: Local cache with Infinispan.

Part 3: Peer-to-Peer Clustering

Part 03 introduces
peer-to-peer clustering as a way to share a
virtual cache among multiple application server
instances.

As it turns out, there are fundamental differences in the way peer-to-peer
clustering is implemented in Ehcache,
Hazelcast, and
Infinispan.

• 3.1: Introduction to peer-to-peer architectures.
• 3.2: Peer-to-peer with Ehcache.
• 3.3: Peer-to-peer with Hazelcast.
• 3.4: Peer-to-peer with Infinispan.

Part 4: Client-Server Clustering

Part 04 shows how a stand-alone cache
cluster can be implemented. The implementation is reviewed for
Ehcache,
Hazelcast, and
Infinispan.

• 4.1: Introduction to client-server architectures.
• 4.2: Client-server with Ehcache.
• 4.3: Client-server with Hazelcast.
• 4.4: Client-server with Infinispan.

Part 5: Advanced Topics

Our series concludes with an overview of some advanced topics,
like deployments as a second level database cache, or a non-standard feature
comparison matrix.

• 5.1 Second-level caches for databases.
• 5.2 Advanced features.

Next

The next page gives an overview of related work and Big Data solutions:

• 0.2: Caches and Big Data.