Interface StoreConfigurationChildBuilder<S>

    • Method Detail

      • async

        AsyncStoreConfigurationBuilder<S> async()
        Configuration for the async cache store. If enabled, this provides you with asynchronous writes to the cache store, giving you 'write-behind' caching.
      • fetchPersistentState

        S fetchPersistentState​(boolean b)
        If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled. Persistent state transfer with a shared cache store does not make sense, as the same persistent store that provides the data will just end up receiving it. Therefore, if a shared cache store is used, the cache will not allow a persistent state transfer even if a cache store has this property set to true. Finally, setting it to true only makes sense if in a clustered environment, and only 'replication' and 'invalidation' cluster modes are supported.
      • ignoreModifications

        S ignoreModifications​(boolean b)
        If true, any operation that modifies the cache (put, remove, clear, store...etc) won't be applied to the cache store. This means that the cache store could become out of sync with the cache.
      • purgeOnStartup

        S purgeOnStartup​(boolean b)
        If true, purges this cache store when it starts up.
      • preload

        S preload​(boolean b)
        If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
      • shared

        S shared​(boolean b)
        This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store.

        If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store. Note that this could be useful if each individual node has its own cache store - perhaps local on-disk.

      • transactional

        S transactional​(boolean b)
        This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and the cache's transaction rollingback.

        If enabled and this store is shared, then writes to this store will be performed at prepare time of the Infinispan Tx. If an exception is encountered by the store during prepare time, then this will result in the global Tx being rolledback along with this stores writes, otherwise writes to this store will be committed during the commit phase of 2PC. If this is not enabled, then writes to the cache store are performed during the commit phase of a Tx.

        Note that this requires shared(boolean) to be set to true.

      • maxBatchSize

        S maxBatchSize​(int maxBatchSize)
        The maximum size of a batch to be inserted/deleted from the store. If the value is less than one, then no upper limit is placed on the number of operations in a batch.
      • segmented

        S segmented​(boolean b)
        If true this store should either be non shared (segmenting can be done automatically for non shared stores) or the shared store must implement the SegmentedAdvancedLoadWriteStore interface. Segmented stores help performance for things that require viewing the entire contents of the store (eg. iteration, stream processing, state transfer, mass indexer). If the store doesn't provide constant time operations for methods such as CacheLoader.loadEntry(Object) or CacheWriter.write(MarshallableEntry) than segmenting this store could also improve performance of those operations.
        b - whether this store should be segmented
      • addProperty

        S addProperty​(java.lang.String key,
                      java.lang.String value)

        Defines a single property. Can be used multiple times to define all needed properties, but the full set is overridden by withProperties(java.util.Properties).

        These properties are passed directly to the cache store.

      • withProperties

        S withProperties​(java.util.Properties p)
        Properties passed to the cache store or loader