Go to
hazelcast.org/documentation
Documentation
Version: 3.6-EA3 - Publication Date : Dec 23, 2015
Preface
Product Naming
Licensing
Trademarks
Customer Support
Release Notes
Contributing to Hazelcast
Phone Home
Typographical Conventions
Document Revision History
Getting Started
Installation
Hazelcast
Hazelcast Enterprise
Starting the Member and Client
Configuring Hazelcast
Deploying On Amazon EC2
Deploying using Docker
Hazelcast Overview
Sharding in Hazelcast
Hazelcast Topology
Why Hazelcast?
Data Partitioning
How the Data is Partitioned
Partition Table
Repartitioning
Use Cases
Resources
Hazelcast Clusters
Discovering Cluster Members
Discovering Members by Multicast
Discovering Members by TCP
Discovering Members within EC2 Cloud
Discovering Members with jclouds
Creating Cluster Groups
Distributed Data Structures
Map
Getting a Map and Putting an Entry
Backing Up Maps
Evicting Map Entries
Setting In Memory Format
Loading and Storing Persistent Data
Creating Near Cache for Map
Locking Maps
Accessing Entry Statistics
Map Listener
Adding Interceptors
Preventing Out of Memory Exceptions
Queue
Getting a Queue and Putting Items
Creating an Example Queue
Setting a Bounded Queue
Queueing with Persistent Datastore
Configuring Queue
MultiMap
Getting a MultiMap and Putting an Entry
Configuring MultiMap
Set
Getting a Set and Putting Items
List
Getting a List and Putting Items
Ringbuffer
Getting a Ringbuffer and Reading Items
Adding Items to a Ringbuffer
IQueue vs. Ringbuffer
Configuring Ringbuffer Capacity
Backing Up Ringbuffer
Configuring Ringbuffer Time To Live
Setting Ringbuffer Overflow Policy
Configuring Ringbuffer In-Memory Format
Adding Batched Items
Reading Batched Items
Using Async Methods
Ringbuffer Configuration Examples
Topic
Getting a Topic and Publishing Messages
Getting Topic Statistics
Understanding Topic Behavior
Configuring Topic
Reliable Topic
Sample Reliable ITopic Code
Slow Consumers
Lock
Using Try-Catch Blocks with Locks
Releasing Locks with tryLock Timeout
Avoiding Waiting Threads with Lease Time
Understanding Lock Behavior
Synchronizing Threads with ICondition
IAtomicLong
Sending Functions to IAtomicLong
Executing Functions on IAtomicLong
Reasons to Use Functions with IAtomic
ISemaphore
Controlling Thread Counts with Semaphore Permits
Example Semaphore Code
Example Semaphore Configuration
IAtomicReference
Sending Functions to IAtomicReference
Using IAtomicReference
ICountDownLatch
Gate-Keeping Concurrent Activities
Recovering From Failure
Using ICountDownLatch
IdGenerator
Generating Cluster-Wide IDs
Unique IDs and Duplicate IDs
Replicated Map
Replicating Instead of Partitioning
Example Replicated Map Code
Considerations for Replicated Map
Configuration Design for Replicated Map
Configuring Replicated Map
Using EntryListener on Replicated Map
Distributed Events
Event Listeners for Hazelcast Members
Listening for Member Events
Listening for Distributed Object Events
Listening for Migration Events
Listening for Partition Lost Events
Listening for Lifecycle Events
Listening for Map Events
Listening for MultiMap Events
Listening for Item Events
Listening for Topic Messages
Listening for Clients
Event Listeners for Hazelcast Clients
Global Event Configuration
Distributed Computing
Executor Service
Implementing a Callable Task
Implementing a Runnable Task
Configuring Executor Threads
Scaling The Executor Service
Executing Code in the Cluster
Canceling an Executing Task
Callback When Task Completes
Selecting Members for Task Execution
Entry Processor
Performing Fast In-Memory Map Operations
Creating an Entry Processor
Abstract Entry Processor
Distributed Query
How Distributed Query Works
Employee Map Query Example
Querying with Criteria API
Querying with SQL
Filtering with Paging Predicates
Indexing Queries
Configuring Query Thread Pool
Querying in Collections and Arrays
Indexing in Collections and Arrays
Corner cases
Custom Attributes
Implementing a ValueExtractor
Extraction Arguments
Configuring a Custom Attribute Programmatically
Configuring a Custom Attribute Declaratively
Indexing Custom Attributes
MapReduce
Understanding MapReduce
Using the MapReduce API
Hazelcast MapReduce Architecture
Aggregators
Aggregations Basics
Using the Aggregations API
Aggregations Examples
Implementing Aggregations
Continuous Query
Listening to Predicate Map Entries
Continuous Query Cache
Keeping Query Results Local and Ready
Accessing Continuous Query from Server Side
Accessing Continuous Query from Client Side
Features of Continuous Query Cache
Transactions
Creating a Transaction Interface
Queue/Set/List vs. Map/Multimap
ONE_PHASE vs. TWO_PHASE
Providing XA Transactions
Integrating into J2EE
Sample Code for J2EE Integration
Configuring Resource Adapter
Configuring a Glassfish v3 Web Application
Configuring a JBoss AS 5 Web Application
Configuring a JBoss AS 7 / EAP 6 Web Application
Hazelcast JCache
JCache Overview
JCache Setup and Configuration
Setting up Your Application
Example JCache Application
Configuring for JCache
JCache Providers
Configuring JCache Provider
Configuring JCache with Client Provider
Configuring JCache with Server Provider
JCache API
JCache API Application Example
JCache Base Classes
Implementing Factory and FactoryBuilder
Implementing CacheLoader
CacheWriter
Implementing EntryProcessor
CacheEntryListener
ExpirePolicy
Hazelcast JCache Extension - ICache
Scoping to Join Clusters
Namespacing
Retrieving an ICache Instance
ICache Configuration
ICache Async Methods
Defining a Custom ExpiryPolicy
JCache Eviction
JCache Near Cache
ICache Convenience Methods
Implementing BackupAwareEntryProcessor
ICache Partition Lost Listener
JCache Split-Brain
Testing for JCache Specification Compliance
Integrated Clustering
Hibernate Second Level Cache
Sample Code for Hibernate
Supported Hibernate Versions
Configuring Hibernate for Hazelcast
Configuring Hazelcast for Hibernate
Setting P2P (Peer-to-Peer) for Hibernate
Setting Client/Server for Hibernate
Configuring Cache Concurrency Strategy
Advanced Settings
Web Session Replication
Filter Based Web Session Replication
Supporting Spring Security
Tomcat Based Web Session Replication
Jetty Based Web Session Replication
Spring Integration
Supported Versions
Configuring Spring
Enabling SpringAware Objects
Adding Caching to Spring
Configuring Hibernate Second Level Cache
Best Practices
Storage
High-Density Memory Store
Configuring High-Density Memory Store
Sizing Practices
Hot Restart Persistence
Hot Restart Persistence Overview
Configuring Hot Restart
Hot Restart and IP Address-Port
Hot Restart Persistence Design Details
Concurrent, Incremental, Generational GC
Hazelcast Java Client
Hazelcast Clients Feature Comparison
Java Client Overview
Including Dependencies for Java Clients
Getting Started with Client API
Java Client Operation Modes
Handling Failures
Using Supported Distributed Data Structures
Using Client Services
Client Listeners
Client Transactions
Configuring Java Client
Configuring Client Network
Configuring Client Load Balancer
Configuring Client Near Cache
Client Group Configuration
Client Security Configuration
Client Serialization Configuration
Configuring Client Listeners
ExecutorPoolSize
ClassLoader
Client System Properties
Sample Codes for Client
Other Client Implementations
C++ Client
Setting Up C++ Client
Installing C++ Client
C++ Client Code Examples
.NET Client
Configuring .NET Client
Starting .NET Client
REST Client
REST Client GET/POST/DELETE Examples
Checking the Status of the Cluster for REST Client
Memcache Client
Memcache Client Code Examples
Unsupported Operations for Memcache
Serialization
Serialization Interface Types
Comparing Serialization Interfaces
Implementing Java Serializable and Externalizable
Implementing Java Externalizable
Implementing DataSerializable
IdentifiedDataSerializable
Implementing Portable Serialization
Portable Serialization Example Code
Registering the Portable Factory
Versioning for Portable Serialization
Null Portable Serialization
DistributedObject Serialization
Custom Serialization
Implementing StreamSerializer
Implementing ByteArraySerializer
Global Serializer
Sample Global Serializer
Implementing HazelcastInstanceAware
Management
Getting Member Statistics from Distributed Data Structures
Map Statistics
Multimap Statistics
Queue Statistics
Topic Statistics
Executor Statistics
JMX API per Node
Monitoring with JMX
MBean Naming for Hazelcast Data Structures
Connecting to JMX Agent
Cluster Utilities
Getting Member Events and Member Sets
Managing Cluster and Member States
Enabling Lite Members
Defining Member Attributes
Safety Checking Cluster Members
Defining a Cluster Quorum
Management Center
Installing Management Center
Getting Started to Management Center
Management Center Tools
Management Center Home Page
Monitoring Caches
Managing Maps
Monitoring Replicated Maps
Monitoring Queues
Monitoring Topics
Monitoring MultiMaps
Monitoring Executors
Monitoring WAN Replication
Monitoring Members
Scripting
Executing Console Commands
Creating Alerts
Administering Management Center
Hot Restart
Checking Past Status with Time Travel
Management Center Documentation
Suggested Heap Size
Clustered JMX via Management Center
Configuring Clustered JMX
Clustered JMX API
Integrating with New Relic
Integrating with AppDynamics
Clustered REST via Management Center
Enabling Clustered REST
Clustered REST API Root
Clusters Resource
Cluster Resource
Members Resource
Member Resource
Clients Resource
Maps Resource
MultiMaps Resource
Queues Resource
Topics Resource
Executors Resource
Security
Enabling Security for Hazelcast Enterprise
Socket Interceptor
Security Interceptor
Encryption
SSL
Credentials
ClusterLoginModule
Enterprise Integration
Cluster Member Security
Native Client Security
Authentication
Authorization
Permissions
Performance
Data Affinity
Back Pressure
Threading Model
I/O Threading
Event Threading
IExecutor Threading
Operation Threading
SlowOperationDetector
Logging of Slow Operations
Purging of Slow Operation Logs
Hazelcast Performance on AWS
Selecting EC2 Instance Type
Dealing with Network Latency
Selecting Virtualization
Hazelcast Simulator
Key Concepts
Installing Simulator
Firewall Settings
Setting Up the Local Machine (Coordinator)
Setting Up the Remote Machines (Agents, Workers)
Setting Up the Public/Private Key Pair
Setting Up For Amazon EC2
Setting Up For Google Compute Engine
Setting Up Machines Manually
Executing a Simulator Test
Creating and Editing Properties File
Running the Test
Running the Test with a Script
Using Maven Archetypes
Provisioner
Accessing the Provisioned Machine
Coordinator
Controlling Hazelcast Declarative Configuration
Controlling Test Duration
Controlling Client And Workers
Communicator
Example
Message Types
Message Addressing
Simulator.Properties File Description
Performance and Benchmarking
WAN
WAN Replication
Configuring WAN Replication
WAN Replication Additional Information
Enterprise WAN Replication
Replication implementations
WAN Replication Batch Size
WAN Replication Batch Frequency
WAN Replication Operation Timeout
WAN Replication Queue Capacity
WAN Replication Event Filtering API
WAN Replication Acknowledge Types
Enterprise WAN Replication Additional Information
OSGI
OSGI Support
API
Configuring Hazelcast OSGI Support
Design
Using Hazelcast OSGI Service
Getting Hazelcast OSGI Service Instances
Managing and Using Hazelcast instances
Hazelcast Configuration
Configuration Overview
Using Wildcard
Using Variables
Composing Declarative Configuration
Network Configuration
Public Address
Port
Outbound Ports
Reuse Address
Join
Interfaces
SSL
Socket Interceptor
Symmetric Encryption
IPv6 Support
Map Configuration
Map Store
Near Cache
Indexes
Entry Listeners
MultiMap Configuration
Queue Configuration
Topic Configuration
Reliable Topic Configuration
List Configuration
Set Configuration
Ringbuffer Configuration
Semaphore Configuration
ReplicatedMap Configuration
Executor Service Configuration
Cache Configuration
Serialization Configuration
MapReduce Jobtracker Configuration
Services Configuration
Management Center Configuration
WAN Replication Configuration
Enterprise WAN Replication Configuration
IMap and ICache WAN Configuration
Quorum Configuration
Partition Group Configuration
Logging Configuration
System Properties
Lite Member Configurations
Extending Hazelcast
User Defined Services
Creating the Service Class
Enabling the Service Class
Adding Properties to the Service
Starting the Service
Placing a Remote Call via Proxy
Creating Containers
Partition Migration
Creating Backups
WaitNotifyService
Discovery SPI
Discovery SPI Interfaces and Classes
Discovery Strategy
DiscoveryService (Framework integration)
Config Properties SPI
Config Properties SPI Classes
Config Properties SPI Example
Network Partitioning - Split Brain Syndrome
Understanding Partition Recreation
Understanding Backup Partition Creation
Understanding The Update Overwrite Scenario
What Happens When The Network Failure Is Fixed
How Hazelcast Split Brain Merge Happens
Specifying Merge Policies
License Questions
Embedded Dependencies
Runtime Dependencies
Common Exception Types
Frequently Asked Questions
Why 271 as the default partition count?
Is Hazelcast thread safe?
How do nodes discover each other?
What happens when a node goes down?
How do I test the connectivity?
How do I choose keys properly?
How do I reflect value modifications?
How do I test my Hazelcast cluster?
Does Hazelcast support hundreds of nodes?
Does Hazelcast support thousands of clients?
What is the difference between old LiteMember and new Smart Client?
How do you give support?
Does Hazelcast persist?
Can I use Hazelcast in a single server?
How can I monitor Hazelcast?
How can I see debug level logs?
What is the difference between client-server and embedded topologies?
How do I know it is safe to kill the second node?
When do I need Native Memory solutions?
Is there any disadvantage of using near-cache?
Is Hazelcast secure?
How can I set socket options?
I periodically see client disconnections during idle time?
How to get rid of "java.lang.OutOfMemoryError: unable to create new native thread"?
Does repartitioning wait for Entry Processor?
Why do Hazelcast instances on different machines not see each other?
What Does "Replica: 1 has no owner" Mean?
Glossary
Powered by
beautiful-docs
-
Back to top
Map Listener
Please refer to the
Listening for Map Events section
.
