# 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).
  BlockingOperation | An interface that can be implemented by an operation that can block.
  CanCancelOperations | Implemented by a service that can cancel its operations.
  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.
  FragmentedMigrationAwareService | `FragmentedMigrationAwareService` is an extension to the `MigrationAwareService` which allows migration/replication of partition replicas in smaller fragments.
  GracefulShutdownAwareService | An interface that can be implemented by SPI services to participate in graceful shutdown process, such as moving their internal data to another node or releasing their allocated resources gracefully.
  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.
  LiveOperations | `InvocationMonitor` passes instances of this type to each `LiveOperationsTracker` so it can contribute the call IDs of invocations it is responsible for.
  LiveOperationsTracker | Can be implemented by a Service to track live operations.
  LockInterceptorService<T> | Interface to be implemented by services that need to intercept lock operation for distributed objects it manages.
  ManagedService | An interface that can be implemented by an SPI Service to receive lifecycle calls: initialization shutdown reset
  MemberAddressProvider | IMPORTANT This interface is not intended to provide addresses of other cluster members with which the hazelcast instance will form a cluster.
  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`.
  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 it 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 | Marker interface for services that want to return operations to be executed on the cluster members after a join has been finalized.
  PreJoinAwareService | Services which need to perform operations on a joining member just before the member is set as joined must implement this interface.
  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 allowed to run during migration and passive state.
  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 WAN replication events.
  ServiceConfigurationParser<T> | A hook into the parsing system.
  ServiceNamespace | `ServiceNamespace` is a namespace to group objects, structures, fragments within a service.
  ServiceNamespaceAware | An object which is aware of `ServiceNamespace` which object itself belongs to.
  SharedService | Deprecated since 3.7.
  SplitBrainHandlerService | An interface that can be implemented by SPI services that want to be able to resolve a split-brain.
  StatisticsAwareService<T extends LocalInstanceStats> | A service implementating this interface provides local instance statistics.
  TaskScheduler | `ExecutorService` can schedule a command to run after a given delay or execute periodically.
  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.

- Class Summary
  Class | Description
  --- | ---
  AbstractDistributedObject<S extends RemoteService> | Abstract DistributedObject implementation.
  AbstractLocalOperation | Abstract class for local operations, which should not be serializable.
  AbstractWaitNotifyKey | Abstract implementation of the WaitNotifyKey.
  CallsPerMember | Implements `LiveOperations` and additionally collects the call IDs of operations on remote members whose cancellation was requested.
  CallStatus | The result of an `Operation.call()`.
  DefaultObjectNamespace | Deprecated please use `DistributedObjectNamespace`
  DistributedObjectNamespace | Default `ObjectNamespace` implementation for `DistributedObject`.
  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.
  Offload | This is an internal class.
  Operation | An operation could be compared to a `Runnable`.
  OperationAccessor | Allows access to certain attributes on an Operation.
  OperationControl | Content of an Operation Control packet: a list of operations the remote member started on this member which are still running; a list of operations this member wants to cancel on the remote member. Operations are identified by their call ID.
  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. As a low-level API, it is expected to change in each release except for the patch releases.

Copyright © 2020. All rights reserved.