10/3/2021 An Introduction to Hazelcast | Baeldung

(/)

Guide to Hazelcast with Java

Last modi ed: September 17, 2020

by baeldung (https://www.baeldung.com/author/baeldung/)

Data (https://www.baeldung.com/category/data/)

1. Overview
This is an introductory article on Hazelcast where we'll see how to create a
cluster member, a distributed Map to share data among the cluster nodes, and
create a Java client to connect and query data in the cluster.

2. What Is Hazelcast?
Hazelcast is a distributed In-Memory Data Grid platform for Java. The
architecture supports high scalability and data distribution in a clustered
environment. It supports the auto-discovery of nodes and intelligent
synchronization.
Hazelcast is available in di erent editions
(http://docs.hazelcast.org/docs/latest/manual/html-
single/index.html#hazelcast-editions.). To see the features for all Hazelcast
editions we can refer to the following link (https://hazelcast.org/imdg/imdg-
features/). In this tutorial, we'll use the open-source edition.

https://www.baeldung.com/java-hazelcast 1/9
10/3/2021 An Introduction to Hazelcast | Baeldung

Likewise, Hazelcast o ers various features such as Distributed Data Structure,

Distributed Compute, Distributed Query, etc. For the purpose of this article,
we'll focus on a distributed Map.

3. Maven Dependency
Hazelcast o ers many di erent libraries to deal with various requirements. We
can nd them under com.hazelcast
(https://search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22com.haze
lcast%22) group in Maven Central.
However, in this article, we'll only use the core dependency needed to create
a standalone Hazelcast cluster member and the Hazelcast Java Client:

<dependency>
<groupId>com.hazelcast</groupId>
<artifactId>hazelcast</artifactId>
<version>4.0.2</version>
</dependency>

The current version is available in maven central repository

(https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22com.haz
elcast%22%20AND%20a%3A%22hazelcast%22).

4. A First Hazelcast Application

4.1. Create a Hazelcast Member

Members (also called nodes) automatically join together to form a cluster. This
automatic joining takes place with various discovery mechanisms that the
members use to nd each other.
Let's create a member that stores data in a Hazelcast distributed map:

https://www.baeldung.com/java-hazelcast 2/9
10/3/2021 An Introduction to Hazelcast | Baeldung

public class ServerNode {

HazelcastInstance hzInstance = Hazelcast.newHazelcastInstance();

...
}

When we start the ServerNode application, we can see the owing text in the
console which means that we create a new Hazelcast node in our JVM which
will have to join the cluster.

Members [1] {
Member [192.168.1.105]:5701 - 899898be-b8aa-49aa-8d28-40917ccba56c
this
}

To create multiple nodes we can start the multiple instances of ServerNode

application. As a result, Hazelcast will automatically create and add a new
member to the cluster.
For example, if we run the ServerNode application again, we'll see the
following log in the console which says that there are two members in the
cluster.

Members [2] {
Member [192.168.1.105]:5701 - 899898be-b8aa-49aa-8d28-40917ccba56c
Member [192.168.1.105]:5702 - d6b81800-2c78-4055-8a5f-7f5b65d49f30 this
}

4.2. Create a Distributed Map

Next, let's create a distributed Map. We need the instance of
HazelcastInstance created earlier to construct a distributed Map which
extends java.util.concurrent.ConcurrentMap interface.

Map<Long, String> map = hazelcastInstance.getMap("data");

...

Finally, let's add some entries to the map:

https://www.baeldung.com/java-hazelcast 3/9
10/3/2021 An Introduction to Hazelcast | Baeldung

FlakeIdGenerator idGenerator =
hazelcastInstance.getFlakeIdGenerator("newid");
for (int i = 0; i < 10; i++) {
map.put(idGenerator.newId(), "message" + i);
}

As we can see above, we have added 10 entries to the map. We used

FlakeIdGenerator to ensure that we get the unique key for the map. For more
details on FlakeIdGenerator, we can check out the following link
(https://javadoc.io/doc/com.hazelcast/hazelcast/4.0.2/com/hazelcast/ akei
dgen/FlakeIdGenerator.html).
While this may not be a real-world example, we only used it to demonstrate
one of the many operations that we can apply to the distributed map. Later on,
we'll see how to retrieve the entries added by the cluster member from the
Hazelcast Java client.
Internally, Hazelcast partitions the map entries and distributes and replicates
the entries among the cluster members. For more details on Hazelcast Map,
we can check out the following link
(https://docs.hazelcast.org/docs/4.0.2/manual/html-single/index.html#map).

4.3. Create a Hazelcast Java Client

Hazelcast client allows us to do all Hazelcast operations without being a
member of the cluster. It connects to one of the cluster members and
delegates all cluster-wide operations to it.
Let's create a native client:

ClientConfig config = new ClientConfig();

config.setClusterName("dev");
HazelcastInstance hazelcastInstanceClient =
HazelcastClient.newHazelcastClient(config);

It's simple as that.

4.4. Access Distributed Map From Java Client

https://www.baeldung.com/java-hazelcast 4/9
10/3/2021 An Introduction to Hazelcast | Baeldung

Next, we'll use the instance of HazelcastInstance created earlier to access the
distributed Map:

Map<Long, String> map = hazelcastInstanceClient.getMap("data");

...

Now we can do operations on a map without being a member of the cluster.

For example, let's try to iterate over the entries:

for (Entry<Long, String> entry : map.entrySet()) {

...
}

5. Con guring Hazelcast

In this section, we'll focus on how to con gure the Hazelcast network using
declaratively (XML) and programmatically (API) and use the Hazelcast
management center to monitor and manage nodes that are running.
While Hazelcast is starting up, it looks for a hazelcast.con g system property. If
it's set, its value is used as the path. Otherwise, Hazelcast searches for a
hazelcast.xml le in the working directory or on the classpath.
If none of the above works, Hazelcast loads the default con guration, i.e.
hazelcast-default.xml that comes with hazelcast.jar.

5.1. Network Con guration

By default, Hazelcast uses multicast for discovering other members that can
form a cluster. If multicast isn't a preferred way of discovery for our
environment, then we can con gure Hazelcast for a full TCP/IP cluster.
Let's con gure the TCP/IP cluster using declarative con guration:

https://www.baeldung.com/java-hazelcast 5/9
10/3/2021 An Introduction to Hazelcast | Baeldung

<?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-4.0.xsd";
<network>
<port auto-increment="true" port-count="20">5701</port>
<join>
<multicast enabled="false"/>
<tcp-ip enabled="true">
<member>machine1</member>
<member>localhost</member>
</tcp-ip>
</join>
</network>
</hazelcast>

Alternatively, we can use the Java con g approach:

Config config = new Config();

NetworkConfig network = config.getNetworkConfig();
network.setPort(5701).setPortCount(20);
network.setPortAutoIncrement(true);
JoinConfig join = network.getJoin();
join.getMulticastConfig().setEnabled(false);
join.getTcpIpConfig()
.addMember("machine1")
.addMember("localhost").setEnabled(true);

By default, Hazelcast will try 100 ports to bind. In the example above, if we set
the value of port as 5701 and limit the port count to 20, as members are joining
the cluster, Hazelcast tries to nd ports between 5701 and 5721.
If we want to choose to use only one port, we can disable the auto-increment
feature by setting auto-increment to false.

5.2. Management Center Con guration

The management center allows us to monitor the overall state of the clusters,
we can also analyze and browse the data structures in detail, update map
con gurations, and take thread dump from nodes.

https://www.baeldung.com/java-hazelcast 6/9
10/3/2021 An Introduction to Hazelcast | Baeldung

To use the Hazelcast management center, we can either deploy the

mancenter-version.war application into our Java application server/container
or we can start Hazelcast Management Center from the command line. We
can download the latest Hazelcast ZIP from hazelcast.org
(https://hazelcast.org/imdg/download/). The ZIP contains the mancenter-
version.war le.
We can con gure our Hazelcast nodes by adding the URL of the web
application to hazelcast.xml and then have the Hazelcast members
communicate with the management center.
So let's now con gure the management center using declarative
con guration:

<management-center enabled="true">
http://localhost:8080/mancenter
</management-center>

Likewise, here's the programmatic con guration:

ManagementCenterConfig manCenterCfg = new ManagementCenterConfig();

manCenterCfg.setEnabled(true).setUrl("http://localhost:8080/mancenter");

6. Conclusion
In this article, we covered introductory concepts about Hazelcast. For more
details, we can take a look at the Reference Manual
(http://docs.hazelcast.org/docs/3.7/manual/html-single/index.html).
As usual, all the code for this article is available over on GitHub
(https://github.com/eugenp/tutorials/tree/master/hazelcast).

Get started with Spring 5 and Spring Boot 2, through

the Learn Spring course:

https://www.baeldung.com/java-hazelcast 7/9
10/3/2021 An Introduction to Hazelcast | Baeldung

>> CHECK OUT THE COURSE (/ls-course-end)

Comments are closed on this article!

CATEGORIES
SPRING (HTTPS://WWW.BAELDUNG.COM/CATEGORY/SPRING/)
REST (HTTPS://WWW.BAELDUNG.COM/CATEGORY/REST/)
JAVA (HTTPS://WWW.BAELDUNG.COM/CATEGORY/JAVA/)
SECURITY (HTTPS://WWW.BAELDUNG.COM/CATEGORY/SECURITY-2/)
PERSISTENCE (HTTPS://WWW.BAELDUNG.COM/CATEGORY/PERSISTENCE/)
JACKSON (HTTPS://WWW.BAELDUNG.COM/CATEGORY/JSON/JACKSON/)
HTTP CLIENT-SIDE (HTTPS://WWW.BAELDUNG.COM/CATEGORY/HTTP/)

SERIES
JAVA “BACK TO BASICS” TUTORIAL (/JAVA-TUTORIAL)
JACKSON JSON TUTORIAL (/JACKSON)
HTTPCLIENT 4 TUTORIAL (/HTTPCLIENT-GUIDE)
REST WITH SPRING TUTORIAL (/REST-WITH-SPRING-SERIES)
SPRING PERSISTENCE TUTORIAL (/PERSISTENCE-WITH-SPRING-SERIES)
SECURITY WITH SPRING (/SECURITY-SPRING)

ABOUT
ABOUT BAELDUNG (/ABOUT)
THE COURSES (HTTPS://COURSES.BAELDUNG.COM)
JOBS (/TAG/ACTIVE-JOB/)
THE FULL ARCHIVE (/FULL_ARCHIVE)
WRITE FOR BAELDUNG (/CONTRIBUTION-GUIDELINES)
EDITORS (/EDITORS)
OUR PARTNERS (/PARTNERS)
ADVERTISE ON BAELDUNG (/ADVERTISE)
https://www.baeldung.com/java-hazelcast 8/9
10/3/2021 An Introduction to Hazelcast | Baeldung

TERMS OF SERVICE (/TERMS-OF-SERVICE)

PRIVACY POLICY (/PRIVACY-POLICY)
COMPANY INFO (/BAELDUNG-COMPANY-INFO)
CONTACT (/CONTACT)

https://www.baeldung.com/java-hazelcast 9/9