Infinispan 15.1 API

Package
Description
This is the core of Infinispan, a distributed, transactional, highly scalable data grid platform.
This package contains the KeyAffinityService interfaces which allow user code to determine mapping of keys onto nodes
 
Support for batching calls using the BatchingCache.startBatch() and BatchingCache.endBatch(boolean) API.
 
Hot Rod client API.
Hot Rod client annotations.
Hot Rod client configuration API.
 
 
Hot Rod client remote event API.
 
Hot Rod client exceptions.
 
 
 
 
 
 
 
 
 
 
 
Commands that operate on the cache, either locally or remotely.
Commons package
Commons API package
 
Commons Configuration package
 
 
 
 
 
 
 
Commons Executors package
Commons Hash package
 
Commons IO package
 
Pluggable lookup for MBeanServer.
 
Provides Infinispan-specific input and output streams, buffers and related utilities.
Provides Infinispan-specific extensions to the marshallers.
 
 
 
 
 
 
 
Commons package providing various utility classes
Provides commons interfaces and classes related to concurrency
 
 
Cache configuration
 
EmbeddedCacheManager configuration
 
 
This package contains the APIs that enable users to search for, and amend, data inconsistencies within their cache.
Package that contains the interface describing the underlyling API for storage in Infinispan
Entries which are stored in data containers.
 
 
Data containers which store cache entries.
 
 
 
Contexts contain information of a specific invocation on the cache, such as its origins, scope (transactional or non-transactional), as well as invocation-specific flags.
This package contains different context implementations, selected dynamically based on the type of invocation.
 
Clustered Counters API.
 
Clustered Counters Exceptions.
 
 
 
Classes relating to the distributed cache mode.
Consistent Hash interfaces
 
Groups allow keys with differeing hash codes to be co-located on the same node.
 
 
 
 
 
 
Classes related to eviction.
 
Implementations of different executors used for asynchronous operation.
Cache expiration.
 
 
Factories are internal components used to create other components based on a cache's configuration.
Internal annotations to control the lifecycle of cache components.
 
Scopes of components within the lifespan of a cache manager and its caches, and related utilities.
 
Provides capabilities around filtering and converting entries that are found in the cache or cache store/loader.
Functional API package
 
Global configuration state.
 
 
 
 
Infinispan is designed around a set of interceptors around a data container.
 
Hooks to bridge Infinispan's marshalling APIs with JBoss Marshalling internals.
 
 
Helpers that allow easy exposure of attributes and operations via JMX.
Module and component lifecycle.
Embedded Clustered Locks.
Clustered Locks API.
 
Clustered Locks Exceptions.
 
 
Cache manager API.
 
 
Externalizers for various JDK types that are marshalled using the marshalling framework.
 
Metadata interfaces
 
Micrometer based metrics.
 
MultimapCache API.
Embedded Multimap Cache.
 
Notifications and eventing for listeners on both the Cache and CacheManager interfaces.
Cache-specific notifications and eventing.
Cache-specific listener annotations
 
 
invalid reference
Cache
-specific listener events
 
Cache-specific notifications and eventing filtering classes.
invalid reference
CacheManager
-specific notifications and eventing.
EmbeddedCacheManager-specific listener annotations
EmbeddedCacheManager-specific listener events
 
 
Querying on plain Java objects.
 
 
Persistence API.
 
A CacheLoader (not CacheWriter) that polls other nodes in the cluster for state.
Simple filesystem-based CacheWriter implementation.
 
This package contains a AdvancedLoadWriteStore implementation based on a JDBC database connection.
This package contains a AdvancedLoadWriteStore implementation based on a JDBC database connection.
Common configuration for JDBC cache stores.
 
 
 
 
Configuration for the JDBC CacheStore.
 
JDBC CacheStore implementation which maps keys to strings.
 
Modifications that are used to encapsulate cache operations for application to a
invalid reference
CacheStore
.
Hot Rod-based AdvancedLoadWriteStore.
Configuration for RemoteStore.
 
 
 
 
 
 
RocksDB-based AdvancedLoadWriteStore.
Configuration for RocksDBStore.
 
 
Configuration for
invalid reference
org.infinispan.persistence.sifs.SoftIndexFileStore
.
 
The Persistence SPI.
This package contains a AdvancedLoadWriteStore implementation based on a JDBC database connection.
 
 
 
Query API that lets you perform Ickle queries and look up values in caches.
Continuous querying API.
 
Query DSL API.
Query module internals.
 
 
Server-side remote query components.
Query client support classes.
 
 
 
 
 
 
Remote communication between cache instances.
 
Abstractions of the different response types allowed during RPC.
Remote Procedure Call (RPC) interfaces and components used to invoke remote methods on cache instances.
Transports handle the low-level networking, used by the remoting components.
 
A transport implementation based on JGroups.
REST Server bootstrap and Netty bridge classes.
Authentication API for REST.
 
 
REST Server Configuration API
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Security API.
 
 
 
 
 
 
 
 
 
Core Server Configuration API
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
HotRod Server Configuration API
 
 
 
 
 
 
 
 
 
 
 
 
 
Memcached Server Configuration API
 
 
Cache statistics.
 
Cache stream processing.
 
Server tasks API.
 
 
 
 
JTA transaction support.
 
Interfaces and implementations of lookup classes to locate and/or instantiate JTA
invalid reference
javax.transaction.TransactionManager
s.
 
Infinispan's bare-bones internal transaction manager, used for batching calls as well as as a dummy, unit-test-only transaction manager.
XA transaction support.
 
 
General utilities that are not specific to Infinispan, including string parsing helpers, reflection tools and collections and containers designed to supplement the JDK-provided containers.
Thread-safe containers and other concurrency-related utilities, designed to supplement JDK concurrency utilities and containers.
Lock and synchronization related classes, tools and utilities.
 
 
Infinispan's logging abstractions that delegate to either JDK or Log4J logging engines.
 
 
 
 
 
 
 
Cross-Site Replication conflict resolution.