All Classes and Interfaces
Class
Description
The
Aggregator interface for aggregating values of the given key.A read-only metadata class representing the state of the application and the current rebalance.
Assignment related configs for the Kafka Streams
TaskAssignor.Sets the
auto.offset.reset configuration when
adding a source processor
or when creating KStream or KTable via StreamsBuilder.Interface for batching restoration of a
StateStore
It is expected that implementations of this class will not call the StateRestoreCallback.restore(byte[], byte[]) method.The
Branched class is used to define the optional parameters when building branches with
BranchedKStream.Branches the records in the original stream based on the predicates supplied for the branch definitions.
Indicates that none of the specified
brokers
could be found.Collection of builtin
DslStoreSuppliers for Kafka Streams.A
DslStoreSuppliers that supplies all stores backed by an in-memory mapA
DslStoreSuppliers that supplies all stores backed by RocksDBCancellable interface returned in
ProcessingContext.schedule(Duration, PunctuationType, Punctuator).Encapsulates the
client instance id used for metrics collection by
producers, consumers, and the admin client used by Kafka Streams.CogroupedKStream is an abstraction of multiple grouped record streams of KeyValue pairs.Stores can register this callback to be notified upon successful commit.
Provides a set of
StoreBuilders that will be automatically added to the topology and connected to the
associated processor.The
Consumed class is used to define the optional parameters when using StreamsBuilder to
build instances of KStream, KTable, and GlobalKTable.An abstract implementation of
FixedKeyProcessor that manages the FixedKeyProcessorContext instance.An abstract implementation of
Processor that manages the ProcessorContext instance.ProductionExceptionHandler that always instructs streams to fail when an exception
happens while attempting to produce result records.Interface that specifies how an exception from source node deserialization
(e.g., reading from Kafka) should be handled.
Enumeration that describes the response from the exception handler.
DslKeyValueParams is a wrapper class for all parameters that function
as inputs to DslStoreSuppliers.keyValueStore(DslKeyValueParams).DslSessionParams is a wrapper class for all parameters that function
as inputs to DslStoreSuppliers.sessionStore(DslSessionParams).DslStoreSuppliers defines a grouping of factories to construct
stores for each of the types of state store implementations in Kafka
Streams.DslWindowParams is a wrapper class for all parameters that function
as inputs to DslStoreSuppliers.windowStore(DslWindowParams).This interface controls the strategy that can be used to control how we emit results in a processor.
This interface allows user code to inspect the context of a record that has failed during processing.
Retrieves embedded metadata timestamps from Kafka messages.
This enumeration type captures the various top-level reasons that a particular
partition of a store would fail to execute a query.
A processor of key-value pair records where keys are immutable.
Processor context interface for
FixedKeyRecord.A processor supplier that can create one or more
FixedKeyProcessor instances.A data class representing an incoming record with fixed key for processing in a
FixedKeyProcessor
or a record to forward to downstream processors via FixedKeyProcessorContext.The
ForeachAction interface for performing an action on a key-value
pair.Deprecated.
Since 4.0 and should not be used any longer.
GlobalKTable is an abstraction of a changelog stream from a primary-keyed table.The class that is used to capture the key and value
Serdes and set the part of name used for
repartition topics when performing KStream.groupBy(KeyValueMapper, Grouped), KStream.groupByKey(Grouped), or KTable.groupBy(KeyValueMapper, Grouped) operations.Represents a user defined endpoint in a
KafkaStreams application.The
Initializer interface for creating an initial value in aggregations.Indicates that there was a problem when trying to access a
StateStore.Indicates that the specific state store being queried via
StoreQueryParameters used a partitioning that is not assigned to this instance.The
Joined class represents optional params that can be passed to
KStream#join(KTable,...) and
KStream#leftJoin(KTable,...) operations.The window specifications used for joins.
KafkaClientSupplier can be used to provide custom Kafka clients to a KafkaStreams instance.A Kafka client that allows for performing continuous computation on input coming from one or more input topics and
sends output to zero, one, or more output topics.
Class that handles options passed in case of
KafkaStreams instance scale downKafka Streams states are the possible state that a Kafka Streams instance can be in.
Listen to
KafkaStreams.State change events.A simple container class for the assignor to return the desired placement of active and standby tasks on
KafkaStreams clients.
A read-only metadata class representing the current state of each KafkaStreams client with at least one StreamThread participating in this rebalance
Interactive query for retrieving a single record based on its key.
Represents all the metadata related to a key, where a particular key resides in a
KafkaStreams application.A key-value pair defined for a single Kafka Streams record.
A store supplier that can be used to create one or more
KeyValueStore<Bytes, byte[]> instances of type <Bytes, byte[]>.Iterator interface of
KeyValue.The
KeyValueMapper interface for mapping a key-value pair to a new value of arbitrary type.A key-value store that supports put/get/delete and range queries.
KGroupedStream is an abstraction of a grouped record stream of KeyValue pairs.KGroupedTable is an abstraction of a re-grouped changelog stream from a primary-keyed table,
usually on a different grouping key than the original primary key.KStream is an abstraction of a record stream of KeyValue pairs, i.e., each record is an
independent entity/event in the real world.KTable is an abstraction of a changelog stream from a primary-keyed table.Encapsulates information about lag, at a store partition replica (active or standby).
Indicates that the state store directory lock could not be acquired because another thread holds the lock.
Deserialization handler that logs a deserialization exception and then
signals the processing pipeline to continue processing more records.
Processing exception handler that logs a processing exception and then
signals the processing pipeline to continue processing more records.
Deserialization handler that logs a deserialization exception and then
signals the processing pipeline to stop processing more records and fail.
Processing exception handler that logs a processing exception and then
signals the processing pipeline to stop processing more records and fail.
Retrieves embedded metadata timestamps from Kafka messages.
Used to describe how a
StateStore should be materialized.The interface for merging aggregate values for
SessionWindows with the given key.Interactive query for retrieving a set of records with the same specified key and different timestamps within the specified time range.
A representation of a position vector with respect to a set of topic partitions.
A class bounding the processing state
Position during queries.The
Predicate interface represents a predicate (boolean-valued function) of a KeyValue pair.An object to define the options used when printing a
KStream.A simple wrapper around UUID that abstracts a Process ID
Processor context interface.
An interface that allows user code to inspect a record that has failed processing
A processor of key-value pair records.
Processor context interface for
Record.Processor context interface.
Indicates a processor state operation (e.g.
A processor supplier that can create one or more
Processor instances.Wrapper class that can be used to inject custom wrappers around the processors of their application topology.
This class is used to provide the optional parameters when producing to new topics
using
KStream.to(String, Produced).Interface that specifies how an exception when attempting to produce a result to
Kafka should be handled.
Controls what notion of time is used for punctuation scheduled via
schedule:
STREAM_TIME - uses "stream time", which is advanced by the processing of messages
in accordance with the timestamp as extracted by the TimestampExtractor in use.A functional interface used as an argument to
ProcessorContext.schedule(Duration, PunctuationType, Punctuator).Marker interface that all interactive queries must implement (see
KafkaStreams.query(StateQueryRequest)).Used to enable querying of custom
StateStore types via the KafkaStreams API.Provides access to the
QueryableStoreTypes provided with KafkaStreams.Runtime configuration parameters
Container for a single partition's result when executing a
StateQueryRequest.Interactive query for issuing range queries and scans over KeyValue stores.
A key-value store that only supports read operations.
A session store that only supports read operations.
A window store that only supports read operations.
A data class representing an incoming record for processing in a
Processor
or a record to forward to downstream processors via ProcessorContext.The context associated with the current record being processed by
a
ProcessorThe
Reducer interface for combining two values of the same type into a new value.This class is used to provide the optional parameters for internal repartition topics.
An interface to that allows developers to customize the RocksDB settings for a given Store.
A store supplier that can be used to create one or more
SessionStore<Byte, byte[]> instances.Interface for storing the aggregated values of sessions.
SessionWindowedCogroupKStream is an abstraction of a windowed record stream of KeyValue pairs.SessionWindowedKStream is an abstraction of a windowed record stream of KeyValue pairs.A session based window specification used for aggregating events into sessions.
A sliding window used for aggregating events.
The request object for Interactive Queries.
A progressive builder interface for creating
StoreQueryRequests.The response object for interactive queries.
Restoration logic for log-backed state stores upon restart,
it takes one record at a time from the logs to apply to the restoring state.
Class for listening to various states of the restoration process of a StateStore.
Factory for creating serializers / deserializers for state stores in Kafka Streams.
A storage engine for managing state maintained by a stream processor.
State store context interface.
Indicates that the state store being queried is closed although the Kafka Streams state is
RUNNING or
REBALANCING.Indicates that the state store being queried is already closed.
Build a
StateStore wrapped with optional caching and logging.StoreQueryParameters allows you to pass a variety of parameters when fetching a store for interactive query.Factory for creating state stores in Kafka Streams.
A state store supplier which can create one or more
StateStore instances.Class used to configure the name of the join processor, the repartition topic name,
state stores or state store names in Stream-Stream join.
Determine how records are distributed among the partitions in a Kafka topic.
StreamsBuilder provides the high-level Kafka Streams DSL to specify a Kafka Streams topology.Configuration for a
KafkaStreams instance.StreamsException is the top-level exception type generated by Kafka Streams, and indicates errors have
occurred during a StreamThread's processing.Metadata of a Kafka Streams client.
The Kafka Streams metrics interface for adding metric sensors and collecting metric values.
Indicates that Kafka Streams is in state
CREATED and thus state stores cannot be queries yet.Indicates that Kafka Streams is in state
REBALANCING and thus
cannot be queried by default.Indicates that Kafka Streams is in a terminating or terminal state, such as
KafkaStreams.State.PENDING_SHUTDOWN,KafkaStreams.State.PENDING_ERROR,KafkaStreams.State.NOT_RUNNING, or KafkaStreams.State.ERROR.Enumeration that describes the response from the exception handler.
Marker interface for a buffer configuration that will strictly enforce size constraints
(bytes and/or number of records) on the buffer, so it is suitable for reducing duplicate
results downstream, but does not promise to eliminate them entirely.
Marker interface for a buffer configuration that is "strict" in the sense that it will strictly
enforce the time bound and never emit early.
The
TableJoined class represents optional parameters that can be passed to
KTable#join(KTable,Function,...) and
KTable#leftJoin(KTable,Function,...)
operations, for foreign key joins.Indicates a run time error incurred while trying to assign
stream tasks to
threads.A set of utilities to help implement task assignment via the
TaskAssignorA simple config container for necessary parameters and optional overrides to apply when
running the active or standby task rack-aware optimizations.
A TaskAssignor is responsible for creating a TaskAssignment from a given
ApplicationState.NONE: no error detected
ACTIVE_TASK_ASSIGNED_MULTIPLE_TIMES: multiple KafkaStreams clients assigned with the same active task
INVALID_STANDBY_TASK: stateless task assigned as a standby task
MISSING_PROCESS_ID: ProcessId present in the input ApplicationState was not present in the output TaskAssignment
UNKNOWN_PROCESS_ID: unrecognized ProcessId not matching any of the participating consumers
UNKNOWN_TASK_ID: unrecognized TaskId not matching any of the tasks to be assigned
Wrapper class for the final assignment of active and standbys tasks to individual
KafkaStreams clients.
Indicates a specific task is corrupted and need to be re-initialized.
The task ID representation composed as subtopology plus the assigned partition ID.
Indicates a run time error incurred while trying parse the
task id
from the read string.A simple container class corresponding to a given
TaskId.Metadata of a task.
Indicates that all tasks belongs to the thread have migrated to another thread.
This is a simple container class used during the assignment process to distinguish
TopicPartitions type.
Metadata of a stream thread.
Interactive query for retrieving a single record based on its key from
TimestampedKeyValueStoreA key-(value/timestamp) store that supports put/get/delete and range queries.
Interactive query for issuing range queries and scans over
TimestampedKeyValueStoreInterface for storing the aggregated values of fixed-size time windows.
An interface that allows the Kafka Streams framework to extract a timestamp from an instance of
ConsumerRecord.TimeWindowedCogroupKStream is an abstraction of a windowed record stream of KeyValue pairs.TimeWindowedKStream is an abstraction of a windowed record stream of KeyValue pairs.The fixed-size time-based window specifications used for aggregations.
This class is used to provide the optional parameters when sending output records to downstream processor
using
ProcessorContext.forward(Object, Object, To).An interface that allows to dynamically determine the name of the Kafka topic to send at the sink node of the topology.
A logical representation of a
ProcessorTopology.Deprecated.
Since 4.0.
Streams configs that apply at the topology level.
A meta representation of a
topology.Represents a
global store.A node of a topology.
A processor node of a topology.
A sink node of a topology.
A source node of a topology.
A connected sub-graph of a
Topology.Indicates a pre run time error occurred while parsing the
logical topology
to construct the physical processor topology.Deprecated.
Since 4.0.
Deprecated.
Since 4.0.
Indicates that the state store being queried is unknown, i.e., the state store does either not exist in your topology
or it is not queryable.
Indicates that the
NamedTopology being
looked up does not exist in this applicationThe unlimited window specifications used for aggregations.
Retrieves embedded metadata timestamps from Kafka messages.
Combines a value from a
KeyValue with a timestamp.The
ValueJoiner interface for joining two values into a new value of arbitrary type.The
ValueJoinerWithKey interface for joining two values into a new value of arbitrary type.The
ValueMapper interface for mapping a value to a new value of arbitrary type.The
ValueMapperWithKey interface for mapping a value to a new value of arbitrary type.Deprecated.
Since 4.0.
Deprecated.
Since 4.0.
The
ValueTransformerWithKey interface for stateful mapping of a value to a new value (with possible new type).A
ValueTransformerWithKeySupplier interface which can create one or more ValueTransformerWithKey instances.A representation of a versioned key-value store as a
KeyValueStore of type <Bytes, byte[]>.A store supplier that can be used to create one or more versioned key-value stores,
specifically,
VersionedBytesStore instances.Interactive query for retrieving a single record from a versioned state store based on its key and timestamp.
A key-value store that stores multiple record versions per key, and supports timestamp-based
retrieval operations to return the latest record (per key) as of a specified timestamp.
Combines a value (from a key-value record) with a timestamp, for use as the return type
from
VersionedKeyValueStore.get(Object, long) and related methods.Iterator interface of
VersionedRecord.Retrieves current wall clock timestamps as
System.currentTimeMillis().A single window instance, defined by its start and end timestamp.
A store supplier that can be used to create one or more
WindowStore<Byte, byte[]> instances of type <Byte, byte[]>.The result key type of a windowed stream aggregation.
The window specification for fixed size windows that is used to define window boundaries and grace period.
Interface for storing the aggregated values of fixed-size time windows.
Iterator interface of
KeyValue with key typed Long used for WindowStore.fetch(Object, long, long)
and WindowStore.fetch(Object, Instant, Instant)
Users must call its close method explicitly upon completeness to release resources,
or use try-with-resources statement (available since JDK7) for this Closeable class.Marker interface for classes implementing
FixedKeyProcessorSupplier
that have been wrapped via a ProcessorWrapper.Marker interface for classes implementing
ProcessorSupplier
that have been wrapped via a ProcessorWrapper.