Implementing distributed caching with PostgreSQL and Hazelcast in Java

21 Sep 2023

Caching plays a crucial role in improving the performance and scalability of applications. It helps reduce the load on backend systems by storing frequently accessed data in memory. In this blog post, we will explore how to implement distributed caching using PostgreSQL and Hazelcast in Java.

What is Distributed Caching?

Distributed caching involves storing and accessing cached data across multiple servers. It allows for faster data access by distributing the cache across different nodes in a network. This approach ensures high availability and scalability, making it suitable for applications with heavy read loads.

Why PostgreSQL and Hazelcast?

PostgreSQL is a powerful open-source relational database known for its extensibility and advanced features. It provides support for various data types, indexing mechanisms, and query optimization techniques. By integrating PostgreSQL with a caching solution like Hazelcast, we can leverage its caching capabilities and enhance overall application performance.

Hazelcast, on the other hand, is an open-source in-memory data grid platform that provides distributed caching and computation features. It allows seamless integration with various technologies and offers a rich set of APIs for caching, clustering, and data synchronization.

Setting Up PostgreSQL

To get started, we need to set up PostgreSQL and create a database and table for caching. Follow these steps:

Install PostgreSQL on your machine by downloading it from the official website or using package managers like Homebrew (Mac) or apt-get (Linux).
Start the PostgreSQL service and access the PostgreSQL shell by running the command psql in the terminal.
Create a new database for caching using the following SQL command:
```
CREATE DATABASE caching_db;
```
Switch to the newly created database using the command \c caching_db.
Create a table called cache_data with the necessary columns for caching your data. For example, if you want to cache user profiles, you can create a table like this:
```
CREATE TABLE cache_data (
  id SERIAL PRIMARY KEY,
  username VARCHAR(50) NOT NULL,
  profile VARCHAR(2000) NOT NULL
);
```

Integrating Hazelcast with Java

Next, we need to integrate Hazelcast with our Java application to enable distributed caching. Follow these steps:

Add the Hazelcast dependency to your project’s pom.xml file if you’re using Maven. Otherwise, include the relevant Hazelcast JAR files in your project.
```
<dependency>
  <groupId>com.hazelcast</groupId>
  <artifactId>hazelcast</artifactId>
  <version>4.2.1</version>
</dependency>
```

Create a Java class representing the cache and configure Hazelcast. Here’s an example:

import com.hazelcast.config.Config;
import com.hazelcast.config.MapConfig;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IMap;
   
public class CacheManager {
  private static HazelcastInstance hazelcastInstance;
  private static IMap<Long, String> cache;
   
  public static void init() {
    Config config = new Config().setInstanceName("cache-instance");
    MapConfig mapConfig = new MapConfig().setName("cache-data");
    config.addMapConfig(mapConfig);
    hazelcastInstance = Hazelcast.newHazelcastInstance(config);
    cache = hazelcastInstance.getMap("cache-data");
  }
   
  public static String getFromCache(Long id) {
    return cache.get(id);
  }
   
  public static void putInCache(Long id, String data) {
    cache.put(id, data);
  }
}

Initialize the cache in your application’s entry point, such as the main method:

public class Application {
  public static void main(String[] args) {
    CacheManager.init();
    // Your application code
  }
}

Caching Data with PostgreSQL and Hazelcast

Now that we have integrated Hazelcast with our Java application, we can start caching data using PostgreSQL and Hazelcast together. Here’s an example of caching user profiles:

public class UserProfileService {
  private final CacheManager cacheManager;
  private final UserRepository userRepository;
  
  public UserProfileService() {
    this.cacheManager = new CacheManager();
    this.userRepository = new UserRepository();
  }

  public String getUserProfile(Long userId) {
    String userProfile = cacheManager.getFromCache(userId);
    
    if (userProfile == null) {
      userProfile = userRepository.getUserProfile(userId);
      cacheManager.putInCache(userId, userProfile);
    }
    
    return userProfile;
  }
}

In the above example, we first check if the user profile is available in the cache. If not, we retrieve it from the UserRepository and store it in the cache for future use. This way, subsequent requests for the same user profile can be served from the cache, reducing the load on the database.

Conclusion

Distributed caching is a powerful technique for improving application performance and scalability. By integrating PostgreSQL with Hazelcast in our Java applications, we can effectively cache frequently accessed data and reduce the load on the database. This, in turn, leads to faster response times and better overall system performance.

#distributedcaching #postgresql #hazelcast #java