com.hazelcast.core

## Interface MapLoader<K,V>

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

      public interface 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, or simply a file based data store.

  `IMap.get(Object)` normally returns the value that is available in-memory. If the entry doesn't exist in-memory, Hazelcast returns `null`. If a Loader implementation is provided then, instead of returning `null`, Hazelcast will attempt to load the unknown entry by calling the implementation's `load(Object)` or `loadAll(Collection)` methods. Loaded entries will be placed into the distributed map and they will stay in-memory until they are explicitly removed or implicitly evicted (if eviction is configured).

  MapLoader implementations are executed by a partition thread, therefore care should be taken not to block the thread with an expensive operation or an operation that may potentially never return, the partition thread does not time out the operation. Whilst the partition thread is executing the MapLoader it is unable to respond to requests for data on any other structure that may reside in the same partition, or to respond to other partitions mapped to the same partition thread. For example a very slow MapLoader for one map could block a request for data on another map, or even a queue. It is therefore strongly recommended not to use MapLoader to call across a WAN or to a system which will take on average longer than a few milliseconds to respond.

  MapLoaders should not be used to perform cascading operations on other data structures via a `HazelcastInstance`, the MapLoader should only concern itself with the operation on the assigned map. If the MapLoader attempts to access another data structure on a different partition to the key used in the MapLoader, a `IllegalThreadStateException` is thrown. A MapLoader can only interact with other data structures that reside on the same partition.

  If a blocked partition thread is called from a Hazelcast Client the caller will also block indefinitely, for example `IMap.get(Object)`. If the same call is made from another cluster member the operation will eventually timeout with a `OperationTimeoutException`.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `V` | `load(K key)` Loads the value of a given key.
    `Map<K,V>` | `loadAll(Collection<K> keys)` Loads given keys.
    `Iterable<K>` | `loadAllKeys()` Loads all of the keys from the store.

- - ### Method Detail

    - #### load

          V load(K key)

      Loads the value of a given key. If distributed map doesn't contain the value for the given key then Hazelcast will call implementation's load (key) method to obtain the value. Implementation can use any means of loading the given key; such as an O/R mapping tool, simple SQL or reading a file etc.
      Parameters:
        `key,` - cannot be `null`
      Returns:
        value of the key; returning `null` value signals value missing in the underlying store

    - #### loadAll

          Map<K,V> loadAll(Collection<K> keys)

      Loads given keys. This is batch load operation so that implementation can optimize the multiple loads.

      For any key in the input keys, there should be a single mapping in the resulting map. Also the resulting map should not have any keys that are not part of the input keys.

      The given collection should not contain any `null` keys. The returned Map should not contain any `null` keys or values.

      Loading other items than what provided in `keys` prevents the map from being filled from the map store.

      Parameters:
        `keys` - keys of the values entries to load
      Returns:
        map of loaded key-value pairs.

    - #### loadAllKeys

          Iterable<K> loadAllKeys()

      Loads all of the keys from the store. The returned `Iterable` may return the keys lazily by loading them in batches. The `Iterator` of this `Iterable` may implement the `Closeable` interface in which case it will be closed once iteration is over. This is intended for releasing resources such as closing a JDBC result set.

      The returned Iterable should not contain any `null` keys.

      Returns:
        all the keys. Keys inside the Iterable cannot be `null`.

Copyright © 2020. All rights reserved.