Spring Boot EhCaching

EhCache

EhCache is an open-source, Java-based cache used to boost performance. The current version of Ehcache is 3. It provides the implementation of the JSR-107 cache manager. We can use it directly.

Features of EhCache

It is fast, lightweight, Scalable, and Flexible.
It allows us to perform Serializable and Object
It offers cache eviction policies such as LRU, LFU, FIFO,
It stores the cache in memory and disk (SSD).
It depends on SLF4J for logging.
It has a full implementation of JSR-107 and Jcache
It supports distributed caching via JGroups or JMS and RMI.
It uses fluent query language for distributed search.

EhCache Usage Patterns

The cache uses several access patterns. There are following patterns used by EhCache:

Cache-aside
Cache-as-SoR (system-of-record)
Read-through
Write-through
Write-behind

Cache-aside

In the cache-aside pattern, first, the application consults with the cache. If the data is found, it returns the data directly. In the opposite scenario, it fetches the data from the SoR, stores it into the cache, and then return.

Cache-as-SoR

The cache-as-SoR pattern represents SoR reading and writing operations to the cache. It reduces the responsibility of the application. It uses the combination of read and write pattern that includes read-through, write-through, and write-behind. It reduces the difficulty of the application. It allows the cache to solve the thundering-herd problem

Read-through

The read-through pattern also copies the cache-aside pattern while reading data from the cache. The difference between the read-through and cache-aside is that read-through pattern implements the CacheEntryFactory interface. It guides the cache how to read an object from the cache. It is better to wrap the EhCache instance with the instance of SelfPopulatingCache while using the read-through pattern.

Write-through

The write-through pattern also copies the cache-aside pattern while writing data in the cache. The difference between write-through and cache-aside pattern is that write-through pattern implements the CacheWriter interface. It configures the cache for both write-through and write-behind pattern. It writes data to the SoR in the same thread of execution.

Write-behind

The write-behind pattern is different form the other three patterns. It modifies the cache entries after a configurable delay. The delay may in seconds, minutes, a day, a week, or for a long time. Simultaneously, it also queues the data to write at a later time in the same thread of execution.

The data write using write-behind pattern happens outside of the scope of the transaction. It means that it creates a new transaction to commit the data in the SoR that is distinct from the main transaction.

EhCaching Storage Tiers

EhCache allows us to use various data storage areas, such as heap, disk and clustered. We can configure a multi-storage cache (uses more than one storage area). It can be arranged and managed as tiers.

The tiers are organized in order. The bottom-most tier is known as authority tier, and the other tier is known as the caching tier. It is also known as nearer or near cache. The caching tier can have more than one storage area. The hottest data kept in the caching tier because it is faster than the authority tier. Other data is kept in the authority tier that is slower but richer in comparison to the caching tier.

There are four types of data storage supported by EhCache:

On-Heap Store
Off-Heap Store
Disk Store
Clustered Store

On-Heap Store

It stores cache entries in Java heap memory. It shares the storage with Java application. It is fast because it uses heap but has limited storage space. The garbage collector also scans the on-heap store.

Off-Heap Store

It uses the primary memory (RAM) to store cache entries. The garbage collector does not scan it. It is slower than the on-heap store because the cache entries move to the on-heap store before use. It is limited in size.

Disk Store

It uses a disk to store cache entries. It is much slower than RAM-based stores (on and off-heap store). It is better to use a dedicated disk if you are using a disk store pattern. It enhances throughput.

Clustered Store

It stores cache entries on the remote server. It is slower than off-heap storage. It may have a failover server that provides high availability.

The above diagram shows that:

An application may have more than one Cache Manager.
Many caches can be handled by a Cache Manager.
The caches can use more than one tier for storing cache entries.
EhCache puts the recently used or frequently used data in the faster tier (caching tier).

Configuring EhCache

Place the EhCache jar in the classpath.
Configure the xml and put it in the classpath.
Create a
Reference a Cache.

Example of EhCache

In the following example, we are going to configure EhCache in an application.

Step 1: Open the Spring Initializr https://start.spring.io/.

Step 2: Select the Spring Boot version 2.3.0 M2.

Step 3: Provide the Group name. We have provided the Group name com.javatpoint.

Step 4: Provide the Artifact. We have provided the Artifact spring-boot-ehcache-example.

Step 5: Add the Spring Web dependency.

Step 6: Click on the Generate button. When we click on the Generate button, it wraps all the specifications related to application into a Jar file and downloads it to the local system.

Step 7: Extract the jar file.

Step 8: Copy the folder and paste it in the STS workspace.

Step 9: Import the project.

File -> Import -> Existing Maven Projects -> Next -> Browse -> Select the folder spring-boot-ehcache-example -> Select Folder -> Finish

It takes time to import the project.

Step 10: Copy the following dependency one by one from the Maven Repository https://mvnrepository.com/ and paste it into the pom.xml file.

spring-boot-starter-cache
ehcache 3
cache API.

Note: Do not use the ehcache of the package net.sf.ehcache.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.0.M2</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.javatpoint</groupId>
<artifactId>spring-boot-ehcache-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-ehcache-example</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
</dependency>
<dependency>
<groupId>javax.cache</groupId>
<artifactId>cache-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>

Now, we need to configure the ehcache.xml file. It tells the framework where to find the file.

Step 11: Open the application.properties file and configure the EhCache by using the following property.

application.properties

#configuring ehcache.xml
spring.cache.jcache.config=classpath:ehcache.xml

Step 12: Open the SpringBootEhcacheExampleApplication.java file and enable caching by using the annotation @EnableCaching.

SpringBootEhcacheExampleApplication.java

package com.javatpoint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//enables the cache management capability
@EnableCaching
public class SpringBootEhcacheExampleApplication 
{
public static void main(String[] args) 
{
SpringApplication.run(SpringBootEhcacheExampleApplication.class, args);
}
}

Note: If we do not want to use annotation @EnableCaching in main application file, we can create a separate CacheConfig class and annotate that call with the annotation.

package com.javatpoint;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
@Configuration
//enable caching
@EnableCaching
public class CacheConfig 
{
}

Step 13: Create a model class. We have created the model class in the package com.javatpoint with the name Student. In the model class do the following:

Create five variable id, name, gender, and
Generate Constructor using Fields.
Right-click on the file -> Source -> Generate Constructor using Fields -> Select All -> Generate
Generate Getters and Setters.
Right-click on the file -> Source -> Generate Getters and Setters -> Select All -> Generate
Generate a toString()
Right-click on the file -> Source -> Generate toString() -> Generate

After completing all the above steps, the model class looks like the following.

Student.java

package com.javatpoint;
public class Student 
{
private int id;
private String name;
private String gender;
private String city;
public Student(int id, String name, String gender, String city) 
{
super();
this.id = id;
this.name = name;
this.gender = gender;
this.city = city;
}
public int getId() 
{
return id;
}
public void setId(int id) 
{
this.id = id;
}
public String getName() 
{
return name;
}
public void setName(String name) 
{
this.name = name;
}
public String getGender() 
{
return gender;
}
public void setGender(String gender) 
{
this.gender = gender;
}
public String getCity() 
{
return city;
}
public void setCity(String city) 
{
this.city = city;
}
@Override
public String toString() 
{
return "Student [id=" + id + ", name=" + name + ", gender=" + gender + ", city=" + city + "]";
}
}  

Step 14: Create a Service class that manages the student. We have created the service class with the name StudentManager. In this class, we have done the following:

Annotated the class with the annotation @Service.
Create an instance of HashMap.
In the static block, we have added student data in the map.
By using the annotation @Cacheable, we have defined the name of the cache All the data will be saved in this cache. We have defined the id in the key attribute of the annotation. The cache searches the student on the basis of id.
We have created a method getStudentById() that parses id as a parameter. It returns the id of the student.

StudentManager.java

StudentManager.java
package com.javatpoint;
import java.util.HashMap;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class StudentManager 
{
static HashMap<Integer, Student> student = new HashMap<>();
static 
{
student.put(1, new Student(100, "Alex", "Male", "Berlin"));
student.put(2, new Student(101, "Tony", "Male", "Maxico"));
student.put(3, new Student(102, "Andrew", "Male", "Chicago"));
student.put(4, new Student(103, "Alexa", "Female", "Brussels"));
student.put(5, new Student(104, "Maria", "Female", "Houston"));
}
@Cacheable(cacheNames="demoCache", key="#id")
public Student getStudentById(Integer id) 
{
System.out.println("Fetching student data from cache");
return student.get(id);
}
}

Now we need to create ehcache.xml file. It contains the information related to cache such as name of the cache, no of element in the memory, time to live data in the cache, etc.

Step 15: Create a cache configure file named ehcache.xml in the src/main/resources folder.

ehcahe.xml

<config
xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
xmlns='http://www.ehcache.org/v3'
xmlns:jsr107='http://www.ehcache.org/v3/jsr107'>
<ehcache>
<diskStore path="java.io.tmpdir" />
<defaultCache maxElementsInMemory="2000" 
			eternal="true"
			overflowToDisk="false" 
			timeToLiveSeconds="1200" />
	<cache name="demoCache" 
			maxElementsInMemory="2000"
			eternal="false" 
			overflowToDisk="false" 
			timeToLiveSeconds="10000" />
</ehcache>
</config>

Now we have created all the required files. After creating all the files, the project directory looks like the following:

Let's run the application.

Step 16: Open the SpringBootEhcacheExampleApplication.java file and run it as Java Application.

It shows the following output:

Getting Students from Cache
[id=100, name=Alex, gender=Male, city=Berlin]
[id=101, name=Tony, gender=Male, city=Mexico]
[id=102, name=Andrew, gender=Male, city=Chicago]
[id=103, name=Alexa, gender=Female, city=Brussels]
[id=104, name=Maria, gender=Female, city=Houston]

Download EhCaching Project

Next TopicHow to Run Spring Boot Application

← prev next →