Developer's Catalog

Database

Hazelcast

Overview

Hazelcast is an open-source, in-memory data grid platform developed in Java. It provides an integrated solution for distributed caching, computing, and storage, supporting the development of high-performance, scalable applications.

Designed for real-time applications, Hazelcast enables high-volume data processing with low latency, distributed computing, and stream processing within a single unified platform.

Details

• Development: Developed and maintained by Hazelcast Inc.
• Architecture: P2P distributed architecture (no master/slave model)
• Data Distribution: Automatic sharding and replication
• High Availability: Automatic failover and data recovery
• Language Support: Java (native), .NET, C++, Python, Go, Node.js
• CP Subsystem: Support for distributed locks, semaphores, and atomic operations
• Stream Processing: High-performance stream processing via Hazelcast Jet integration
• Security: TLS/SSL, JAAS, Kerberos authentication support
• Cloud Ready: Support for AWS, Azure, GCP, and Kubernetes environments
• Management: Web-based management UI through Management Center

Advantages and Disadvantages

Advantages

• Automatic Distribution: Automatic distribution and replication of data and computing
• P2P Architecture: Peer-to-peer configuration with no single point of failure
• High Performance: Low-latency processing through memory-based operations
• Scalability: Linear scalability by adding nodes
• Rich Feature Set: Diverse data structures including Map, Queue, Topic, Lock
• Enterprise Ready: Commercial support and complete management tools

Disadvantages

• Memory Consumption: High memory requirements for large data storage
• Java Dependency: JVM-based limitations for integration with other languages
• Complexity: Complexity of configuration and operations inherent to distributed systems
• Persistence Cost: Additional configuration and overhead for data persistence
• Licensing: Commercial features require paid licenses

Key Links

• Official Website
• Official Documentation
• GitHub Repository
• Management Center

Code Examples

Setup and Configuration

<!-- Maven dependency (pom.xml) -->
<dependencies>
    <dependency>
        <groupId>com.hazelcast</groupId>
        <artifactId>hazelcast</artifactId>
        <version>5.4.0</version>
    </dependency>
</dependencies>

// Basic Hazelcast instance startup
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;

public class HazelcastServer {
    public static void main(String[] args) {
        // Start Hazelcast instance with default configuration
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        
        System.out.println("Hazelcast instance started");
        
        // On application shutdown
        // hz.shutdown();
    }
}

Basic Operations (CRUD)

// Basic operations with distributed map (IMap)
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.map.IMap;

public class BasicMapOperations {
    public static void main(String[] args) {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        
        // Get distributed map
        IMap<String, String> customerMap = hz.getMap("customers");
        
        // Store data (PUT)
        customerMap.put("user:1001", "John Doe");
        customerMap.put("user:1002", "Jane Smith");
        
        // Retrieve data (GET)
        String customer = customerMap.get("user:1001");
        System.out.println("Customer: " + customer);
        
        // Update data
        customerMap.put("user:1001", "John Smith");
        
        // Delete data
        customerMap.remove("user:1002");
        
        // Total data size
        System.out.println("Map size: " + customerMap.size());
        
        hz.shutdown();
    }
}

Client Connection Configuration

// Hazelcast client configuration
import com.hazelcast.client.HazelcastClient;
import com.hazelcast.client.config.ClientConfig;
import com.hazelcast.core.HazelcastInstance;

public class HazelcastClientExample {
    public static void main(String[] args) {
        // Client configuration
        ClientConfig clientConfig = new ClientConfig();
        clientConfig.setClusterName("my-cluster");
        clientConfig.getNetworkConfig().addAddress("127.0.0.1:5701", "127.0.0.1:5702");
        
        // Client connection
        HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig);
        
        // Access distributed map
        IMap<String, String> map = client.getMap("example-map");
        map.put("key1", "value1");
        
        System.out.println("Value: " + map.get("key1"));
        
        client.shutdown();
    }
}

Utilizing Distributed Data Structures

// Example using multiple data structures
import com.hazelcast.core.*;
import com.hazelcast.collection.IQueue;
import com.hazelcast.topic.ITopic;
import com.hazelcast.cp.IAtomicLong;

public class DistributedDataStructures {
    public static void main(String[] args) {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        
        // Distributed queue
        IQueue<String> queue = hz.getQueue("task-queue");
        queue.put("task1");
        queue.put("task2");
        String task = queue.take(); // Blocking operation
        
        // Distributed topic (Pub/Sub)
        ITopic<String> topic = hz.getTopic("notifications");
        topic.addMessageListener(message -> {
            System.out.println("Received: " + message.getMessageObject());
        });
        topic.publish("New notification");
        
        // Distributed atomic variable
        IAtomicLong counter = hz.getCPSubsystem().getAtomicLong("global-counter");
        long newValue = counter.incrementAndGet();
        System.out.println("Counter: " + newValue);
        
        // Distributed lock
        FencedLock lock = hz.getCPSubsystem().getLock("shared-resource");
        lock.lock();
        try {
            // Critical section
            System.out.println("Exclusive access to resource");
        } finally {
            lock.unlock();
        }
        
        hz.shutdown();
    }
}

Detailed Configuration with Configuration File

<!-- hazelcast.xml -->
<hazelcast xmlns="http://www.hazelcast.com/schema/config"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.hazelcast.com/schema/config 
           http://www.hazelcast.com/schema/config/hazelcast-config-5.4.xsd">
    
    <cluster-name>production-cluster</cluster-name>
    
    <network>
        <port auto-increment="true" port-count="20">5701</port>
        <join>
            <multicast enabled="false"/>
            <tcp-ip enabled="true">
                <member>192.168.1.100</member>
                <member>192.168.1.101</member>
                <member>192.168.1.102</member>
            </tcp-ip>
        </join>
    </network>
    
    <map name="customer-cache">
        <backup-count>1</backup-count>
        <eviction eviction-policy="LRU" max-size-policy="PER_NODE" size="10000"/>
        <time-to-live-seconds>300</time-to-live-seconds>
    </map>
    
    <cp-subsystem>
        <cp-member-count>3</cp-member-count>
        <group-size>3</group-size>
    </cp-subsystem>
    
</hazelcast>

Practical Example (Cache Integration)

// Spring application cache integration example
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    
    @Cacheable(value = "users", key = "#userId")
    public User getUserById(Long userId) {
        // Retrieve user information from database (heavy operation)
        return userRepository.findById(userId);
    }
    
    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

// Hazelcast configuration
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        return new HazelcastCacheManager(hazelcastInstance());
    }
    
    @Bean
    public HazelcastInstance hazelcastInstance() {
        Config config = new Config();
        config.getMapConfig("users")
              .setTimeToLiveSeconds(3600)
              .setBackupCount(1);
        return Hazelcast.newHazelcastInstance(config);
    }
}

Best Practices

// Production configuration example
import com.hazelcast.config.*;

public class ProductionConfig {
    public static Config createProductionConfig() {
        Config config = new Config();
        
        // Cluster name
        config.setClusterName("production-cluster");
        
        // Network configuration
        NetworkConfig network = config.getNetworkConfig();
        network.setPort(5701).setPortAutoIncrement(true);
        
        // Security configuration
        SecurityConfig security = config.getSecurityConfig();
        security.setEnabled(true);
        
        // Enable metrics
        MetricsConfig metrics = config.getMetricsConfig();
        metrics.setEnabled(true)
               .setCollectionFrequencySeconds(5)
               .setJmxConfig(new MetricsJmxConfig().setEnabled(true));
        
        // Management center configuration
        ManagementCenterConfig mcConfig = config.getManagementCenterConfig();
        mcConfig.setConsoleEnabled(true)
                .addTrustedInterface("192.168.1.*");
        
        // Map configuration (TTL and backup)
        MapConfig mapConfig = new MapConfig("session-cache");
        mapConfig.setTimeToLiveSeconds(1800)  // 30 min TTL
                 .setBackupCount(1)
                 .setAsyncBackupCount(1)
                 .setReadBackupData(true);
        
        config.addMapConfig(mapConfig);
        
        return config;
    }
}

CLI Operations and Monitoring

# Using Hazelcast CLI tools
hz-cli

# Check cluster information
hz-cli cluster list

# Display map statistics
hz-cli map stats -n myMap

# Check cluster members
hz-cli member list

# Execute SQL queries
hz-cli sql "SELECT * FROM customers WHERE age > 25"

// JMX-based monitoring
import javax.management.MBeanServer;
import javax.management.ObjectName;
import java.lang.management.ManagementFactory;

public class HazelcastMonitoring {
    public void printMapStatistics(String mapName) {
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            ObjectName objectName = new ObjectName(
                "com.hazelcast:instance=_hzInstance_1_dev,type=IMap,name=" + mapName
            );
            
            long size = (Long) server.getAttribute(objectName, "Size");
            long hits = (Long) server.getAttribute(objectName, "Hits");
            long misses = (Long) server.getAttribute(objectName, "Misses");
            
            System.out.println("Map: " + mapName);
            System.out.println("Size: " + size);
            System.out.println("Hits: " + hits);
            System.out.println("Misses: " + misses);
            System.out.println("Hit Rate: " + (hits * 100.0 / (hits + misses)) + "%");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}