Caching is sometimes a very important problem for some applications with a lot of user requests. It both solves application performance issues and minimizes application-related I/O operations. In this tutorial, I introduce you to EhCache, an open-source caching that is used by many people.
First, I will create a new Maven project as an example:
with the EhCache dependency as follows:
|
1 2 3 4 5 |
<dependency> <groupId>org.ehcache</groupId> <artifactId>ehcache</artifactId> <version>3.9.6</version> </dependency |
As an example for this tutorial, I will use EhCache to store user information and we can retrieve user information from the cache using that user’s ID.
I will create a new class to store user information:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
package com.huongdanjava.ehcache; public class User { private Long id; private String name; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } |
and the main class to run the application has the following initial content:
|
1 2 3 4 5 6 7 8 |
package com.huongdanjava.ehcache; public class Application { public static void main(String[] args) { } } |
The cache manager object in EhCache is the Cache object and to get this object, the first thing you need to do is create a new CacheManager object, using the CacheManagerBuilder class as follows:
|
1 2 |
CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder() .build(true); |
Here, I initialize the CacheManager without any further configuration. You can, while initializing CacheManager, initialize some Cache that you want. I want to be clear, so I will initialize the Cache object later.
Now you can use the createCache() method of CacheManager to create a new Cache object for yourself. This createCache() method has two overloaded methods with the first common parameter of these two methods being the name of the cache. The second parameter is related to the cache configuration.
|
1 |
<K, V> Cache<K, V> createCache(String alias, CacheConfiguration<K, V> config) |
và:
|
1 |
<K, V> Cache<K, V> createCache(String alias, Builder<? extends CacheConfiguration<K, V>> configBuilder); |
Remember, we will cache by key and value, get value by key. Each cache will have a name, so we can declare which cache we need to get information from. When initializing the cache, we will need to declare the data type of the key and value in each cache.
In my above example, I will cache with the key as ID with the data type as Long, and my value will have the data type as User as follows:
|
1 2 3 4 |
Cache<Long, User> userCache = cacheManager.createCache("user", CacheConfigurationBuilder .newCacheConfigurationBuilder( Long.class, User.class, ResourcePoolsBuilder.heap(10))); |
The above code uses the CacheConfigurationBuilder class to declare the configuration information of the “user” cache. We use ResourcePoolsBuilder class with the static heap() method to declare the amount of information contained in a cache.
Now we can store cache information using put() method as follows:
|
1 2 3 4 5 |
User user = new User(); user.setId(1L); user.setName("Khanh"); userCache.put(user.getId(), user); |
Once you have the information in the cache, you can also get the information in the cache as follows:
|
1 2 3 |
Cache<Long, User> userCache1 = cacheManager.getCache("user", Long.class, User.class); User user1 = userCache1.get(1L); System.out.println(user1.getName()); |
Result:
