StoreConfigurationChildBuilder

All Superinterfaces:

ConfigurationChildBuilder

All Known Subinterfaces:

RemoteStoreConfigurationChildBuilder<S>, RestStoreConfigurationChildBuilder<S>, StoreConfigurationBuilder<T,S>

All Known Implementing Classes:

AbstractJdbcStoreConfigurationBuilder, AbstractJdbcStoreConfigurationChildBuilder, AbstractRemoteStoreConfigurationChildBuilder, AbstractRestStoreConfigurationChildBuilder, AbstractSecurityConfigurationChildBuilder, AbstractStoreConfigurationBuilder, AbstractStoreConfigurationChildBuilder, AsyncStoreConfigurationBuilder, AuthenticationConfigurationBuilder, ClusterLoaderConfigurationBuilder, ConnectionPoolConfigurationBuilder, ConnectionPoolConfigurationBuilder, CustomStoreConfigurationBuilder, ExecutorFactoryConfigurationBuilder, JdbcStringBasedStoreConfigurationBuilder, JdbcStringBasedStoreConfigurationBuilder.StringTableManipulationConfigurationBuilder, JpaStoreConfigurationBuilder, ManagedConnectionFactoryConfigurationBuilder, PooledConnectionFactoryConfigurationBuilder, RemoteServerConfigurationBuilder, RemoteStoreConfigurationBuilder, RestStoreConfigurationBuilder, RocksDBStoreConfigurationBuilder, SecurityConfigurationBuilder, SimpleConnectionFactoryConfigurationBuilder, SingleFileStoreConfigurationBuilder, SingletonStoreConfigurationBuilder, SoftIndexFileStoreConfigurationBuilder, SslConfigurationBuilder, TableManipulationConfigurationBuilder
```
public interface StoreConfigurationChildBuilder<S>
extends ConfigurationChildBuilder
```

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`S`	`addProperty(java.lang.String key, java.lang.String value)` Defines a single property.
`AsyncStoreConfigurationBuilder<S>`	`async()` Configuration for the async cache store.
`S`	`fetchPersistentState(boolean b)` If true, fetch persistent state when joining a cluster.
`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.
`S`	`maxBatchSize(int maxBatchSize)` The maximum size of a batch to be inserted/deleted from the store.
`S`	`preload(boolean b)` If true, when the cache starts, data stored in the cache store will be pre-loaded into memory.
`S`	`purgeOnStartup(boolean b)` If true, purges this cache store when it starts up.
`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.
`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.
`SingletonStoreConfigurationBuilder<S>`	`singleton()` Deprecated. Singleton writers will be removed in 10.0. If it is desirable that all nodes don't write to the underlying store then a shared store should be used instead, as this only performs store writes at a key's primary owner.
`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.
`S`	`withProperties(java.util.Properties p)` Properties passed to the cache store or loader

Methods inherited from interface org.infinispan.configuration.cache.ConfigurationChildBuilder
build, clustering, compatibility, customInterceptors, dataContainer, deadlockDetection, encoding, eviction, expiration, indexing, invocationBatching, jmxStatistics, locking, memory, persistence, security, simpleCache, simpleCache, sites, storeAsBinary, template, transaction, unsafe, validate, versioning

- 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.
  - singleton
```
@Deprecated
SingletonStoreConfigurationBuilder<S> singleton()
```
    Deprecated. Singleton writers will be removed in 10.0. If it is desirable that all nodes don't write to the underlying store then a shared store should be used instead, as this only performs store writes at a key's primary owner.
    
    SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store. The coordinator of the cluster will be responsible for the underlying CacheStore. SingletonStore is a simply facade to a real CacheStore implementation. It always delegates reads to the real CacheStore.
  - 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.
    
    Parameters:
    
    b - whether this store should be segmented
    
    Returns:
    
    this
  - 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

Interface StoreConfigurationChildBuilder<S>

Method Summary

Methods inherited from interface org.infinispan.configuration.cache.ConfigurationChildBuilder

Method Detail

async

singleton

fetchPersistentState

ignoreModifications

purgeOnStartup

preload

shared

transactional

maxBatchSize

segmented

addProperty

withProperties