Boosting Performance with Hazelcast Client-Server Deployment With Near Cache: A Tutorial for Spring Applications
Hazelcast is a popular open-source in-memory data grid that provides distributed storage and processing capabilities. Hazelcast offers various deployment modes to suit different application requirements. One of the most widely used deployment modes is the client-server deployment mode, which is used to build distributed systems. In this article, we will explore the use cases and benefits of using Hazelcast client-server deployment mode with near cache and provide a step-by-step tutorial on how to implement it in Spring applications.
Client-Server Deployment Mode Overview
In client-server deployment mode, a client application communicates with a cluster of Hazelcast servers to access data. The Hazelcast servers manage the data storage and processing, while the client application sends requests to the servers to perform operations. This deployment mode is ideal for distributed systems that require high availability and scalability.
Near Cache Overview
Near cache is a caching mechanism that stores a copy of frequently accessed data in memory, closer to the client or application, thus reducing the number of requests to the server. Near cache is ideal for read-heavy applications that require low latency and high throughput.
Benefits of Using Client-Server Deployment with Near Cache
- Reduced Network Traffic
One of the key benefits of using client-server deployment mode with near cache is reduced network traffic. Since near cache stores a copy of frequently accessed data in memory, closer to the client or application, the number of requests to the server is reduced. This reduces the network traffic and improves the overall performance of the system.
- Improved Latency and Throughput
Near cache also improves the latency and throughput of the system. Since the frequently accessed data is stored in memory, closer to the client or application, the response time for read operations is reduced, resulting in improved latency. Near cache also reduces the load on the server, resulting in improved throughput.
- Better Scalability
Client-server deployment mode with near cache also provides better scalability. Since the client application communicates with a cluster of Hazelcast servers, the system can be scaled horizontally by adding more servers to the cluster. Near cache also improves the scalability of the system by reducing the load on the server.
Tutorial: Implementing Client-Server Deployment Mode with Near Cache in Spring Applications
Step 1: Add Hazelcast Dependency to Project
Add the following dependency to your project’s pom.xml file:
|
1 2 3 4 5 6 7 8 |
<dependency> <groupId>com.hazelcast</groupId> <artifactId>hazelcast-all</artifactId> <version>4.2</version> </dependency> |
Step 2: Configure Hazelcast Client
Create a configuration file named “hazelcast-client.xml” and add the following content:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<hazelcast-client xmlns="http://www.hazelcast.com/schema/client-config"> <network> <cluster-members> <address>server1:5701</address> <address>server2:5701</address> </cluster-members> </network> <near-cache name="myNearCache"> <time-to-live-seconds>300</time-to-live-seconds> <max-idle-seconds>180</max-idle-seconds> <eviction-policy>LRU</eviction-policy> <invalidate-on-change>true</invalidate-on-change> </near-cache> </hazelcast-client> |
In the above configuration, we have specified two cluster members (server1 and server2) that the client will connect to. We have also defined a near cache named “myNearCache” with a time-to-live of 300 seconds and a max idle time of 180 seconds. We have set the eviction policy to LRU (Least Recently Used) and enabled the invalidate-on-change option.
Step 3: Configure Hazelcast Server
Create a configuration file named “hazelcast-server.xml” and add the following content:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
<hazelcast xmlns="http://www.hazelcast.com/schema/config"> <network> <port>5701</port> <join> <multicast enabled="false"/> <tcp-ip enabled="true"> <interface>192.168.0.1</interface> </tcp-ip> </join> </network> <map name="myMap"> <near-cache name="myNearCache"> <time-to-live-seconds>300</time-to-live-seconds> <max-idle-seconds>180</max-idle-seconds> <eviction-policy>LRU</eviction-policy> <invalidate-on-change>true</invalidate-on-change> </near-cache> </map> </hazelcast> |
In the above configuration, we have defined a map named “myMap” with a near cache named “myNearCache”. We have specified the same near cache configuration as in the client configuration.
Step 4: Configure Spring Application
Add the following Hazelcast configuration to your Spring application’s configuration file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
@Configuration @EnableCaching public class HazelcastConfig { @Bean public HazelcastInstance hazelcastInstance() { ClientConfig clientConfig = new ClasspathXmlConfig("hazelcast-client.xml"); return HazelcastClient.newHazelcastClient(clientConfig); } @Bean public CacheManager cacheManager() { HazelcastCacheManager cacheManager = new HazelcastCacheManager(hazelcastInstance()); cacheManager.setCacheManagerConfigFile("hazelcast-server.xml"); return cacheManager; } } |
In the above configuration, we have created a Hazelcast client instance and a cache manager that uses the Hazelcast instance. We have also set the cache manager configuration file to the server configuration file.
Step 5: Use the Cache in Your Application
Now that we have configured Hazelcast client-server deployment mode with near cache in our Spring application, we can use the cache in our application code. Here’s an example of how to use the cache with the Spring Cache abstraction:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
@Service public class MyService { @Cacheable(value = "myCache") public MyObject getData(String key) { // Retrieve data from a remote Hazelcast map // This operation will be cached in the near cache return remoteMap.get(key); } } |
In the above code, we have annotated the getData() method with @Cacheable and specified the cache name as “myCache”. The method retrieves data from a remote Hazelcast map, which will be cached in the near cache.
Conclusion
In this article, we have explored the benefits of using Hazelcast client-server deployment mode with near cache and provided a step-by-step tutorial on how to implement it in Spring applications. By using client-server deployment mode with near cache, we can reduce network traffic, improve latency and throughput, and achieve better scalability in our distributed systems. By following the tutorial, you can easily add Hazelcast client-server deployment mode with near cache to your Spring applications and start reaping the benefits of improved performance.
