Course info
Dec 16, 2015
1h 50m

This course covers the base information you need to get up and running with Hazelcast. It covers the main data structures with a focus on distributed maps. It also covers how to ensure that you use you network efficiently and how to debug and monitor your applications.

About the author
About the author

Grant is a Software Engineer with over 15 years experience working in mainly large scale, highly available and real time enterprise applications. He is keen on Agile approaches and automation to solve complex problems for clients and stakeholders.

More from the author
Practical Enterprise JMS Playbook
1h 39m
Dec 11, 2017
JCache Fundamentals
1h 23m
Sep 19, 2016
Section Introduction Transcripts
Section Introduction Transcripts

Basic Map Usage
Hi, this is Grant Little from Pluralsight. In this module, we'll start to look at what is probably the most fundamental data structure in Hazelcast, the distributed map. We'll look at what a distributed map is, how we can add data into distributed maps, how Hazelcast stores this data in a resilient way, and some of the issues you need to be aware of. We'll look at an example of how you can read data into and write data from a map into some form of persistent storage such as a database. We'll look at how you can search the data within a map, and also how you can improve the performance of your searches using indexes.

Working with Map Data
Hi, this is Grant Little from Pluralsight. In this module we'll be focusing a bit more on how to work with the map data you have stored in your cluster. We'll have a look at key locks. What they are and how they can be used. We'll go over entry processors, especially around how these can be used to avoid synchronization points in your application. We'll review how you can get aggregated information from your map data using aggregators. It's also possible to keep related data together within your cluster to help improve performance using Data Affinity so we'll see how you can do that.

Other Data Structures
Hi, this is Grant Little from Pluralsight. In this module we'll be looking at some of the other data structures that are available within Hazelcast. The ones we will be looking at are sets, lists, queues and topics, MultiMaps, locks. There are others though and in fact, you can actually create your own custom data structures but I generally find when starting out, these are the ones that are most relevant. We also won't be going into as much detail as we did with the map data structure. There are a couple of reasons for this. First off, many of the APIs are simpler than the map data structure. Second, in many cases, they are very similar to their counterparts in the standard java. util package such as set and list. As this course is based at an intermediary level, it is assumed that you will have some experience of these already, therefore they should be fairly easy to pick up and run with.

Listening to Events in the Cluster
Hi, this is Grant Little from Pluralsight. In this module we will look at how Hazelcast can provide you with information about what is happening in your cluster. It does this through events, which you can subscribe to. You've probably not realized it, but we have already looked at one type of event listener. This was in the last module when we looked at the topic data structure. The messageListener interface we implemented there is actually an event listener. We won't cover that again, but we will look at some of the other important ones. Specifically, entry listeners, which are used to listen for events on your map and MultiMap data structures. Continuous query, a special case where some filtering can be applied to only invoke your entry listeners when certain criteria apply. Item listeners, used to listen for events on your set, list, and queue data structures. Partition lost listeners, allows you to be notified when there's potential data loss in your cluster. We'll also quickly review some of the other events you can subscribe to.

Efficient Use of the Network
Hi, this is Grant Little from Pluralsight. In this module we're going to be looking at a specific performance issue when using Hazelcast and that is serialization. We'll look at some of the serialization options available within Hazelcast, but we will focus on one in particular and that is VersionedPortable. And why I recommend this serialization mechanism. We'll take a look at a demo of how you can implement VersionedPortable and some utilizes you might need to create to support this.