Package com.hazelcast.spi

Provides interfaces/classes for the Hazelcast SPI for building distributed data structures and services.

See: Description

Interface Summary

Interface	Description
BackupAwareOperation	A BackupAwareOperation is an Operation to indicate then when a change is made, a BackupOperation is created to replicate the backup.
BackupOperation	When an BackupAwareOperation makes a change, the backups need to be replicated to other members (depending on the configuration and if change really happened).
Callback<T>	Deprecated
ClientAwareService	A interface that can be implemented by a SPI Service so that it can be notified about client disconnects.
ConfigurableService<T>	A capability for SPI services.
CoreService	Marker interface for core Hazelcast services.
EventFilter	A predicate that can filter out events.
EventPublishingService<E,T>	A service for publishing events.
EventRegistration	The result of a Event Registration.
EventService	Component responsible for handling events like topic events or map.listener events.
ExecutionService	A Service responsible for providing access to 'system' executors and customer executors.
ExecutionTracingService	Service that keeps registry of operations' execution/lifecycle.
InitializingObject	Can be implemented by DistributedObject (proxies) to indicate that they want to be initialized.
InternalCompletableFuture<E>	A ICompletableFuture with more functionality like getting the result without needing to deal with checked exceptions.
ListenerWrapperEventFilter	Contract point for EventFilter instances these wrap listeners.
ManagedService	A interface that can be implemented by a SPI Service to receive lifecycle calls: initialization shutdown reset
MembershipAwareService	An interface that can be implemented by a SPI service that needs to be notified members joining and leaving the cluster.
MigrationAwareService	An interface that can be implemented by SPI services to get notified of partition changes; for example, if a MapService starts moving its data around because partitions are moving to a different machine.
NamedOperation	Indicates that Operation carries the distributed data structure name that is going to work on.
NodeAware	A 'capability' that can be implemented by object to get the Node injected.
NodeEngine	The NodeEngine is the 'umbrella' of services/service-method that gets injected into a ManagedService.
NonThreadSafe	Marker interface for non-thread-safe classes.
NotifiableEventListener<S>	Contract point for event listeners to be notified by EventService.
Notifier	A component used in wait/notify systems like Condition.
ObjectNamespace	An ObjectNamespace that makes identification of object within a service possible.
OperationFactory	A Factory for creating Operation instances.
OperationResponseHandler<O extends Operation>	A handler for the OperationService when it has calculated a response.
OperationService	The OperationService is responsible for executing operations.
PartitionAwareOperation	An interface that can be implemented by an operation to indicate that is should be invoked on a particular partition.
PartitionAwareService	An interface that can be implemented by SPI services to get notified of when a partition-related event occurs; for example, if a MapService notifies its map listeners when partition is lost for a map.
PostJoinAwareService
ProxyService	A CoreService responsible for managing the DistributedObject proxies.
QuorumAwareService	Quorum service can ask for quorum information to the QuorumAwareService to decide whether operation participates into a quorum or not.
ReadonlyOperation	Read-only operations are not retried during migration.
RemoteService	An interface that can be implemented by SPI-Services to give them the ability to create proxies to distributed objects.
ReplicationSupportingService	An interface that can be implemented by SPI services to give them the ability to listen to Replication Events.
ResponseHandler	Deprecated
ServiceConfigurationParser<T>	A hook into the parsing system.
SharedService	Marks a service which exposes its data (e.g.
SplitBrainHandlerService	An interface that can be implemented by SPI services that want to be able to resolve a split brain.
StatisticsAwareService	This interface is in BETA stage and is subject to change in upcoming releases.
TraceableOperation	Operation which has a traceable identifier
TransactionalService	An interface that can be implemented by SPI services that want to deal with transactions.
UrgentSystemOperation	An Marker interface that signals that an operation is an urgent System Operation.
WaitNotifyKey	A key for a wait notify object e.g.
WaitNotifyService	A service for an object where one can wait on, like ICondition or ILock when a thread needs to wait for a lock to be released.
WaitSupport	A interface that can be implemented to participate in the Wait/Notify System.

Class Summary

Class	Description
AbstractDistributedObject<S extends RemoteService>	Abstract DistributedObject implementation.
AbstractOperation	Abstract Operation implementation with some basic methods implemented.
AbstractWaitNotifyKey	Abstract implementation of the WaitNotifyKey.
DefaultObjectNamespace	Default ObjectNamespace implementation.
InvocationBuilder	The InvocationBuilder is responsible for building an invocation of an operation and invoking it.
MemberAttributeServiceEvent	This service event is fired to inform services about a change in a member's attributes collection
MembershipServiceEvent	Membership event fired when a new member is added to the cluster and/or when a member leaves the cluster.
Operation	An operation could be compared to a Runnable.
OperationAccessor	Allows access to certain attributes on an Operation.
PartitionMigrationEvent	An EventObject for a partition migration.
PartitionReplicationEvent	An event send to MigrationAwareService when partition changes happen.
TransactionalDistributedObject<S extends RemoteService>	To centralize de-serialization for transactional proxies

Enum Summary

Enum	Description
ExceptionAction	The possible actions that can be taken when a certain exception is thrown.

Package com.hazelcast.spi Description

Provides interfaces/classes for the Hazelcast SPI for building distributed data structures and services. This is an internal, low-level API for building distributed services on Hazelcast. As an internal API, it is expected to change in each major and minor release of Hazelcast, but be stable for patch releases. It should be possible to evolve your structures and services as the SPI changes. As an internal API, it is expected to change in each release except for the patch releases.