com.hazelcast.core

## Interface MapStore<K,V>

- Type Parameters:
    `K` - type of the MapStore key
    `V` - type of the MapStore value
  All Superinterfaces:
    MapLoader<K,V>
  All Known Implementing Classes:
    MapStoreAdapter

      public interface MapStore<K,V>
      extends MapLoader<K,V>

  Hazelcast distributed map implementation is an in-memory data store, but it can be backed by any type of data store such as RDBMS, OODBMS, NOSQL, or simply a file-based data store.

  IMap.put(key, value) normally stores the entry into JVM's memory. If the MapStore implementation is provided then Hazelcast will also call the MapStore implementation to store the entry into a user-defined storage, such as RDBMS or some other external storage system. It is completely up to the user how the key-value will be stored or deleted.

  Same goes for IMap.remove(key).

  Store implementation can be called synchronously (write-through) or asynchronously (write-behind) depending on the configuration.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `delete(K key)` Deletes the entry with a given key from the store.
    `void` | `deleteAll(Collection<K> keys)` Deletes multiple entries from the store.
    `void` | `store(K key, V value)` Stores the key-value pair.
    `void` | `storeAll(Map<K,V> map)` Stores multiple entries.

    - ### Methods inherited from interface com.hazelcast.core.MapLoader

      `load, loadAll, loadAllKeys`

- - ### Method Detail

    - #### store

          void store(K key,
                     V value)

      Stores the key-value pair.

      If an exception is thrown then the put operation will fail.

      Parameters:
        `key` - key of the entry to store
        `value` - value of the entry to store

    - #### storeAll

          void storeAll(Map<K,V> map)

      Stores multiple entries.

      Implementation of this method can optimize the store operation by storing all entries in one database connection. storeAll() is used when writeDelaySeconds is positive (write-behind).If an exception is thrown, the entries will try to be stored one by one using the store() method.

      Note: on the retry phase only entries left in the map will be stored one-by-one. In this way a MapStore implementation can handle partial storeAll() cases when some entries were stored successfully before a failure happens. Entries removed from the map will be not passed to subsequent call to store() method any more.

      Parameters:
        `map` - map of entries to store

    - #### delete

          void delete(K key)

      Deletes the entry with a given key from the store.

      If an exception is thrown the remove operation will fail.

      Parameters:
        `key` - the key to delete from the store

    - #### deleteAll

          void deleteAll(Collection<K> keys)

      Deletes multiple entries from the store.

      If an exception is thrown the entries will try to be deleted one by one using the delete() method.

      Note: on the retry phase only entries left in the keys will be deleted one-by-one. In this way a MapStore implementation can handle partial deleteAll() cases when some entries were deleted successfully before a failure happens. Entries removed from the keys will be not passed to subsequent call to delete() method any more.

      Parameters:
        `keys` - the keys of the entries to delete.

Copyright © 2019. All rights reserved.