Spring Boot EhCaching
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
EhCache Usage Patterns
The cache uses several access patterns. There are following patterns used by EhCache:
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.
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
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.
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.
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:
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.
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.
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.
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:
Example of EhCache
In the following example, we are going to configure EhCache in an application.
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.
Note: Do not use the ehcache of the package net.sf.ehcache.
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.
Step 12: Open the SpringBootEhcacheExampleApplication.java file and enable caching by using the annotation @EnableCaching.
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.
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:
After completing all the above steps, the model class looks like the following.
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:
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.
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: