tessl/maven-com-hazelcast--hazelcast

In-memory distributed computing platform for real-time stream processing and data storage with SQL capabilities

—

Pending

Overview

Eval results

Files

Configuration

Name: tessl/maven-com-hazelcast--hazelcast
Author: tessl

Hazelcast provides a comprehensive configuration system that supports programmatic configuration, XML files, YAML files, and environment variables. The configuration system is hierarchical and allows fine-grained control over all aspects of cluster behavior.

Main Configuration Classes

Config Class

The main configuration class for Hazelcast server instances.

import com.hazelcast.config.Config;
import com.hazelcast.config.NetworkConfig;
import com.hazelcast.config.MapConfig;
import com.hazelcast.config.QueueConfig;
import com.hazelcast.config.SerializationConfig;
import com.hazelcast.config.SecurityConfig;
import java.util.Map;
import java.util.Properties;

public class Config {
    // Instance and cluster identification
    public Config setInstanceName(String instanceName);
    public String getInstanceName();
    
    public Config setClusterName(String clusterName);
    public String getClusterName();
    
    // Network configuration
    public NetworkConfig getNetworkConfig();
    public Config setNetworkConfig(NetworkConfig networkConfig);
    
    // Data structure configurations
    public Map<String, MapConfig> getMapConfigs();
    public Config addMapConfig(MapConfig mapConfig);
    public MapConfig getMapConfig(String name);
    
    public Map<String, QueueConfig> getQueueConfigs();
    public Config addQueueConfig(QueueConfig queueConfig);
    public QueueConfig getQueueConfig(String name);
    
    // Advanced configurations
    public SerializationConfig getSerializationConfig();
    public Config setSerializationConfig(SerializationConfig serializationConfig);
    
    public SecurityConfig getSecurityConfig();
    public Config setSecurityConfig(SecurityConfig securityConfig);
    
    // Properties and system properties
    public Properties getProperties();
    public Config setProperties(Properties properties);
    public Config setProperty(String name, String value);
    public String getProperty(String name);
    
    // License key
    public Config setLicenseKey(String licenseKey);
    public String getLicenseKey();
    
    // User context
    public ConcurrentMap<String, Object> getUserContext();
    
    // Configuration loading
    public static Config load();
    public static Config loadFromFile(File configurationFile);
    public static Config loadFromStream(InputStream inputStream);
}

ClientConfig Class

Configuration for Hazelcast client instances.

import com.hazelcast.client.config.ClientConfig;
import com.hazelcast.client.config.ClientNetworkConfig;
import com.hazelcast.client.config.ClientSecurityConfig;
import com.hazelcast.client.config.ClientConnectionStrategyConfig;

public class ClientConfig {
    // Instance identification
    public ClientConfig setInstanceName(String instanceName);
    public String getInstanceName();
    
    public ClientConfig setClusterName(String clusterName);
    public String getClusterName();
    
    // Network configuration
    public ClientNetworkConfig getNetworkConfig();
    public ClientConfig setNetworkConfig(ClientNetworkConfig networkConfig);
    
    // Security configuration
    public ClientSecurityConfig getSecurityConfig();
    public ClientConfig setSecurityConfig(ClientSecurityConfig securityConfig);
    
    // Connection strategy
    public ClientConnectionStrategyConfig getConnectionStrategyConfig();
    public ClientConfig setConnectionStrategyConfig(ClientConnectionStrategyConfig connectionStrategyConfig);
    
    // Properties
    public Properties getProperties();
    public ClientConfig setProperties(Properties properties);
    public ClientConfig setProperty(String name, String value);
    
    // Labels (for client identification)
    public Set<String> getLabels();
    public ClientConfig setLabels(Set<String> labels);
    public ClientConfig addLabel(String label);
    
    // User context
    public ConcurrentMap<String, Object> getUserContext();
}

Basic Configuration Examples

Programmatic Server Configuration

Config config = new Config();

// Basic instance settings
config.setInstanceName("my-hazelcast-server");
config.setClusterName("production-cluster");

// Set properties
config.setProperty("hazelcast.logging.type", "slf4j");
config.setProperty("hazelcast.operation.call.timeout.millis", "30000");

// Create instance
HazelcastInstance hz = Hazelcast.newHazelcastInstance(config);

Programmatic Client Configuration

ClientConfig clientConfig = new ClientConfig();

// Basic client settings
clientConfig.setInstanceName("my-client");
clientConfig.setClusterName("production-cluster");

// Network settings
clientConfig.getNetworkConfig()
           .addAddress("192.168.1.100:5701", "192.168.1.101:5701")
           .setSmartRouting(true)
           .setRedoOperation(true)
           .setConnectionTimeout(5000);

// Labels for client identification
clientConfig.addLabel("web-server")
           .addLabel("region:us-east-1");

// Create client
HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig);

Network Configuration

NetworkConfig Class

Controls network behavior including ports, interfaces, and join mechanisms.

import com.hazelcast.config.NetworkConfig;
import com.hazelcast.config.JoinConfig;
import com.hazelcast.config.InterfacesConfig;
import com.hazelcast.config.SocketInterceptorConfig;
import java.util.Collection;

public class NetworkConfig {
    // Port configuration
    public NetworkConfig setPort(int port);
    public int getPort();
    
    public NetworkConfig setPortAutoIncrement(boolean portAutoIncrement);
    public boolean isPortAutoIncrement();
    
    public NetworkConfig setPortCount(int portCount);
    public int getPortCount();
    
    // Network interfaces
    public InterfacesConfig getInterfaces();
    public NetworkConfig setInterfaces(InterfacesConfig interfaces);
    
    // Join configuration
    public JoinConfig getJoin();
    public NetworkConfig setJoin(JoinConfig join);
    
    // Public address (for cloud/NAT environments)
    public NetworkConfig setPublicAddress(String publicAddress);
    public String getPublicAddress();
    
    // Socket options
    public SocketInterceptorConfig getSocketInterceptorConfig();
    public NetworkConfig setSocketInterceptorConfig(SocketInterceptorConfig socketInterceptorConfig);
    
    // SSL/TLS
    public SSLConfig getSSLConfig();
    public NetworkConfig setSSLConfig(SSLConfig sslConfig);
}

Join Configuration

import com.hazelcast.config.JoinConfig;
import com.hazelcast.config.MulticastConfig;
import com.hazelcast.config.TcpIpConfig;
import com.hazelcast.config.AwsConfig;

public class JoinConfig {
    // Multicast discovery
    public MulticastConfig getMulticastConfig();
    public JoinConfig setMulticastConfig(MulticastConfig multicastConfig);
    
    // TCP/IP discovery
    public TcpIpConfig getTcpIpConfig();
    public JoinConfig setTcpIpConfig(TcpIpConfig tcpIpConfig);
    
    // Cloud discovery
    public AwsConfig getAwsConfig();
    public JoinConfig setAwsConfig(AwsConfig awsConfig);
    
    public GcpConfig getGcpConfig();
    public JoinConfig setGcpConfig(GcpConfig gcpConfig);
    
    public AzureConfig getAzureConfig();
    public JoinConfig setAzureConfig(AzureConfig azureConfig);
    
    public KubernetesConfig getKubernetesConfig();
    public JoinConfig setKubernetesConfig(KubernetesConfig kubernetesConfig);
    
    // Auto-detection
    public DiscoveryConfig getDiscoveryConfig();
    public JoinConfig setDiscoveryConfig(DiscoveryConfig discoveryConfig);
}

Network Configuration Examples

Config config = new Config();
NetworkConfig network = config.getNetworkConfig();

// Basic network settings
network.setPort(5701)
       .setPortAutoIncrement(true)
       .setPortCount(20);

// Interface restrictions
network.getInterfaces()
       .setEnabled(true)
       .addInterface("192.168.1.*")
       .addInterface("10.0.0.*");

// TCP/IP cluster discovery
JoinConfig join = network.getJoin();
join.getMulticastConfig().setEnabled(false);
join.getTcpIpConfig()
    .setEnabled(true)
    .addMember("192.168.1.100")
    .addMember("192.168.1.101")
    .addMember("192.168.1.102");

// Public address for cloud environments
network.setPublicAddress("203.0.113.1:5701");

// AWS discovery
join.getAwsConfig()
    .setEnabled(true)
    .setProperty("access-key", "your-access-key")
    .setProperty("secret-key", "your-secret-key")
    .setProperty("region", "us-east-1")
    .setProperty("tag-key", "hazelcast-cluster")
    .setProperty("tag-value", "production");

// Kubernetes discovery
join.getKubernetesConfig()
    .setEnabled(true)
    .setProperty("namespace", "hazelcast")
    .setProperty("service-name", "hazelcast-service");

Data Structure Configuration

Map Configuration

import com.hazelcast.config.MapConfig;
import com.hazelcast.config.EvictionConfig;
import com.hazelcast.config.IndexConfig;
import com.hazelcast.config.MapStoreConfig;
import com.hazelcast.config.NearCacheConfig;

public class MapConfig {
    // Basic settings
    public MapConfig setName(String name);
    public String getName();
    
    // Backup configuration
    public MapConfig setBackupCount(int backupCount);
    public int getBackupCount();
    
    public MapConfig setAsyncBackupCount(int asyncBackupCount);
    public int getAsyncBackupCount();
    
    // TTL and idle time
    public MapConfig setTimeToLiveSeconds(int timeToLiveSeconds);
    public int getTimeToLiveSeconds();
    
    public MapConfig setMaxIdleSeconds(int maxIdleSeconds);
    public int getMaxIdleSeconds();
    
    // Eviction configuration
    public EvictionConfig getEvictionConfig();
    public MapConfig setEvictionConfig(EvictionConfig evictionConfig);
    
    // Indexing
    public List<IndexConfig> getIndexConfigs();
    public MapConfig addIndexConfig(IndexConfig indexConfig);
    
    // Map store (persistence)
    public MapStoreConfig getMapStoreConfig();
    public MapConfig setMapStoreConfig(MapStoreConfig mapStoreConfig);
    
    // Near cache
    public NearCacheConfig getNearCacheConfig();
    public MapConfig setNearCacheConfig(NearCacheConfig nearCacheConfig);
    
    // Read backup data
    public MapConfig setReadBackupData(boolean readBackupData);
    public boolean isReadBackupData();
    
    // Statistics
    public MapConfig setStatisticsEnabled(boolean statisticsEnabled);
    public boolean isStatisticsEnabled();
}

Map Configuration Examples

Config config = new Config();

// User session map configuration
MapConfig sessionMapConfig = new MapConfig("user-sessions");
sessionMapConfig.setBackupCount(2)
               .setTimeToLiveSeconds(1800) // 30 minutes
               .setMaxIdleSeconds(600)     // 10 minutes
               .setStatisticsEnabled(true);

// Eviction configuration
EvictionConfig evictionConfig = new EvictionConfig();
evictionConfig.setEvictionPolicy(EvictionPolicy.LRU)
             .setMaxSizePolicy(MaxSizePolicy.PER_NODE)
             .setSize(10000);
sessionMapConfig.setEvictionConfig(evictionConfig);

config.addMapConfig(sessionMapConfig);

// Product catalog map with indexes
MapConfig productMapConfig = new MapConfig("products");
productMapConfig.setBackupCount(1)
               .setReadBackupData(true);

// Add indexes for better query performance
productMapConfig.addIndexConfig(new IndexConfig(IndexType.HASH, "category"))
               .addIndexConfig(new IndexConfig(IndexType.SORTED, "price"))
               .addIndexConfig(new IndexConfig(IndexType.BITMAP, "inStock"));

config.addMapConfig(productMapConfig);

// Cache map with near cache
MapConfig cacheMapConfig = new MapConfig("cache");
cacheMapConfig.setBackupCount(0) // No backup for cache data
             .setTimeToLiveSeconds(300); // 5 minutes

// Near cache configuration
NearCacheConfig nearCacheConfig = new NearCacheConfig();
nearCacheConfig.setTimeToLiveSeconds(60)
              .setMaxIdleSeconds(30)
              .setInvalidateOnChange(true)
              .setCacheLocalEntries(true);

cacheMapConfig.setNearCacheConfig(nearCacheConfig);
config.addMapConfig(cacheMapConfig);

Queue Configuration

import com.hazelcast.config.QueueConfig;

public class QueueConfig {
    // Basic settings
    public QueueConfig setName(String name);
    public String getName();
    
    // Capacity
    public QueueConfig setMaxSize(int maxSize);
    public int getMaxSize();
    
    // Backup configuration
    public QueueConfig setBackupCount(int backupCount);
    public int getBackupCount();
    
    public QueueConfig setAsyncBackupCount(int asyncBackupCount);
    public int getAsyncBackupCount();
    
    // Empty queue TTL
    public QueueConfig setEmptyQueueTtl(int emptyQueueTtl);
    public int getEmptyQueueTtl();
    
    // Statistics
    public QueueConfig setStatisticsEnabled(boolean statisticsEnabled);
    public boolean isStatisticsEnabled();
    
    // Queue store
    public QueueStoreConfig getQueueStoreConfig();
    public QueueConfig setQueueStoreConfig(QueueStoreConfig queueStoreConfig);
}

Queue Configuration Example

// Task queue configuration
QueueConfig taskQueueConfig = new QueueConfig("task-queue");
taskQueueConfig.setMaxSize(50000)
              .setBackupCount(1)
              .setStatisticsEnabled(true)
              .setEmptyQueueTtl(300); // Remove empty queue after 5 minutes

config.addQueueConfig(taskQueueConfig);

// Priority queue configuration
QueueConfig priorityQueueConfig = new QueueConfig("priority-tasks");
priorityQueueConfig.setMaxSize(10000)
                  .setBackupCount(2); // Higher backup for important tasks

config.addQueueConfig(priorityQueueConfig);

Advanced Configuration

Serialization Configuration

import com.hazelcast.config.SerializationConfig;
import com.hazelcast.config.SerializerConfig;
import com.hazelcast.config.GlobalSerializerConfig;
import com.hazelcast.nio.serialization.ByteOrder;

public class SerializationConfig {
    // Byte order
    public SerializationConfig setByteOrder(ByteOrder byteOrder);
    public ByteOrder getByteOrder();
    
    // Check class definition errors
    public SerializationConfig setCheckClassDefErrors(boolean checkClassDefErrors);
    public boolean isCheckClassDefErrors();
    
    // Portable version
    public SerializationConfig setPortableVersion(int portableVersion);
    public int getPortableVersion();
    
    // Custom serializers
    public SerializationConfig addSerializerConfig(SerializerConfig serializerConfig);
    public Collection<SerializerConfig> getSerializerConfigs();
    
    // Global serializer
    public GlobalSerializerConfig getGlobalSerializerConfig();
    public SerializationConfig setGlobalSerializerConfig(GlobalSerializerConfig globalSerializerConfig);
    
    // Data serializable factories
    public SerializationConfig addDataSerializableFactoryClass(int factoryId, String className);
    public SerializationConfig addDataSerializableFactory(int factoryId, DataSerializableFactory factory);
    
    // Portable factories
    public SerializationConfig addPortableFactoryClass(int factoryId, String className);
    public SerializationConfig addPortableFactory(int factoryId, PortableFactory portableFactory);
    
    // Java serialization filter
    public JavaSerializationFilterConfig getJavaSerializationFilterConfig();
    public SerializationConfig setJavaSerializationFilterConfig(JavaSerializationFilterConfig javaSerializationFilterConfig);
}

Serialization Configuration Example

Config config = new Config();
SerializationConfig serializationConfig = config.getSerializationConfig();

// Custom serializer for User class
SerializerConfig userSerializerConfig = new SerializerConfig();
userSerializerConfig.setTypeClass(User.class)
                   .setImplementation(new UserSerializer());

serializationConfig.addSerializerConfig(userSerializerConfig);

// Portable factory for cross-platform compatibility
serializationConfig.addPortableFactory(1, new MyPortableFactory());

// Java serialization filter for security
JavaSerializationFilterConfig filterConfig = new JavaSerializationFilterConfig();
filterConfig.setDefaultsDisabled(false);
serializationConfig.setJavaSerializationFilterConfig(filterConfig);

config.setSerializationConfig(serializationConfig);

Security Configuration

import com.hazelcast.config.SecurityConfig;
import com.hazelcast.config.CredentialsFactoryConfig;
import com.hazelcast.config.LoginModuleConfig;
import com.hazelcast.config.PermissionConfig;

public class SecurityConfig {
    // Enable/disable security
    public SecurityConfig setEnabled(boolean enabled);
    public boolean isEnabled();
    
    // Credentials factory
    public CredentialsFactoryConfig getCredentialsFactoryConfig();
    public SecurityConfig setCredentialsFactoryConfig(CredentialsFactoryConfig credentialsFactoryConfig);
    
    // JAAS login modules
    public List<LoginModuleConfig> getLoginModuleConfigs();
    public SecurityConfig addLoginModuleConfig(LoginModuleConfig loginModuleConfig);
    
    // Permissions
    public Set<PermissionConfig> getClientPermissionConfigs();
    public SecurityConfig addClientPermissionConfig(PermissionConfig permissionConfig);
    
    // Security interceptor
    public SecurityConfig setSecurityInterceptorConfig(SecurityInterceptorConfig securityInterceptorConfig);
    
    // Client block/unblock
    public SecurityConfig setClientBlockUnmappedActions(boolean clientBlockUnmappedActions);
    public boolean getClientBlockUnmappedActions();
}

Security Configuration Example

Config config = new Config();
SecurityConfig securityConfig = config.getSecurityConfig();
securityConfig.setEnabled(true);

// Simple credentials factory
CredentialsFactoryConfig credentialsFactory = new CredentialsFactoryConfig();
credentialsFactory.setClassName("com.example.MyCredentialsFactory");
securityConfig.setCredentialsFactoryConfig(credentialsFactory);

// LDAP login module
LoginModuleConfig loginModuleConfig = new LoginModuleConfig();
loginModuleConfig.setClassName("com.sun.security.auth.module.LdapLoginModule")
                .setUsage(LoginModuleConfig.LoginModuleUsage.REQUIRED);

loginModuleConfig.getProperties().put("userProvider", "ldap://ldap.example.com/ou=People,dc=example,dc=com");
loginModuleConfig.getProperties().put("authzIdentity", "{USERNAME}@example.com");

securityConfig.addLoginModuleConfig(loginModuleConfig);

// Permission configuration
PermissionConfig mapPermission = new PermissionConfig(PermissionConfig.PermissionType.MAP, "sensitive-data", "admin-role");
mapPermission.addAction("read").addAction("create").addAction("destroy");

securityConfig.addClientPermissionConfig(mapPermission);

config.setSecurityConfig(securityConfig);

Configuration Loading

XML Configuration

<?xml version="1.0" encoding="UTF-8"?>
<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.5.xsd">
    
    <instance-name>production-instance</instance-name>
    <cluster-name>production-cluster</cluster-name>
    
    <properties>
        <property name="hazelcast.logging.type">slf4j</property>
        <property name="hazelcast.operation.call.timeout.millis">30000</property>
    </properties>
    
    <network>
        <port auto-increment="true" port-count="20">5701</port>
        <interfaces enabled="true">
            <interface>192.168.1.*</interface>
        </interfaces>
        
        <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="user-sessions">
        <backup-count>2</backup-count>
        <time-to-live-seconds>1800</time-to-live-seconds>
        <max-idle-seconds>600</max-idle-seconds>
        <statistics-enabled>true</statistics-enabled>
        
        <eviction eviction-policy="LRU" max-size-policy="PER_NODE" size="10000"/>
        
        <indexes>
            <index type="HASH">userId</index>
            <index type="SORTED">lastAccessTime</index>
        </indexes>
    </map>
    
    <queue name="task-queue">
        <max-size>50000</max-size>
        <backup-count>1</backup-count>
        <statistics-enabled>true</statistics-enabled>
    </queue>
    
</hazelcast>

YAML Configuration

hazelcast:
  instance-name: production-instance
  cluster-name: production-cluster
  
  properties:
    hazelcast.logging.type: slf4j
    hazelcast.operation.call.timeout.millis: 30000
  
  network:
    port:
      auto-increment: true
      port: 5701
      port-count: 20
    
    interfaces:
      enabled: true
      interfaces:
        - 192.168.1.*
    
    join:
      multicast:
        enabled: false
      tcp-ip:
        enabled: true
        members:
          - 192.168.1.100
          - 192.168.1.101
          - 192.168.1.102
  
  map:
    user-sessions:
      backup-count: 2
      time-to-live-seconds: 1800
      max-idle-seconds: 600
      statistics-enabled: true
      eviction:
        eviction-policy: LRU
        max-size-policy: PER_NODE
        size: 10000
      indexes:
        - type: HASH
          attributes:
            - userId
        - type: SORTED
          attributes:
            - lastAccessTime
  
  queue:
    task-queue:
      max-size: 50000
      backup-count: 1
      statistics-enabled: true

Loading Configuration Files

// Load from classpath
Config config = Config.load();

// Load from specific file
Config config = Config.loadFromFile(new File("/path/to/hazelcast.xml"));
Config config = Config.loadFromFile(new File("/path/to/hazelcast.yaml"));

// Load from stream
try (InputStream inputStream = getClass().getResourceAsStream("/hazelcast-config.xml")) {
    Config config = Config.loadFromStream(inputStream);
}

// Client configuration loading
ClientConfig clientConfig = ClientConfig.load();
ClientConfig clientConfig = ClientConfig.loadFromFile(new File("/path/to/hazelcast-client.xml"));

Environment-Based Configuration

System Properties and Environment Variables

// System properties
System.setProperty("hazelcast.config", "/path/to/hazelcast.xml");
System.setProperty("hazelcast.logging.type", "slf4j");

// Environment variables
// HAZELCAST_CONFIG=/path/to/hazelcast.xml
// HAZELCAST_LOGGING_TYPE=slf4j

// Programmatic property override
Config config = new Config();
config.setProperty("hazelcast.logging.type", "slf4j");
config.setProperty("hazelcast.operation.call.timeout.millis", "60000");

// Instance name from environment
String instanceName = System.getenv("HAZELCAST_INSTANCE_NAME");
if (instanceName != null) {
    config.setInstanceName(instanceName);
}

Configuration Replacers

// Using placeholders in configuration
Config config = new Config();
config.setClusterName("${cluster.name}");

// Add configuration replacer
config.getConfigurationFile(); // This enables property replacement

// In XML configuration:
/*
<cluster-name>${CLUSTER_NAME:default-cluster}</cluster-name>
<network>
    <port>${HAZELCAST_PORT:5701}</port>
</network>
*/

Dynamic Configuration

Runtime Configuration Updates

// Note: Not all configurations can be changed at runtime
// This example shows what CAN be changed dynamically

HazelcastInstance hz = Hazelcast.newHazelcastInstance();

// Add new map configuration at runtime
MapConfig runtimeMapConfig = new MapConfig("runtime-map");
runtimeMapConfig.setBackupCount(1);
hz.getConfig().addMapConfig(runtimeMapConfig);

// Get existing configuration
Config currentConfig = hz.getConfig();
MapConfig existingMapConfig = currentConfig.getMapConfig("user-sessions");
System.out.println("Current backup count: " + existingMapConfig.getBackupCount());

// Some configurations require restart
// Network settings, cluster name, etc. cannot be changed at runtime

Configuration Validation

public class ConfigValidator {
    
    public static void validateConfig(Config config) {
        // Validate cluster name
        if (config.getClusterName() == null || config.getClusterName().trim().isEmpty()) {
            throw new IllegalArgumentException("Cluster name cannot be empty");
        }
        
        // Validate network configuration
        NetworkConfig network = config.getNetworkConfig();
        if (network.getPort() < 1024 || network.getPort() > 65535) {
            throw new IllegalArgumentException("Invalid port number: " + network.getPort());
        }
        
        // Validate map configurations
        for (MapConfig mapConfig : config.getMapConfigs().values()) {
            validateMapConfig(mapConfig);
        }
        
        System.out.println("Configuration validation passed");
    }
    
    private static void validateMapConfig(MapConfig mapConfig) {
        if (mapConfig.getBackupCount() + mapConfig.getAsyncBackupCount() > 6) {
            throw new IllegalArgumentException(
                "Total backup count cannot exceed 6 for map: " + mapConfig.getName());
        }
        
        if (mapConfig.getTimeToLiveSeconds() < 0) {
            throw new IllegalArgumentException(
                "TTL cannot be negative for map: " + mapConfig.getName());
        }
    }
}

// Usage
try {
    Config config = new Config();
    // ... configure
    
    ConfigValidator.validateConfig(config);
    HazelcastInstance hz = Hazelcast.newHazelcastInstance(config);
} catch (IllegalArgumentException e) {
    System.err.println("Configuration error: " + e.getMessage());
}

Configuration Best Practices

Production Configuration Template

public class ProductionConfigBuilder {
    
    public static Config buildProductionConfig(String clusterName, String instanceName) {
        Config config = new Config();
        
        // Basic settings
        config.setClusterName(clusterName);
        config.setInstanceName(instanceName);
        
        // Logging
        config.setProperty("hazelcast.logging.type", "slf4j");
        config.setProperty("hazelcast.logging.class", "com.hazelcast.logging.Slf4jFactory");
        
        // Operation timeouts
        config.setProperty("hazelcast.operation.call.timeout.millis", "60000");
        config.setProperty("hazelcast.operation.backup.timeout.millis", "5000");
        
        // Health monitoring
        config.setProperty("hazelcast.health.monitoring.level", "SILENT");
        config.setProperty("hazelcast.health.monitoring.delay.seconds", "30");
        
        // Network configuration
        NetworkConfig network = config.getNetworkConfig();
        network.setPort(5701)
               .setPortAutoIncrement(true)
               .setPortCount(100);
        
        // Security hardening
        network.getRestApiConfig().setEnabled(false);
        network.getMemcacheProtocolConfig().setEnabled(false);
        
        // Default map configuration
        MapConfig defaultMapConfig = config.getMapConfig("default");
        defaultMapConfig.setBackupCount(1)
                       .setAsyncBackupCount(0)
                       .setReadBackupData(false)
                       .setStatisticsEnabled(true);
        
        return config;
    }
    
    public static ClientConfig buildProductionClientConfig(String clusterName) {
        ClientConfig clientConfig = new ClientConfig();
        
        clientConfig.setClusterName(clusterName);
        
        // Connection settings
        clientConfig.getConnectionStrategyConfig()
                   .setAsyncStart(false)
                   .setReconnectMode(ClientConnectionStrategyConfig.ReconnectMode.ON)
                   .getConnectionRetryConfig()
                   .setInitialBackoffMillis(1000)
                   .setMaxBackoffMillis(30000)
                   .setMultiplier(2.0)
                   .setClusterConnectTimeoutMillis(20000);
        
        // Network settings
        clientConfig.getNetworkConfig()
                   .setSmartRouting(true)
                   .setRedoOperation(true)
                   .setConnectionTimeout(5000);
        
        // Labels for identification
        clientConfig.addLabel("production-client");
        
        return clientConfig;
    }
}

// Usage
Config serverConfig = ProductionConfigBuilder.buildProductionConfig("prod-cluster", "server-1");
ClientConfig clientConfig = ProductionConfigBuilder.buildProductionClientConfig("prod-cluster");

Configuration for Different Environments

public class EnvironmentConfigBuilder {
    
    public static Config forDevelopment() {
        Config config = new Config();
        config.setClusterName("dev-cluster");
        
        // Multicast for easy local discovery
        config.getNetworkConfig().getJoin()
              .getMulticastConfig().setEnabled(true)
              .getTcpIpConfig().setEnabled(false);
        
        // Minimal backup for faster development
        config.getMapConfig("default").setBackupCount(0);
        
        // Verbose logging for debugging
        config.setProperty("hazelcast.logging.type", "slf4j");
        
        return config;
    }
    
    public static Config forTesting() {
        Config config = new Config();
        config.setClusterName("test-cluster");
        
        // Disable network for unit tests
        config.getNetworkConfig().getJoin()
              .getMulticastConfig().setEnabled(false)
              .getTcpIpConfig().setEnabled(false);
        
        // Fast shutdown for tests
        config.setProperty("hazelcast.shutdownhook.enabled", "false");
        config.setProperty("hazelcast.graceful.shutdown.max.wait", "5");
        
        return config;
    }
    
    public static Config forProduction(String region) {
        Config config = new Config();
        config.setClusterName("prod-cluster-" + region);
        
        // Cloud discovery configuration
        config.getNetworkConfig().getJoin()
              .getMulticastConfig().setEnabled(false)
              .getAwsConfig().setEnabled(true)
              .setProperty("region", region)
              .setProperty("tag-key", "hazelcast-cluster")
              .setProperty("tag-value", "production");
        
        // Production-level backup and durability
        config.getMapConfig("default")
              .setBackupCount(2)
              .setAsyncBackupCount(1)
              .setReadBackupData(true);
        
        // Security enabled
        config.getSecurityConfig().setEnabled(true);
        
        return config;
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-com-hazelcast--hazelcast

docs

cluster-management.md