Guide de Hazelcast avec Java

1. Vue d'ensemble

Il s'agit d'un article d'introduction sur Hazelcast où nous verrons comment créer un membre du cluster, une carte distribuée pour partager des données entre les nœuds du cluster, et créer un client Java pour se connecter et interroger les données du cluster.

2. Qu'est-ce que Hazelcast?

Hazelcast est une plate-forme de grille de données en mémoire distribuée pour Java. L'architecture prend en charge une évolutivité et une distribution de données élevées dans un environnement en cluster. Il prend en charge la découverte automatique des nœuds et la synchronisation intelligente.

Hazelcast est disponible en différentes éditions. Pour voir les fonctionnalités de toutes les éditions Hazelcast, nous pouvons vous référer au lien suivant. Dans ce tutoriel, nous utiliserons l'édition open source.

De même, Hazelcast propose diverses fonctionnalités telles que la structure de données distribuée, le calcul distribué, la requête distribuée, etc. Pour les besoins de cet article, nous nous concentrerons sur une carte distribuée .

3. Dépendance de Maven

Hazelcast propose de nombreuses bibliothèques différentes pour répondre à diverses exigences. Nous pouvons les trouver sous le groupe com.hazelcast à Maven Central.

Cependant, dans cet article, nous n'utiliserons que la dépendance principale nécessaire pour créer un membre de cluster Hazelcast autonome et le client Java Hazelcast:

 com.hazelcast hazelcast 4.0.2  

La version actuelle est disponible dans le référentiel central maven.

4. Une première application Hazelcast

4.1. Créer un membre Hazelcast

Les membres (également appelés nœuds) se rejoignent automatiquement pour former un cluster. Cette jonction automatique a lieu avec divers mécanismes de découverte que les membres utilisent pour se trouver.

Créons un membre qui stocke les données dans une carte distribuée Hazelcast:

public class ServerNode { HazelcastInstance hzInstance = Hazelcast.newHazelcastInstance(); ... }

Lorsque nous démarrons l' application ServerNode , nous pouvons voir le texte flottant dans la console, ce qui signifie que nous créons un nouveau nœud Hazelcast dans notre JVM qui devra rejoindre le cluster.

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

Pour créer plusieurs nœuds, nous pouvons démarrer les multiples instances de l' application ServerNode . En conséquence, Hazelcast créera et ajoutera automatiquement un nouveau membre au cluster.

Par exemple, si nous exécutons à nouveau l'application ServerNode , nous verrons le journal suivant dans la console qui indique qu'il y a deux membres dans le 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. Créer une carte distribuée

Ensuite, créons une carte distribuée . Nous avons besoin de l'instance de HazelcastInstance créée précédemment pour construire une carte distribuée qui étend l' interface java.util.concurrent.ConcurrentMap .

Map map = hazelcastInstance.getMap("data"); ...

Enfin, ajoutons quelques entrées à la carte :

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

Comme nous pouvons le voir ci-dessus, nous avons ajouté 10 entrées à la carte . Nous avons utilisé FlakeIdGenerator pour nous assurer que nous obtenons la clé unique de la carte. Pour plus de détails sur FlakeIdGenerator , nous pouvons consulter le lien suivant.

Bien que ce ne soit peut-être pas un exemple réel, nous ne l'avons utilisé que pour démontrer l'une des nombreuses opérations que nous pouvons appliquer à la carte distribuée. Plus tard, nous verrons comment récupérer les entrées ajoutées par le membre du cluster à partir du client Hazelcast Java.

En interne, Hazelcast partitionne les entrées de la carte et distribue et réplique les entrées parmi les membres du cluster. Pour plus de détails sur Hazelcast Map , nous pouvons consulter le lien suivant.

4.3. Créer un client Java Hazelcast

Le client Hazelcast nous permet de faire toutes les opérations Hazelcast sans être membre du cluster. Il se connecte à l'un des membres du cluster et lui délègue toutes les opérations à l'échelle du cluster.

Créons un client natif:

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

C'est aussi simple que ça.

4.4. Accéder à la carte distribuée à partir du client Java

Ensuite, nous utiliserons l'instance de HazelcastInstance créée précédemment pour accéder à la carte distribuée :

Map map = hazelcastInstanceClient.getMap("data"); ...

Nous pouvons désormais effectuer des opérations sur une carte sans être membre du cluster. Par exemple, essayons de parcourir les entrées:

for (Entry entry : map.entrySet()) { ... }

5. Configuration de Hazelcast

Dans cette section, nous allons nous concentrer sur la façon de configurer le réseau Hazelcast en utilisant de manière déclarative (XML) et par programme (API) et utiliser le centre de gestion Hazelcast pour surveiller et gérer les nœuds en cours d'exécution.

Pendant le démarrage de Hazelcast, il recherche une propriété système hazelcast.config . S'il est défini, sa valeur est utilisée comme chemin. Sinon, Hazelcast recherche un fichier hazelcast.xml dans le répertoire de travail ou sur le chemin des classes .

If none of the above works, Hazelcast loads the default configuration, i.e. hazelcast-default.xml that comes with hazelcast.jar.

5.1. Network Configuration

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 configure Hazelcast for a full TCP/IP cluster.

Let's configure the TCP/IP cluster using declarative configuration:


    

Alternatively, we can use the Java config 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 find 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 Configuration

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 configurations, and take thread dump from nodes.

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. The ZIP contains the mancenter-version.war file.

We can configure 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 configure the management center using declarative configuration:

 //localhost:8080/mancenter 

Likewise, here's the programmatic configuration:

ManagementCenterConfig manCenterCfg = new ManagementCenterConfig(); manCenterCfg.setEnabled(true).setUrl("//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.

As usual, all the code for this article is available over on GitHub.