Package org.ehcache.spi.loaderwriter

Interface CacheLoaderWriter<K,​V>

  • Type Parameters:
    K - the key type processed by this loader-writer
    V - the value type processed by this loader-writer
    public interface CacheLoaderWriter<K,​V>
    A CacheLoaderWriter is used to keep a Cache in sync with another system.

    Instances of this class should be thread safe.

    Any Exception thrown by the loading methods of this interface will be wrapped into a CacheLoadingException by the Cache and will need to be handled by the user. Any java.lang.Exception thrown by the writing methods will be wrapped into a CacheWritingException.

    A similar thing will happen for the bulk version of the loading and writing methods and create the bulk version of the related exceptions.

    See Also:
    CacheLoadingException, CacheWritingException, BulkCacheLoadingException, BulkCacheWritingException

    • Method Summary

      All Methods Instance Methods Abstract Methods Default Methods 
      Modifier and Type Method Description
      void delete​(K key)
      Deletes a single mapping.
      default void deleteAll​(java.lang.Iterable<? extends K> keys)
      Deletes multiple mappings.
      V load​(K key)
      Loads a single value.
      default java.util.Map<K,​V> loadAll​(java.lang.Iterable<? extends K> keys)
      Loads multiple values.
      void write​(K key, V value)
      Writes a single mapping.
      default void writeAll​(java.lang.Iterable<? extends java.util.Map.Entry<? extends K,​? extends V>> entries)
      Writes multiple mappings.

    • Method Detail

      • load

        V load​(K key)
throws java.lang.Exception
        Loads a single value.

        When used with a cache any exception thrown by this method will be thrown back to the user as a CacheLoadingException.

        Parameters:
        key - the key for which to load the value
        Returns:
        the loaded value
        Throws:
        java.lang.Exception - if the value cannot be loaded

      • loadAll

        default java.util.Map<K,​V> loadAll​(java.lang.Iterable<? extends K> keys)
                                  throws BulkCacheLoadingException,
                                         java.lang.Exception
        Loads multiple values.

        The returned Map should contain null values for the keys that could not be found.

        When used with a cache the mappings that will be installed are the keys as found in keys mapped to the results of loadAllResult.get(key). Any other mappings will be ignored.

        By using a BulkCacheLoadingException implementors can report partial success. Any other exceptions will be thrown back to the Cache user through a BulkCacheLoadingException indicating a complete failure.

        Parameters:
        keys - the keys to load //Which null or not present?
        Returns:
        the Map of values for each key passed in, where no mapping means no value to map.
        Throws:
        BulkCacheLoadingException - in case of partial success
        java.lang.Exception - in case no values could be loaded

      • write

        void write​(K key,
           V value)
    throws java.lang.Exception
        Writes a single mapping.

        The write may represent a brand new value or an update to an existing value.

        When used with a Cache any exception thrown by this method will be thrown back to the user through a CacheWritingException.

        Parameters:
        key - the key to write
        value - the value to write
        Throws:
        java.lang.Exception - if the write operation failed

      • writeAll

        default void writeAll​(java.lang.Iterable<? extends java.util.Map.Entry<? extends K,​? extends V>> entries)
               throws BulkCacheWritingException,
                      java.lang.Exception
        Writes multiple mappings.

        The writes may represent a mix of brand new values and updates to existing values.

        By using a BulkCacheWritingException implementors can report partial success. Any other exception will be thrown back to the Cache user through a BulkCacheWritingException indicating a complete failure.

        Parameters:
        entries - the mappings to write
        Throws:
        BulkCacheWritingException - in case of partial success
        java.lang.Exception - in case no values could be written

      • delete

        void delete​(K key)
     throws java.lang.Exception
        Deletes a single mapping.
        Parameters:
        key - the key to delete
        Throws:
        java.lang.Exception - if the write operation failed

      • deleteAll

        default void deleteAll​(java.lang.Iterable<? extends K> keys)
                throws BulkCacheWritingException,
                       java.lang.Exception
        Deletes multiple mappings.

        By using a BulkCacheWritingException implementors can report partial success. Any other exception will be thrown back to the Cache user through a BulkCacheWritingException indicating all deletes failed.

        Parameters:
        keys - the keys to delete
        Throws:
        BulkCacheWritingException - in case of partial success
        java.lang.Exception - in case no values can be loaded