Category: hazelcast

Hazelcast – Configuration ”; Previous Next Hazelcast supports programmatic as well as XML-based configuration. However, it is the XML configuration which is heavily used in production, given its ease of use. But XML configuration internally uses the Programmatic configuration. XML Configuration The hazelcast.xml is where these configurations need to be placed. The file is searched for in the following location (in same order) and is chosen from the first available location − Passing the location of the XML to the JVM via the system property – Dhazelcast.config=/path/to/hazelcast.xml hazelcast.xml in the current working directory hazelcast.xml in the classpath default hazelcast.xml provided by Hazelcast Once the XML is found, Hazelcast would load the required configuration from the XML file. Let”s try that out with an example. Create an XML in your current directory with the name hazelcast.xml. <hazelcast xsi:schemaLocation=”http://www.hazelcast.com/schema/config http://www.hazelcast.com/schema/config/hazelcast-config-3.12.12.xsd” xmlns=”http://www.hazelcast.com/schema/config” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”> <!– name of the instance –> <instance-name>XML_Hazelcast_Instance</instance-name> </hazelcast> The XML as of now only contains the schema location of the Hazelcast XML which is used for validation. But more importantly, it contains the instance name. Example Now create an XMLConfigLoadExample.java file with the following content. package com.example.demo; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; public class XMLConfigLoadExample { public static void main(String… args) throws InterruptedException{ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); //specified the name written in the XML file System.out.println(String.format(“Name of the instance: %s”,hazelcast.getName())); //perform a graceful shutdown hazelcast.shutdown(); } } Execute the above Java file with the following command − java -Dhazelcast.config=hazelcast.xml -cp .targetdemo-0.0.1-SNAPSHOT.jar com.example.demo.XMLConfigLoadExample Output The output for above command would be − Jan 30, 2021 1:21:41 PM com.hazelcast.config.XmlConfigLocator INFO: Loading configuration hazelcast.xml from System property ”hazelcast.config” Jan 30, 2021 1:21:41 PM com.hazelcast.config.XmlConfigLocator INFO: Using configuration file at C:Usersdemoeclipseworkspace hazelcasthazelcast.xml … Members {size:1, ver:1} [ Member [localhost]:5701 – 3d400aed-ddb9-4e59-9429-3ab7773e7e09 this ] Name of cluster: XML_Hazelcast_Instance As you see, Hazelcast loaded the configuration and printed the name which was specified in the configuration (last line). There are a whole lot of configuration options which can be specified in the XML. The complete list can be found at − https://github.com/hazelcast/hazelcast/blob/master/hazelcast/src/main/resources/hazelcast-full-example.xml We will see a few of these configurations as we move along the tutorial. Programmatic Configuration As stated earlier, XML configuration is ultimately done via programmatic configuration. So, let’s try programmatic configuration for the same example which we saw in XML configuration. For that, let’s create the ProgramaticConfigLoadExample.java file with the following content. Example package com.example.demo; import com.hazelcast.config.Config; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; public class ProgramaticConfigLoadExample { public static void main(String… args) throws InterruptedException { Config config = new Config(); config.setInstanceName(“Programtic_Hazelcast_Instance”); // initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(config); // specified the name written in the XML file System.out.println(String.format(“Name of the instance: %s”, hazelcast.getName())); // perform a graceful shutdown hazelcast.shutdown(); } } Let’s execute the code without passing any hazelcast.xml file by − java -cp .targetdemo-0.0.1-SNAPSHOT.jar com.example.demo.ProgramaticConfigLoadExample Output The output of the above code is − Name of the instance: Programtic_Hazelcast_Instance Logging To avoid dependencies, Hazelcast by default uses JDK based logging. But it also supports logging via slf4j, log4j. For example, if we want to setup logging via for sl4j with logback, we can update the POM to contain the following dependencies − <!– contains both sl4j bindings and the logback core –> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.3</version> </dependency> Example Define a configuration logback.xml file and add it to your classpath, for example, src/main/resources. <configuration> <appender name=”STDOUT” class=”ch.qos.logback.core.ConsoleAppender”> <encoder> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} – %msg%n</pattern> </encoder> </appender> <root level=”info”> <appender-ref ref=”STDOUT” /> </root> <logger name=”com.hazelcast” level=”error”> <appender-ref ref=”STDOUT” /> </logger> </configuration> Now, when we execute the following command, we notice that all the meta information about the Hazelcast member creation etc. is not printed. And this is because we have set the logging level for Hazelcast to error and asked Hazelcast to use sl4j logger. java -Dhazelcast.logging.type=slf4j -cp .targetdemo-0.0.1-SNAPSHOT.jar com.example.demo.SingleInstanceHazelcastExample Output John Variables Value written to XML configuration files can vary based on the environment. For example, in production, you may use a different username/password for connecting to the Hazelcast cluster compared to the dev environment. Instead of maintaining separate XML files, one can also write variables in the XML files and then pass those variables via command line or programmatically to Hazelcast. Here is an example for choosing the name of the instance from the command line. So, here is our XML file with the variable ${varname} <hazelcast xsi:schemaLocation=”http://www.hazelcast.com/schema/config http://www.hazelcast.com/schema/config/hazelcast-config-3.12.12.xsd” xmlns=”http://www.hazelcast.com/schema/config” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”> <instance-name>${instance_name}</instance-name> </hazelcast> Example And here is the sample Java code we would use to print the variable value − package com.example.demo; import java.util.Map; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; public class XMLConfigLoadWithVariable { public static void main(String… args) throws InterruptedException { // initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); // specified the name written in the XML file System.out.println(String.format(“Name of the instance: %s”, hazelcast.getName())); // perform a graceful shutdown hazelcast.shutdown(); } } And, following is the command − java -Dhazelcast.config=othershazelcast.xml -Dinstance_name=dev_cluster -cp .targetdemo-0.0.1-SNAPSHOT.jar com.example.demo.XMLConfigLoadWithVariable Output And the output shows that the variable was replaced by Hazelcast correctly. Name of the instance: dev_cluster Print Page Previous Next Advertisements ”;

Hazelcast – Setup ”; Previous Next Hazelcast requires Java 1.6 or above. Hazelcast can also be used with .NET, C++, or other JVM based languages like Scala and Clojure. However, for this tutorial, we are going to use Java 8. Before we move on, following is the project setup that we will use for this tutorial. hazelcast/ ├── com.example.demo/ │ ├── SingleInstanceHazelcastExample.java │ ├── MultiInstanceHazelcastExample.java │ ├── Server.java │ └── …. ├── pom.xml ├── target/ ├── hazelcast.xml ├── hazelcast-multicast.xml ├── … For now, we can just create the package, i.e., com.example.demo inside the hazelcast directory. Then, just cd to that directory. We will look at other files in the upcoming sections. Installing Hazelcast Installing Hazelcast simply involves adding a JAR file to your build file. POM file or build.gradle based on whether you are using Maven or Gradle respectively. If you are using Gradle, adding the following to build.gradle file would be enough − dependencies { compile “com.hazelcast:hazelcast:3.12.12” } POM for the tutorial We will use the following POM for our tutorial − <?xml version=”1.0″ encoding=”UTF-8″?> <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>1.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>demo</name> <description>Demo project for Hazelcast</description> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>com.hazelcast</groupId> <artifactId>hazelcast</artifactId> <version>3.12.12</version> </dependency> </dependencies> <!– Below build plugin is not needed for Hazelcast, it is being used only to created a shaded JAR so that –> <!– using the output i.e. the JAR becomes simple for testing snippets in the tutorial–> <build> <plugins> <plugin> <!– Create a shaded JAR and specify the entry point class–> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.2.4</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project> Print Page Previous Next Advertisements ”;

Hazelcast – Spring Integration ”; Previous Next Hazelcast supports an easy way to integrate with Spring Boot application. Let”s try to understand that via an example. We will create a simple API application which provides an API to get employee information for a company. For this purpose, we will use Spring Boot driven RESTController along with Hazelcast for caching data. Note that to integrate Hazelcast in Spring Boot, we will need two things − Add Hazelcast as a dependency to our project. Define a configuration (static or programmatic) and make it available to Hazelcast Let’s first define the POM. Note that we have to specify Hazelcast JAR to use it in the Spring Boot project. <?xml version=”1.0″ encoding=”UTF-8″?> <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>hazelcast</artifactId> <version>0.0.1-SNAPSHOT</version> <name>demo</name> <description>Demo project to explain Hazelcast integration with Spring Boot</description> <properties> <maven.compiler.target>1.8</maven.compiler.target> <maven.compiler.source>1.8</maven.compiler.source> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.0</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <dependency> <groupId>com.hazelcast</groupId> <artifactId>hazelcast-all</artifactId> <version>4.0.2</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> Also add hazelcast.xml to src/main/resources − <hazelcast xsi:schemaLocation=”http://www.hazelcast.com/schema/config http://www.hazelcast.com/schema/config/hazelcast-config-3.12.12.xsd” xmlns=”http://www.hazelcast.com/schema/config” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”> <instance-name>XML_Hazelcast_Instance</instance-name> </hazelcast> Define an entry point file for Spring Boot to use. Ensure that we have @EnableCaching specified − package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cache.annotation.EnableCaching; @EnableCaching @SpringBootApplication public class CompanyApplication { public static void main(String[] args) { SpringApplication.run(CompanyApplication.class, args); } } Let us define our employee POJO − package com.example.demo; import java.io.Serializable; public class Employee implements Serializable{ private static final long serialVersionUID = 1L; private int empId; private String name; private String department; public Employee(Integer id, String name, String department) { super(); this.empId = id; this.name = name; this.department = department; } public int getEmpId() { return empId; } public void setEmpId(int empId) { this.empId = empId; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDepartment() { return department; } public void setDepartment(String department) { this.department = department; } @Override public String toString() { return “Employee [empId=” + empId + “, name=” + name + “, department=” + department + “]”; } } And ultimately, let us define a basic REST controller to access employee − package com.example.demo; import org.springframework.cache.annotation.Cacheable; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping(“/v1/”) class CompanyApplicationController{ @Cacheable(value = “employee”) @GetMapping(“employee/{id}”) public Employee getSubscriber(@PathVariable(“id”) int id) throws InterruptedException { System.out.println(“Finding employee information with id ” + id + ” …”); Thread.sleep(5000); return new Employee(id, “John Smith”, “CS”); } } Now let us execute the above application, by running the command − mvn clean install mvn spring-boot:run You will notice that the output of the command would contain Hazelcast member information which mean Hazelcast Instance is automatically configured for us using hazelcast.xml configuration. Members {size:1, ver:1} [ Member [localhost]:5701 – 91b3df1d-a226-428a-bb74-6eec0a6abb14 this ] Now let us execute via curl or use browser to access API − curl -X GET http://localhost:8080/v1/employee/5 The output of the API would be our sample employee. { “empId”: 5, “name”: “John Smith”, “department”: “CS” } In the server logs (i.e. where Spring Boot application running), we see the following line − Finding employee information with id 5 … However, note that it takes almost 5 secs (because of sleep we added) to access the information. But If we call the API again, the output of the API is immediate. This is because we have specified @Cacheable notation. The data of our first API call has been cached using Hazelcast as a backend. Print Page Previous Next Advertisements ”;

Hazelcast – Monitoring ”; Previous Next Hazelcast provides multiple ways to monitor the cluster. We will look into how to monitor via REST API and via JMX. Let”s first look into REST API. Monitoring Hazelcast via REST API To monitor health of the cluster or member state via REST API, one has to enable REST API based communication to the members. This can be done by configuration and also programmatically. Let us enable REST based monitoring via XML configuration in hazelcast-monitoring.xml − <hazelcast xsi:schemaLocation=”http://www.hazelcast.com/schema/config http://www.hazelcast.com/schema/config/hazelcast-config-3.12.12.xsd” xmlns=”http://www.hazelcast.com/schema/config” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”> <instance-name>XML_Hazelcast_Instance</instance-name> <network> <rest-api enabled=”true”> <endpoint-group name=”CLUSTER_READ” enabled=”true” /> <endpoint-group name=”HEALTH_CHECK” enabled=”true” /> </rest-api> </network> </hazelcast> Let us create a Hazelcast instance which runs indefinitely in Server.java file − public class Server { public static void main(String… args){ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); // do not shutdown, let the server run //hazelcast.shutdown(); } } And now let us execute start the cluster − java ”-Dhazelcast.config=hazelcast-monitoring.xml” -cp .targetdemo-0.0.1- SNAPSHOT.jar com.example.demo.Server Once started, the health of the cluster can be found out by calling the API like − http://localhost:5701/hazelcast/health The output of the above API call − Hazelcast::NodeState=ACTIVE Hazelcast::ClusterState=ACTIVE Hazelcast::ClusterSafe=TRUE Hazelcast::MigrationQueueSize=0 Hazelcast::ClusterSize=1 This displays that there is 1 member in our cluster and it is Active. More detailed information about the nodes, for example, IP, port, name can be found using − http://localhost:5701/hazelcast/rest/cluster The output of the above API − Members {size:1, ver:1} [ Member [localhost]:5701 – e6afefcb-6b7c-48b3-9ccb-63b4f147d79d this ] ConnectionCount: 1 AllConnectionCount: 2 JMX monitoring Hazelcast also supports JMX monitoring of the data structures embedded inside it, for example, IMap, Iqueue, and so on. To enable JMX monitoring, we first need to enable JVM based JMX agents. This can be done by passing “-Dcom.sun.management.jmxremote” to the JVM. For using different ports or use authentication, we can use -Dcom.sun.management.jmxremote.port, – Dcom.sun.management.jmxremote.authenticate, respectively. Apart from this, we have to enable JMX for Hazelcast MBeans. Let us enable JMX based monitoring via XML configuration in hazelcast-monitoring.xml − <hazelcast xsi:schemaLocation=”http://www.hazelcast.com/schema/config http://www.hazelcast.com/schema/config/hazelcast-config-3.12.12.xsd” xmlns=”http://www.hazelcast.com/schema/config” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”> <instance-name>XML_Hazelcast_Instance</instance-name> <properties> <property name=”hazelcast.jmx”>true</property> </properties> </hazelcast> Let us create a Hazelcast instance which runs indefinitely in Server.java file and add a map − class Server { public static void main(String… args){ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); //create a simple map Map<String, String> vehicleOwners = hazelcast.getMap(“vehicleOwnerMap”); // add key-value to map vehicleOwners.put(“John”, “Honda-9235″); // do not shutdown, let the server run //hazelcast.shutdown(); } } Now we can execute the following command to enable JMX − java ”-Dcom.sun.management.jmxremote” ”-Dhazelcast.config=othershazelcastmonitoring. xml” -cp .targetdemo-0.0.1-SNAPSHOT.jar com.example.demo.Server The JMX ports can now be connected by JMX clients like jConsole, VisualVM, etc. Here is a snapshot of what we will get if we connect using jConsole and see the attributes for VehicleMap. As we can see, the name of the map as vehicleOwnerMap and the size of map being 1. Print Page Previous Next Advertisements ”;

Hazelcast – Serialization ”; Previous Next Hazelcast is ideally used in an environment where data/query are distributed across machines. This requires data to be serialized from our Java objects to a byte array which can be transferred over the network. Hazelcast supports various types of Serialization. However, let’s look at some commonly used ones, i.e., Java Serialization and Java Externalizable. Java Serialization Example First let”s look at Java Serialization. Let”s say, we define an Employee class with Serializable interface implemented. public class Employee implements Serializable{ private static final long serialVersionUID = 1L; private String name; private String department; public Employee(String name, String department) { super(); this.name = name; this.department = department; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDepartment() { return department; } public void setDepartment(String department) { this.department = department; } @Override public String toString() { return “Employee [name=” + name + “, department=” + department + “]”; } } Let’s now write code to add Employee object to the Hazelcast map. public class EmployeeExample { public static void main(String… args){ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); //create a set to track employees Map<Employee, String> employeeOwners=hazelcast.getMap(“employeeVehicleMap”); Employee emp1 = new Employee(“John Smith”, “Computer Science”); // add employee to set System.out.println(“Serializing key-value and add to map”); employeeOwners.put(emp1, “Honda”); // check if emp1 is present in the set System.out.println(“Serializing key for searching and Deserializing value got out of map”); System.out.println(employeeOwners.get(emp1)); // perform a graceful shutdown hazelcast.shutdown(); } } Output It will produce the following output − Serializing key-value and add to map Serializing key for searching and Deserializing value got out of map Honda A very important aspect here is that simply by implementing a Serializable interface, we can make Hazelcast use Java Serialization. Also note that Hazelcast stores serialized data for key and value instead of storing it in-memory like HashMap. So, Hazelcast does the heavy-lifting of Serialization and Deserialization. Example However, there is a pitfall here. In the above case, what if the department of the employee changes? The person is still the same. public class EmployeeExampleFailing { public static void main(String… args){ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); //create a set to track employees Map<Employee, String> employeeOwners=hazelcast.getMap(“employeeVehicleMap”); Employee emp1 = new Employee(“John Smith”, “Computer Science”); // add employee to map System.out.println(“Serializing key-value and add to map”); employeeOwners.put(emp1, “Honda”); Employee empDeptChange = new Employee(“John Smith”, “Electronics”); // check if emp1 is present in the set System.out.println(“Checking if employee with John Smith is present”); System.out.println(employeeOwners.containsKey(empDeptChange)); Employee empSameDept = new Employee(“John Smith”, “Computer Science”); System.out.println(“Checking if employee with John Smith is present”); System.out.println(employeeOwners.containsKey(empSameDept)); // perform a graceful shutdown hazelcast.shutdown(); } } Output It will produce the following output − Serializing key-value and add to map Checking if employee with name John Smith is present false Checking if employee with name John Smith is present true It is because Hazelcast does not deserialize the key, i.e., Employee while comparison. It directly compares the bytecode of the serialized key. So, an object with the same value to all the attributes would be treated the same. But if the value to those attributes changes, for example, department in the above scenario, those two keys are treated as unique. Java Externalizable What if, in the above example, we don”t care about the value of the department while performing serialization/deserialization of keys. Hazelcast also supports Java Externalizable which gives us control over what tags are used for serialization and deserialization. Example Let’s modify our Employee class accordingly − public class EmplyoeeExternalizable implements Externalizable { private static final long serialVersionUID = 1L; private String name; private String department; public EmplyoeeExternalizable(String name, String department) { super(); this.name = name; this.department = department; } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { System.out.println(“Deserializaing….”); this.name = in.readUTF(); } @Override public void writeExternal(ObjectOutput out) throws IOException { System.out.println(“Serializing….”); out.writeUTF(name); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDepartment() { return department; } public void setDepartment(String department) { this.department = department; } @Override public String toString() { return “Employee [name=” + name + “, department=” + department + “]”; } } So, as you can see from the code, we have added readExternal/writeExternal methods which are responsible for serialization/deserialization. Given that we are not interested in the department while serialization/deserialization, we exclude those in readExternal/writeExternal methods. Example Now, if we execute the following code − public class EmployeeExamplePassing { public static void main(String… args){ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); //create a set to track employees Map<EmplyoeeExternalizable, String> employeeOwners=hazelcast.getMap(“employeeVehicleMap”); EmplyoeeExternalizable emp1 = new EmplyoeeExternalizable(“John Smith”, “Computer Science”); // add employee to map employeeOwners.put(emp1, “Honda”); EmplyoeeExternalizable empDeptChange = new EmplyoeeExternalizable(“John Smith”, “Electronics”); // check if emp1 is present in the set System.out.println(“Checking if employee with John Smith is present”); System.out.println(employeeOwners.containsKey(empDeptChange)); EmplyoeeExternalizable empSameDept = new EmplyoeeExternalizable(“John Smith”, “Computer Science”); System.out.println(“Checking if employee with John Smith is present”); System.out.println(employeeOwners.containsKey(empSameDept)); // perform a graceful shutdown hazelcast.shutdown(); } } Output The output we get is − Serializing…. Checking if employee with John Smith is present Serializing…. true Checking if employee with John Smith is present Serializing…. true As the output shows, using Externalizable interface, we can provide Hazelcast with serialized data for only the name of the employee. Also note that Hazelcast serializes our key twice − Once while storing the key, And, second for searching the given key in the map. As stated earlier, this is because Hazelcast uses serialized byte arrays for key comparison. Overall, using Externalizable has more benefits as compared to Serializable if we want to have more control over what attributes are to be serialized and how we want to handle them.

Hazelcast – First Application ”; Previous Next Hazelcast can be run in isolation (single node) or multiple nodes can be run to form a cluster. Let us first try starting a single instance. Single Instance Example Now, let us try creating and using a single instance of Hazelcast cluster. For that, we will create SingleInstanceHazelcastExample.java file. package com.example.demo; import java.util.Map; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; public class SingleInstanceHazelcastExample { public static void main(String… args){ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); System.out.println(“Hello world”); // perform a graceful shutdown hazelcast.shutdown(); } } Now let’s compile the code and execute it − mvn clean install java -cp target/demo-0.0.1-SNAPSHOT.jar com.example.demo.SingleInstanceHazelcastExample Output If you execute above code, the output would be − Hello World However, more importantly, you will also notice log lines from Hazelcast which signifies that Hazelcast has started. Since we are running this code only once, i.e., a single JVM, we would only have one member in our cluster. Jan 30, 2021 10:26:51 AM com.hazelcast.config.XmlConfigLocator INFO: Loading ”hazelcast-default.xml” from classpath. Jan 30, 2021 10:26:51 AM com.hazelcast.instance.AddressPicker INFO: [LOCAL] [dev] [3.12.12] Prefer IPv4 stack is true. Jan 30, 2021 10:26:52 AM com.hazelcast.instance.AddressPicker INFO: [LOCAL] [dev] [3.12.12] Picked [localhost]:5701, using socket ServerSocket[addr=/0:0:0:0:0:0:0:0,localport=5701], bind any local is true Jan 30, 2021 10:26:52 AM com.hazelcast.system … Members {size:1, ver:1} [ Member [localhost]:5701 – 9b764311-9f74-40e5-8a0a-85193bce227b this ] Jan 30, 2021 10:26:56 AM com.hazelcast.core.LifecycleService INFO: [localhost]:5701 [dev] [3.12.12] [localhost]:5701 is STARTED … You will also notice log lines from Hazelcast at the end which signifies Hazelcast was shutdown: INFO: [localhost]:5701 [dev] [3.12.12] Hazelcast Shutdown is completed in 784 ms. Jan 30, 2021 10:26:57 AM com.hazelcast.core.LifecycleService INFO: [localhost]:5701 [dev] [3.12.12] [localhost]:5701 is SHUTDOWN Cluster: Multi Instance Now, let”s create MultiInstanceHazelcastExample.java file (as below) which would be used for multi-instance cluster. package com.example.demo; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; public class MultiInstanceHazelcastExample { public static void main(String… args) throws InterruptedException{ //initialize hazelcast server/instance HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(); //print the socket address of this member and also the size of the cluster System.out.println(String.format(“[%s]: No. of hazelcast members: %s”, hazelcast.getCluster().getLocalMember().getSocketAddress(), hazelcast.getCluster().getMembers().size())); // wait for the member to join Thread.sleep(30000); //perform a graceful shutdown hazelcast.shutdown(); } } Let’s execute the following command on two different shells − java -cp .targetdemo-0.0.1-SNAPSHOT.jar com.example.demo.MultiInstanceHazelcastExample You would notice on the 1st shell that a Hazelcast instance has been started and a member has been assigned. Note the last line of output which says that there is a single member using port 5701. Jan 30, 2021 12:20:21 PM com.hazelcast.internal.cluster.ClusterService INFO: [localhost]:5701 [dev] [3.12.12] Members {size:1, ver:1} [ Member [localhost]:5701 – b0d5607b-47ab-47a2-b0eb-6c17c031fc2f this ] Jan 30, 2021 12:20:21 PM com.hazelcast.core.LifecycleService INFO: [localhost]:5701 [dev] [3.12.12] [localhost]:5701 is STARTED [/localhost:5701]: No. of hazelcast members: 1 You would notice on the 2nd shell that a Hazelcast instance has joined the 1st instance. Note the last line of the output which says that there are now two members using port 5702. INFO: [localhost]:5702 [dev] [3.12.12] Members {size:2, ver:2} [ Member [localhost]:5701 – b0d5607b-47ab-47a2-b0eb-6c17c031fc2f Member [localhost]:5702 – 037b5fd9-1a1e-46f2-ae59-14c7b9724ec6 this ] Jan 30, 2021 12:20:46 PM com.hazelcast.core.LifecycleService INFO: [localhost]:5702 [dev] [3.12.12] [localhost]:5702 is STARTED [/localhost:5702]: No. of hazelcast members: 2 Print Page Previous Next Advertisements ”;

Hazelcast – Introduction ”; Previous Next Distributed In-memory Data Grid A data grid is a superset to distributed cache. Distributed cache is typically used only for storing and retrieving key-value pairs which are spread across caching servers. However, a data grid, apart from supporting storage of key-value pairs, also supports other features, for example, It supports other data structures like locks, semaphores, sets, list, and queues. It provides a way to query the stored data by rich querying languages, for example, SQL. It provides a distributed execution engine which helps to operate on the data in parallel. Benefits of Hazelcast Support multiple data structures − Hazelcast supports the usage of multiple data structures along with Map. Some of the examples are Lock, Semaphore, Queue, List, etc. Fast R/W access − Given that all the data is in-memory, Hazelcast offers very high-speed data read/write access. High availability − Hazelcast supports the distribution of data across machines along with additional support for backup. This means that the data is not stored on a single machine. So, even if a machine goes down, which occurs frequently in a distributed environment, the data is not lost. High Performance − Hazelcast provides constructs which can be used to distribute the workload/computation/query among multiple worker machines. This means a computation/query uses resources from multiple machines which reduces the execution time drastically. Easy to use − Hazelcast implements and extends a lot of java.util.concurrent constructs which make it very easy to use and integrate with the code. Configuration to start using Hazelcast on a machine just involves adding the Hazelcast jar to our classpath. Hazelcast vs Other Caches & Key-Value stores Comparing Hazelcast with other caches like Ehcache, Guava, and Caffeine may not be very useful. It is because, unlike other caches, Hazelcast is a distributed cache, that is, it spreads the data across machines/JVM. Although Hazelcast can work very well on single JVM as well, however, it is more useful is a distributed environment. Similarly comparing it with Databases like MongoDB is also of not much use. This is because, Hazelcast mostly stores data in memory (although it also supports writing to disk). So, it offers high R/W speed with the limitation that data needs to be stored in memory. Hazelcast also supports caching/storing complex data types and provides an interface to query them, unlike other data stores. A comparison, however, can be made with Redis which also offers similar features. Hazelcast vs Redis In terms of features, both Redis and Hazelcast are very similar. However, following are the points where Hazelcast scores over Redis − Built for Distributed Environment from ground-up − Unlike Redis, which started as single machine cache, Hazelcast, from the very beginning, has been built for distributed environment. Simple cluster scale in/out − Maintaining a cluster where nodes are added or removed is very simple in case of Hazelcast, for example, adding a node is a matter of launching the node with the required configuration. Removing a node requires simple shutting down of the node. Hazelcast automatically handles partitioning of data, etc. Having the same setup for Redis and performing the above operation requires more precaution and manual efforts. Less resources needs to support failover − Redis follows master-slave approach. For failover, Redis requires additional resources to setup Redis Sentinel. These Sentinel nodes are responsible to elevate a slave to master if the original master node goes down. In Hazelcast, all nodes are treated equal, failure of a node is detected by other nodes. So, the case of a node going down is handled pretty transparently and that too without any additional set of monitoring servers. Simple Distributed Compute − Hazelcast, with its EntryProcessor, provides a simple interface to send the code to the data for parallel processing. This reduces data transfer over the wire. Redis also supports this, however, achieving this requires one to be aware of Lua scripting which adds additional learning curve. Print Page Previous Next Advertisements ”;