This is an automated email from the ASF dual-hosted git repository.
guozhang pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/trunk by this push:
new 8ae9857 KAFKA-7768: Use absolute paths for javadoc (#6100)
8ae9857 is described below
commit 8ae985705f8e16e64e1cd66bbfd38ac57d875cb7
Author: John Roesler <vvcep...@users.noreply.github.com>
AuthorDate: Mon Jan 7 15:30:49 2019 -0600
KAFKA-7768: Use absolute paths for javadoc (#6100)
Reviewers: Guozhang Wang <wangg...@gmail.com>
---
docs/streams/developer-guide/app-reset-tool.html | 2 +-
docs/streams/developer-guide/config-streams.html | 30 +++---
docs/streams/developer-guide/dsl-api.html | 112 ++++++++++-----------
.../developer-guide/interactive-queries.html | 6 +-
docs/streams/developer-guide/processor-api.html | 6 +-
5 files changed, 78 insertions(+), 78 deletions(-)
diff --git a/docs/streams/developer-guide/app-reset-tool.html
b/docs/streams/developer-guide/app-reset-tool.html
index 10cfffb..f42235a 100644
--- a/docs/streams/developer-guide/app-reset-tool.html
+++ b/docs/streams/developer-guide/app-reset-tool.html
@@ -141,7 +141,7 @@
use either of these methods:</p>
<ul class="simple">
<li>The API method <code class="docutils literal"><span
class="pre">KafkaStreams#cleanUp()</span></code> in your application code.</li>
- <li>Manually delete the corresponding local state directory
(default location: <code class="docutils literal"><span
class="pre">/tmp/kafka-streams/<application.id></span></code>). For more
information, see <a
href="../../../{{version}}/javadoc/org/apache/kafka/streams/StreamsConfig.html#STATE_DIR_CONFIG">Streams</a>
javadocs.</li>
+ <li>Manually delete the corresponding local state directory
(default location: <code class="docutils literal"><span
class="pre">/tmp/kafka-streams/<application.id></span></code>). For more
information, see <a
href="/{{version}}/javadoc/org/apache/kafka/streams/StreamsConfig.html#STATE_DIR_CONFIG">Streams</a>
javadocs.</li>
</ul>
</div>
</div>
diff --git a/docs/streams/developer-guide/config-streams.html
b/docs/streams/developer-guide/config-streams.html
index 9472b4f..918399d 100644
--- a/docs/streams/developer-guide/config-streams.html
+++ b/docs/streams/developer-guide/config-streams.html
@@ -54,7 +54,7 @@
</ol>
<div class="section" id="configuration-parameter-reference">
<span
id="streams-developer-guide-required-configs"></span><h2>Configuration
parameter reference<a class="headerlink"
href="#configuration-parameter-reference" title="Permalink to this
headline"></a></h2>
- <p>This section contains the most common Streams configuration
parameters. For a full reference, see the <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/StreamsConfig.html">Streams</a>
Javadocs.</p>
+ <p>This section contains the most common Streams configuration
parameters. For a full reference, see the <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/StreamsConfig.html">Streams</a>
Javadocs.</p>
<div class="contents local topic" id="contents">
<ul class="simple">
<li><a class="reference internal"
href="#required-configuration-parameters" id="id3">Required configuration
parameters</a><ul>
@@ -149,7 +149,7 @@
</div>
<div class="section" id="optional-configuration-parameters">
<span id="streams-developer-guide-optional-configs"></span><h3><a
class="toc-backref" href="#id6">Optional configuration parameters</a><a
class="headerlink" href="#optional-configuration-parameters" title="Permalink
to this headline"></a></h3>
- <p>Here are the optional <a
href="../../../{{version}}/javadoc/org/apache/kafka/streams/StreamsConfig.html">Streams</a>
javadocs, sorted by level of importance:</p>
+ <p>Here are the optional <a
href="/{{version}}/javadoc/org/apache/kafka/streams/StreamsConfig.html">Streams</a>
javadocs, sorted by level of importance:</p>
<blockquote>
<div><ul class="simple">
<li>High: These parameters can have a significant impact on
performance. Take care when deciding the values of these parameters.</li>
@@ -305,11 +305,11 @@
<code>FAIL</code> will signal that Streams should shut down and
<code>CONTINUE</code> will signal that Streams should ignore the issue
and continue processing. The following library built-in
exception handlers are available:</p>
<ul class="simple">
- <li><a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/errors/LogAndContinueExceptionHandler.html">LogAndContinueExceptionHandler</a>:
+ <li><a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/errors/LogAndContinueExceptionHandler.html">LogAndContinueExceptionHandler</a>:
This handler logs the deserialization exception and then
signals the processing pipeline to continue processing more records.
This log-and-skip strategy allows Kafka Streams to make
progress instead of failing if there are records that fail
to deserialize.</li>
- <li><a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/errors/LogAndFailExceptionHandler.html">LogAndFailExceptionHandler</a>.
+ <li><a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/errors/LogAndFailExceptionHandler.html">LogAndFailExceptionHandler</a>.
This handler logs the deserialization exception and then
signals the processing pipeline to stop processing more records.</li>
</ul>
@@ -354,7 +354,7 @@
<span id="streams-developer-guide-peh"></span><h4><a
class="toc-backref" href="#id24">default.production.exception.handler</a><a
class="headerlink" href="#default-production-exception-handler"
title="Permalink to this headline"></a></h4>
<blockquote>
<div><p>The default production exception handler allows you to
manage exceptions triggered when trying to interact with a broker
- such as attempting to produce a record that is too large. By
default, Kafka provides and uses the <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/errors/DefaultProductionExceptionHandler.html">DefaultProductionExceptionHandler</a>
+ such as attempting to produce a record that is too large. By
default, Kafka provides and uses the <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/errors/DefaultProductionExceptionHandler.html">DefaultProductionExceptionHandler</a>
that always fails when these exceptions occur.</p>
<p>Each exception handler can return a <code>FAIL</code> or
<code>CONTINUE</code> depending on the record and the exception thrown.
Returning <code>FAIL</code> will signal that Streams should shut down and
<code>CONTINUE</code> will signal that Streams
@@ -439,7 +439,7 @@
<span id="streams-developer-guide-partition-grouper"></span><h4><a
class="toc-backref" href="#id12">partition.grouper</a><a class="headerlink"
href="#partition-grouper" title="Permalink to this headline"></a></h4>
<blockquote>
<div>A partition grouper creates a list of stream tasks from the
partitions of source topics, where each created task is assigned with a group
of source topic partitions.
- The default implementation provided by Kafka Streams is <a
class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/processor/DefaultPartitionGrouper.html">DefaultPartitionGrouper</a>.
+ The default implementation provided by Kafka Streams is <a
class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/processor/DefaultPartitionGrouper.html">DefaultPartitionGrouper</a>.
It assigns each task with one partition for each of the source
topic partitions. The generated number of tasks equals the largest
number of partitions among the input topics. Usually an
application does not need to customize the partition grouper.</div></blockquote>
</div>
@@ -479,10 +479,10 @@
<div class="section" id="timestamp-extractor">
<span id="streams-developer-guide-timestamp-extractor"></span><h4><a
class="toc-backref" href="#id15">timestamp.extractor</a><a class="headerlink"
href="#timestamp-extractor" title="Permalink to this headline"></a></h4>
<blockquote>
- <div><p>A timestamp extractor pulls a timestamp from an instance
of <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/clients/consumer/ConsumerRecord.html">ConsumerRecord</a>.
+ <div><p>A timestamp extractor pulls a timestamp from an instance
of <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/clients/consumer/ConsumerRecord.html">ConsumerRecord</a>.
Timestamps are used to control the progress of streams.</p>
<p>The default extractor is
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/processor/FailOnInvalidTimestamp.html">FailOnInvalidTimestamp</a>.
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/processor/FailOnInvalidTimestamp.html">FailOnInvalidTimestamp</a>.
This extractor retrieves built-in timestamps that are
automatically embedded into Kafka messages by the Kafka producer
client since
<a class="reference external"
href="https://cwiki.apache.org/confluence/display/KAFKA/KIP-32+-+Add+timestamps+to+Kafka+message";>Kafka
version 0.10</a>.
@@ -504,19 +504,19 @@
<p>If you have data with invalid timestamps and want to process
it, then there are two alternative extractors available.
Both work on built-in timestamps, but handle invalid
timestamps differently.</p>
<ul class="simple">
- <li><a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/processor/LogAndSkipOnInvalidTimestamp.html">LogAndSkipOnInvalidTimestamp</a>:
+ <li><a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/processor/LogAndSkipOnInvalidTimestamp.html">LogAndSkipOnInvalidTimestamp</a>:
This extractor logs a warn message and returns the invalid
timestamp to Kafka Streams, which will not process but
silently drop the record.
This log-and-skip strategy allows Kafka Streams to make
progress instead of failing if there are records with an
invalid built-in timestamp in your input data.</li>
- <li><a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/processor/UsePreviousTimeOnInvalidTimestamp.html">UsePreviousTimeOnInvalidTimestamp</a>.
+ <li><a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/processor/UsePreviousTimeOnInvalidTimestamp.html">UsePreviousTimeOnInvalidTimestamp</a>.
This extractor returns the record’s built-in timestamp
if it is valid (i.e. not negative). If the record does not
have a valid built-in timestamps, the extractor returns the
previously extracted valid timestamp from a record of the
same topic partition as the current record as a timestamp
estimation. In case that no timestamp can be estimated, it
throws an exception.</li>
</ul>
<p>Another built-in extractor is
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/processor/WallclockTimestampExtractor.html">WallclockTimestampExtractor</a>.
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/processor/WallclockTimestampExtractor.html">WallclockTimestampExtractor</a>.
This extractor does not actually “extract” a
timestamp from the consumed record but rather returns the current time in
milliseconds from the system clock (think: <code
class="docutils literal"><span
class="pre">System.currentTimeMillis()</span></code>), which effectively means
Streams will operate
on the basis of the so-called <strong>processing-time</strong>
of events.</p>
@@ -568,10 +568,10 @@
</div>
<div class="section"
id="kafka-consumers-and-producer-configuration-parameters">
<h3><a class="toc-backref" href="#id16">Kafka consumers, producer and
admin client configuration parameters</a><a class="headerlink"
href="#kafka-consumers-and-producer-configuration-parameters" title="Permalink
to this headline"></a></h3>
- <p>You can specify parameters for the Kafka <a class="reference
external"
href="../../../{{version}}/javadoc/org/apache/kafka/clients/consumer/package-summary.html">consumers</a>,
<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/clients/producer/package-summary.html">producers</a>,
- and <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/kafka/clients/admin/package-summary.html">admin
client</a> that are used internally.
+ <p>You can specify parameters for the Kafka <a class="reference
external"
href="/{{version}}/javadoc/org/apache/kafka/clients/consumer/package-summary.html">consumers</a>,
<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/clients/producer/package-summary.html">producers</a>,
+ and <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/kafka/clients/admin/package-summary.html">admin
client</a> that are used internally.
The consumer, producer and admin client settings are defined by
specifying parameters in a <code class="docutils literal"><span
class="pre">StreamsConfig</span></code> instance.</p>
- <p>In this example, the Kafka <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/clients/consumer/ConsumerConfig.html#SESSION_TIMEOUT_MS_CONFIG">consumer
session timeout</a> is configured to be 60000 milliseconds in the Streams
settings:</p>
+ <p>In this example, the Kafka <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/clients/consumer/ConsumerConfig.html#SESSION_TIMEOUT_MS_CONFIG">consumer
session timeout</a> is configured to be 60000 milliseconds in the Streams
settings:</p>
<div class="highlight-java"><div
class="highlight"><pre><span></span><span class="n">Properties</span> <span
class="n">streamsSettings</span> <span class="o">=</span> <span
class="k">new</span> <span class="n">Properties</span><span class="o">();</span>
<span class="c1">// Example of a "normal" setting for Kafka
Streams</span>
<span class="n">streamsSettings</span><span class="o">.</span><span
class="na">put</span><span class="o">(</span><span
class="n">StreamsConfig</span><span class="o">.</span><span
class="na">BOOTSTRAP_SERVERS_CONFIG</span><span class="o">,</span> <span
class="s">"kafka-broker-01:9092"</span><span class="o">);</span>
@@ -680,7 +680,7 @@
<span id="streams-developer-guide-rocksdb-config"></span><h4><a
class="toc-backref" href="#id20">rocksdb.config.setter</a><a class="headerlink"
href="#rocksdb-config-setter" title="Permalink to this headline"></a></h4>
<blockquote>
<div><p>The RocksDB configuration. Kafka Streams uses RocksDB as
the default storage engine for persistent stores. To change the default
- configuration for RocksDB, implement <code class="docutils
literal"><span class="pre">RocksDBConfigSetter</span></code> and provide your
custom class via <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/state/RocksDBConfigSetter.html">rocksdb.config.setter</a>.</p>
+ configuration for RocksDB, implement <code class="docutils
literal"><span class="pre">RocksDBConfigSetter</span></code> and provide your
custom class via <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/state/RocksDBConfigSetter.html">rocksdb.config.setter</a>.</p>
<p>Here is an example that adjusts the memory size consumed by
RocksDB.</p>
<div class="highlight-java"><div
class="highlight"><pre><span></span> <span class="kd">public</span> <span
class="kd">static</span> <span class="kd">class</span> <span
class="nc">CustomRocksDBConfig</span> <span class="kd">implements</span> <span
class="n">RocksDBConfigSetter</span> <span class="o">{</span>
diff --git a/docs/streams/developer-guide/dsl-api.html
b/docs/streams/developer-guide/dsl-api.html
index 2961bf5..0ddcbc5 100644
--- a/docs/streams/developer-guide/dsl-api.html
+++ b/docs/streams/developer-guide/dsl-api.html
@@ -104,7 +104,7 @@
</ol>
<p>After the application is run, the defined processor topologies
are continuously executed (i.e., the processing plan is put into
action). A step-by-step guide for writing a stream processing
application using the DSL is provided below.</p>
- <p>For a complete list of available API functionality, see also
the <a
href="../../../{{version}}/javadoc/org/apache/kafka/streams/package-summary.html">Streams</a>
API docs.</p>
+ <p>For a complete list of available API functionality, see also
the <a
href="/{{version}}/javadoc/org/apache/kafka/streams/package-summary.html">Streams</a>
API docs.</p>
</div>
<div class="section" id="dsl-core-constructs-overview">
@@ -236,7 +236,7 @@
<td><p class="first">Creates a <a class="reference
internal" href="#streams_concepts_kstream"><span class="std
std-ref">KStream</span></a> from the specified Kafka input topics and
interprets the data
as a <a class="reference internal"
href="#streams_concepts_kstream"><span class="std std-ref">record
stream</span></a>.
A <code class="docutils literal"><span
class="pre">KStream</span></code> represents a <em>partitioned</em> record
stream.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/StreamsBuilder.html#stream(java.lang.String)">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/StreamsBuilder.html#stream(java.lang.String)">(details)</a></p>
<p>In the case of a KStream, the local KStream
instance of every application instance will
be populated with data from only <strong>a
subset</strong> of the partitions of the input topic. Collectively, across
all application instances, all input topic
partitions are read and processed.</p>
@@ -270,7 +270,7 @@
<td><p class="first">Reads the specified Kafka input topic
into a <a class="reference internal" href="#streams_concepts_ktable"><span
class="std std-ref">KTable</span></a>. The topic is
interpreted as a changelog stream, where records with
the same key are interpreted as UPSERT aka INSERT/UPDATE
(when the record value is not <code class="docutils
literal"><span class="pre">null</span></code>) or as DELETE (when the value is
<code class="docutils literal"><span class="pre">null</span></code>) for that
key.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/StreamsBuilder.html#table-java.lang.String(java.lang.String)">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/StreamsBuilder.html#table-java.lang.String(java.lang.String)">(details)</a></p>
<p>In the case of a KTable, the local KTable instance
of every application instance will
be populated with data from only <strong>a
subset</strong> of the partitions of the input topic. Collectively, across
all application instances, all input topic
partitions are read and processed.</p>
@@ -295,7 +295,7 @@
<td><p class="first">Reads the specified Kafka input topic
into a <a class="reference internal"
href="#streams_concepts_globalktable"><span class="std
std-ref">GlobalKTable</span></a>. The topic is
interpreted as a changelog stream, where records with
the same key are interpreted as UPSERT aka INSERT/UPDATE
(when the record value is not <code class="docutils
literal"><span class="pre">null</span></code>) or as DELETE (when the value is
<code class="docutils literal"><span class="pre">null</span></code>) for that
key.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/StreamsBuilder.html#globalTable-java.lang.String(java.lang.String)">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/StreamsBuilder.html#globalTable-java.lang.String(java.lang.String)">(details)</a></p>
<p>In the case of a GlobalKTable, the local
GlobalKTable instance of every application instance will
be populated with data from <strong>all</strong>
the partitions of the input topic.</p>
<p>You must provide a name for the table (more
precisely, for the internal
@@ -366,7 +366,7 @@
</ul>
</td>
<td><p class="first">Branch (or split) a <code
class="docutils literal"><span class="pre">KStream</span></code> based on the
supplied predicates into one or more <code class="docutils literal"><span
class="pre">KStream</span></code> instances.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#branch-org.apache.kafka.streams.kstream.Predicate...-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#branch-org.apache.kafka.streams.kstream.Predicate...-">details</a>)</p>
<p>Predicates are evaluated in order. A record is
placed to one and only one output stream on the first match:
if the n-th predicate evaluates to true, the
record is placed to n-th stream. If no predicate matches, the
the record is dropped.</p>
@@ -394,8 +394,8 @@
</ul>
</td>
<td><p class="first">Evaluates a boolean function for
each element and retains those for which the function returns true.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#filter-org.apache.kafka.streams.kstream.Predicate-">KStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#filter-org.apache.kafka.streams.kstream.Predicate-">KTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#filter-org.apache.kafka.streams.kstream.Predicate-">KStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#filter-org.apache.kafka.streams.kstream.Predicate-">KTable
details</a>)</p>
<div class="last highlight-java"><div
class="highlight"><pre><span></span><span class="n">KStream</span><span
class="o"><</span><span class="n">String</span><span class="o">,</span>
<span class="n">Long</span><span class="o">></span> <span
class="n">stream</span> <span class="o">=</span> <span class="o">...;</span>
<span class="c1">// A filter that selects (keeps) only positive numbers</span>
@@ -421,8 +421,8 @@
</ul>
</td>
<td><p class="first">Evaluates a boolean function for
each element and drops those for which the function returns true.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#filterNot-org.apache.kafka.streams.kstream.Predicate-">KStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#filterNot-org.apache.kafka.streams.kstream.Predicate-">KTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#filterNot-org.apache.kafka.streams.kstream.Predicate-">KStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#filterNot-org.apache.kafka.streams.kstream.Predicate-">KTable
details</a>)</p>
<div class="last highlight-java"><div
class="highlight"><pre><span></span><span class="n">KStream</span><span
class="o"><</span><span class="n">String</span><span class="o">,</span>
<span class="n">Long</span><span class="o">></span> <span
class="n">stream</span> <span class="o">=</span> <span class="o">...;</span>
<span class="c1">// An inverse filter that discards any negative numbers or
zero</span>
@@ -448,7 +448,7 @@
</td>
<td><p class="first">Takes one record and produces
zero, one, or more records. You can modify the record keys and values,
including
their types.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#flatMap-org.apache.kafka.streams.kstream.KeyValueMapper-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#flatMap-org.apache.kafka.streams.kstream.KeyValueMapper-">details</a>)</p>
<p><strong>Marks the stream for data
re-partitioning:</strong>
Applying a grouping or a join after <code
class="docutils literal"><span class="pre">flatMap</span></code> will result in
re-partitioning of the records.
If possible use <code class="docutils
literal"><span class="pre">flatMapValues</span></code> instead, which will not
cause data re-partitioning.</p>
@@ -477,7 +477,7 @@
</td>
<td><p class="first">Takes one record and produces
zero, one, or more records, while retaining the key of the original record.
You can modify the record values and the value
type.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#flatMapValues-org.apache.kafka.streams.kstream.ValueMapper-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#flatMapValues-org.apache.kafka.streams.kstream.ValueMapper-">details</a>)</p>
<p><code class="docutils literal"><span
class="pre">flatMapValues</span></code> is preferable to <code class="docutils
literal"><span class="pre">flatMap</span></code> because it will not cause data
re-partitioning. However, you
cannot modify the key or key type like <code
class="docutils literal"><span class="pre">flatMap</span></code> does.</p>
<div class="last highlight-java"><div
class="highlight"><pre><span></span><span class="c1">// Split a sentence into
words.</span>
@@ -497,7 +497,7 @@
</ul>
</td>
<td><p class="first"><strong>Terminal
operation.</strong> Performs a stateless action on each record.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#foreach-org.apache.kafka.streams.kstream.ForeachAction-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#foreach-org.apache.kafka.streams.kstream.ForeachAction-">details</a>)</p>
<p>You would use <code class="docutils
literal"><span class="pre">foreach</span></code> to cause <em>side effects</em>
based on the input data (similar to <code class="docutils literal"><span
class="pre">peek</span></code>) and then <em>stop</em>
<em>further processing</em> of the input data
(unlike <code class="docutils literal"><span class="pre">peek</span></code>,
which is not a terminal operation).</p>
<p><strong>Note on processing guarantees:</strong>
Any side effects of an action (such as writing to external systems) are not
@@ -526,7 +526,7 @@
</ul>
</td>
<td><p class="first">Groups the records by the
existing key.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#groupByKey--">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#groupByKey--">details</a>)</p>
<p>Grouping is a prerequisite for <a
class="reference internal"
href="#streams-developer-guide-dsl-aggregating"><span class="std
std-ref">aggregating a stream or a table</span></a>
and ensures that data is properly partitioned
(“keyed”) for subsequent operations.</p>
<p><strong>When to set explicit SerDes:</strong>
@@ -571,8 +571,8 @@
<td><p class="first">Groups the records by a
<em>new</em> key, which may be of a different key type.
When grouping a table, you may also specify a new
value and value type.
<code class="docutils literal"><span
class="pre">groupBy</span></code> is a shorthand for <code class="docutils
literal"><span class="pre">selectKey(...).groupByKey()</span></code>.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#groupBy-org.apache.kafka.streams.kstream.KeyValueMapper-">KStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#groupBy-org.apache.kafka.streams.kstream.KeyValueMapper-">KTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#groupBy-org.apache.kafka.streams.kstream.KeyValueMapper-">KStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#groupBy-org.apache.kafka.streams.kstream.KeyValueMapper-">KTable
details</a>)</p>
<p>Grouping is a prerequisite for <a
class="reference internal"
href="#streams-developer-guide-dsl-aggregating"><span class="std
std-ref">aggregating a stream or a table</span></a>
and ensures that data is properly partitioned
(“keyed”) for subsequent operations.</p>
<p><strong>When to set explicit SerDes:</strong>
@@ -648,7 +648,7 @@
</ul>
</td>
<td><p class="first">Takes one record and produces one
record. You can modify the record key and value, including their types.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#map-org.apache.kafka.streams.kstream.KeyValueMapper-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#map-org.apache.kafka.streams.kstream.KeyValueMapper-">details</a>)</p>
<p><strong>Marks the stream for data
re-partitioning:</strong>
Applying a grouping or a join after <code
class="docutils literal"><span class="pre">map</span></code> will result in
re-partitioning of the records.
If possible use <code class="docutils
literal"><span class="pre">mapValues</span></code> instead, which will not
cause data re-partitioning.</p>
@@ -680,8 +680,8 @@
</td>
<td><p class="first">Takes one record and produces one
record, while retaining the key of the original record.
You can modify the record value and the value type.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#mapValues-org.apache.kafka.streams.kstream.ValueMapper-">KStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#mapValues-org.apache.kafka.streams.kstream.ValueMapper-">KTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#mapValues-org.apache.kafka.streams.kstream.ValueMapper-">KStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#mapValues-org.apache.kafka.streams.kstream.ValueMapper-">KTable
details</a>)</p>
<p><code class="docutils literal"><span
class="pre">mapValues</span></code> is preferable to <code class="docutils
literal"><span class="pre">map</span></code> because it will not cause data
re-partitioning. However, it does not
allow you to modify the key or key type like
<code class="docutils literal"><span class="pre">map</span></code> does.</p>
<div class="last highlight-java"><div
class="highlight"><pre><span></span><span class="n">KStream</span><span
class="o"><</span><span class="kt">byte</span><span class="o">[],</span>
<span class="n">String</span><span class="o">></span> <span
class="n">stream</span> <span class="o">=</span> <span class="o">...;</span>
@@ -708,7 +708,7 @@
</td>
<td><p class="first">Merges records of two streams
into one larger stream.
(<a class="reference external"
-
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#merge-org.apache.kafka.streams.kstream.KStream-">details</a>)
+
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#merge-org.apache.kafka.streams.kstream.KStream-">details</a>)
<p>There is no ordering guarantee between records
from different streams in the merged stream.
Relative order is preserved within each input stream though (ie, records within
the same input stream are processed in order)</p>
<div class="last highlight-java">
@@ -730,7 +730,7 @@
</ul>
</td>
<td><p class="first">Performs a stateless action on
each record, and returns an unchanged stream.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#peek-org.apache.kafka.streams.kstream.ForeachAction-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#peek-org.apache.kafka.streams.kstream.ForeachAction-">details</a>)</p>
<p>You would use <code class="docutils
literal"><span class="pre">peek</span></code> to cause <em>side effects</em>
based on the input data (similar to <code class="docutils literal"><span
class="pre">foreach</span></code>) and <em>continue</em>
<em>processing</em> the input data (unlike
<code class="docutils literal"><span class="pre">foreach</span></code>, which
is a terminal operation). <code class="docutils literal"><span
class="pre">peek</span></code> returns the input
stream as-is; if you need to modify the input
stream, use <code class="docutils literal"><span class="pre">map</span></code>
or <code class="docutils literal"><span class="pre">mapValues</span></code>
instead.</p>
@@ -762,7 +762,7 @@
</td>
<td><p class="first"><strong>Terminal
operation.</strong> Prints the records to <code class="docutils literal"><span
class="pre">System.out</span></code>. See Javadocs for serde and <code
class="docutils literal"><span class="pre">toString()</span></code>
caveats.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#print--">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#print--">details</a>)</p>
<p>Calling <code class="docutils literal"><span
class="pre">print()</span></code> is the same as calling <code class="docutils
literal"><span class="pre">foreach((key,</span> <span class="pre">value)</span>
<span class="pre">-></span> <span class="pre">System.out.println(key</span>
<span class="pre">+</span> <span class="pre">",</span> <span
class="pre">"</span> <span class="pre">+</span> <span
class="pre">value))</span></code></p>
<p><code class="docutils literal"><span
class="pre">print</span></code> is mainly for debugging/testing purposes, and
it will try to flush on each record print. Hence it <strong>should not</strong>
be used for production usage if performance requirements are concerned.</p>
<div class="last highlight-java"><div
class="highlight"><pre><span></span><span class="n">KStream</span><span
class="o"><</span><span class="kt">byte</span><span class="o">[],</span>
<span class="n">String</span><span class="o">></span> <span
class="n">stream</span> <span class="o">=</span> <span class="o">...;</span>
@@ -781,7 +781,7 @@
</ul>
</td>
<td><p class="first">Assigns a new key –
possibly of a new key type – to each record.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#selectKey-org.apache.kafka.streams.kstream.KeyValueMapper-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#selectKey-org.apache.kafka.streams.kstream.KeyValueMapper-">details</a>)</p>
<p>Calling <code class="docutils literal"><span
class="pre">selectKey(mapper)</span></code> is the same as calling <code
class="docutils literal"><span class="pre">map((key,</span> <span
class="pre">value)</span> <span class="pre">-></span> <span
class="pre">mapper(key,</span> <span class="pre">value),</span> <span
class="pre">value)</span></code>.</p>
<p><strong>Marks the stream for data
re-partitioning:</strong>
Applying a grouping or a join after <code
class="docutils literal"><span class="pre">selectKey</span></code> will result
in re-partitioning of the records.</p>
@@ -809,7 +809,7 @@
</ul>
</td>
<td><p class="first">Get the changelog stream of this
table.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#toStream--">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#toStream--">details</a>)</p>
<div class="last highlight-java"><div
class="highlight"><pre><span></span><span class="n">KTable</span><span
class="o"><</span><span class="kt">byte</span><span class="o">[],</span>
<span class="n">String</span><span class="o">></span> <span
class="n">table</span> <span class="o">=</span> <span class="o">...;</span>
<span class="c1">// Also, a variant of `toStream` exists that allows you</span>
@@ -913,8 +913,8 @@
<td><p class="first"><strong>Rolling
aggregation.</strong> Aggregates the values of (non-windowed) records by the
grouped key.
Aggregating is a generalization of <code
class="docutils literal"><span class="pre">reduce</span></code> and allows, for
example, the aggregate value to have a different
type than the input values.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedStream.html">KGroupedStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedTable.html">KGroupedTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedStream.html">KGroupedStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedTable.html">KGroupedTable
details</a>)</p>
<p>When aggregating a <em>grouped stream</em>,
you must provide an initializer (e.g., <code class="docutils literal"><span
class="pre">aggValue</span> <span class="pre">=</span> <span
class="pre">0</span></code>) and an “adder”
aggregator (e.g., <code class="docutils
literal"><span class="pre">aggValue</span> <span class="pre">+</span> <span
class="pre">curValue</span></code>). When aggregating a <em>grouped
table</em>, you must provide a
“subtractor” aggregator
(think: <code class="docutils literal"><span class="pre">aggValue</span> <span
class="pre">-</span> <span class="pre">oldValue</span></code>).</p>
@@ -1016,8 +1016,8 @@
Aggregates the values of records, <a
class="reference internal" href="#streams-developer-guide-dsl-windowing"><span
class="std std-ref">per window</span></a>, by the grouped key.
Aggregating is a generalization of <code
class="docutils literal"><span class="pre">reduce</span></code> and allows, for
example, the aggregate value to have a different
type than the input values.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/TimeWindowedKStream.html">TimeWindowedKStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/SessionWindowedKStream.html">SessionWindowedKStream
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/TimeWindowedKStream.html">TimeWindowedKStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/SessionWindowedKStream.html">SessionWindowedKStream
details</a>)</p>
<p>You must provide an initializer (e.g.,
<code class="docutils literal"><span class="pre">aggValue</span> <span
class="pre">=</span> <span class="pre">0</span></code>), “adder”
aggregator (e.g., <code class="docutils literal"><span
class="pre">aggValue</span> <span class="pre">+</span> <span
class="pre">curValue</span></code>),
and a window. When windowing based on
sessions, you must additionally provide a “session merger”
aggregator
(e.g., <code class="docutils
literal"><span class="pre">mergedAggValue</span> <span class="pre">=</span>
<span class="pre">leftAggValue</span> <span class="pre">+</span> <span
class="pre">rightAggValue</span></code>).</p>
@@ -1111,8 +1111,8 @@
</ul>
</td>
<td><p class="first"><strong>Rolling
aggregation.</strong> Counts the number of records by the grouped key.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedStream.html">KGroupedStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedTable.html">KGroupedTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedStream.html">KGroupedStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedTable.html">KGroupedTable
details</a>)</p>
<p>Several variants of <code class="docutils
literal"><span class="pre">count</span></code> exist, see Javadocs for
details.</p>
<div class="highlight-java"><div
class="highlight"><pre><span></span><span class="n">KGroupedStream</span><span
class="o"><</span><span class="n">String</span><span class="o">,</span>
<span class="n">Long</span><span class="o">></span> <span
class="n">groupedStream</span> <span class="o">=</span> <span
class="o">...;</span>
<span class="n">KGroupedTable</span><span class="o"><</span><span
class="n">String</span><span class="o">,</span> <span
class="n">Long</span><span class="o">></span> <span
class="n">groupedTable</span> <span class="o">=</span> <span
class="o">...;</span>
@@ -1142,8 +1142,8 @@
</td>
<td><p class="first"><strong>Windowed
aggregation.</strong>
Counts the number of records, <a
class="reference internal" href="#streams-developer-guide-dsl-windowing"><span
class="std std-ref">per window</span></a>, by the grouped key.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/TimeWindowedKStream.html">TimeWindowedKStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/SessionWindowedKStream.html">SessionWindowedKStream
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/TimeWindowedKStream.html">TimeWindowedKStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/SessionWindowedKStream.html">SessionWindowedKStream
details</a>)</p>
<p>The windowed <code class="docutils
literal"><span class="pre">count</span></code> turns a <code class="docutils
literal"><span class="pre">TimeWindowedKStream<K,</span> <span
class="pre">V></span></code> or <code class="docutils literal"><span
class="pre">SessionWindowedKStream<K,</span> <span
class="pre">V></span></code>
into a windowed <code class="docutils
literal"><span class="pre">KTable<Windowed<K>,</span> <span
class="pre">V></span></code>.</p>
<p>Several variants of <code class="docutils
literal"><span class="pre">count</span></code> exist, see Javadocs for
details.</p>
@@ -1176,8 +1176,8 @@
<td><p class="first"><strong>Rolling
aggregation.</strong> Combines the values of (non-windowed) records by the
grouped key.
The current record value is combined with the
last reduced value, and a new reduced value is returned.
The result value type cannot be changed,
unlike <code class="docutils literal"><span class="pre">aggregate</span></code>.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedStream.html">KGroupedStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedTable.html">KGroupedTable
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedStream.html">KGroupedStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KGroupedTable.html">KGroupedTable
details</a>)</p>
<p>When reducing a <em>grouped stream</em>,
you must provide an “adder” reducer (e.g., <code class="docutils
literal"><span class="pre">aggValue</span> <span class="pre">+</span> <span
class="pre">curValue</span></code>).
When reducing a <em>grouped table</em>,
you must additionally provide a “subtractor” reducer (e.g.,
<code class="docutils literal"><span
class="pre">aggValue</span> <span class="pre">-</span> <span
class="pre">oldValue</span></code>).</p>
@@ -1260,8 +1260,8 @@
The current record value is combined with the
last reduced value, and a new reduced value is returned.
Records with <code class="docutils
literal"><span class="pre">null</span></code> key or value are ignored.
The result value type cannot be changed,
unlike <code class="docutils literal"><span class="pre">aggregate</span></code>.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/TimeWindowedKStream.html">TimeWindowedKStream
details</a>,
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/SessionWindowedKStream.html">SessionWindowedKStream
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/TimeWindowedKStream.html">TimeWindowedKStream
details</a>,
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/SessionWindowedKStream.html">SessionWindowedKStream
details</a>)</p>
<p>The windowed <code class="docutils
literal"><span class="pre">reduce</span></code> turns a turns a <code
class="docutils literal"><span class="pre">TimeWindowedKStream<K,</span>
<span class="pre">V></span></code> or a <code class="docutils literal"><span
class="pre">SessionWindowedKStream<K,</span> <span
class="pre">V></span></code>
into a windowed <code class="docutils
literal"><span class="pre">KTable<Windowed<K>,</span> <span
class="pre">V></span></code>.</p>
<p>Several variants of <code class="docutils
literal"><span class="pre">reduce</span></code> exist, see Javadocs for
details.</p>
@@ -1760,7 +1760,7 @@
</td>
<td><p class="first">Performs an INNER JOIN of
this stream with another stream.
Even though this operation is windowed,
the joined stream will be of type <code class="docutils literal"><span
class="pre">KStream<K,</span> <span class="pre">...></span></code> rather
than <code class="docutils literal"><span
class="pre">KStream<Windowed<K>,</span> <span
class="pre">...></span></code>.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#join-org.apache.kafka.streams.kstream.KStream-org.apache.kafka.streams.kstream.ValueJoiner-org.apache.kafka.streams.kstream.JoinWindows-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#join-org.apache.kafka.streams.kstream.KStream-org.apache.kafka.streams.kstream.ValueJoiner-org.apache.kafka.streams.kstream.JoinWindows-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<p><strong>Causes data re-partitioning of
a stream if and only if the stream was marked for re-partitioning (if both are
marked, both are re-partitioned).</strong></p>
<p>Several variants of <code
class="docutils literal"><span class="pre">join</span></code> exists, see the
Javadocs for details.</p>
@@ -1819,7 +1819,7 @@
</td>
<td><p class="first">Performs a LEFT JOIN of
this stream with another stream.
Even though this operation is windowed,
the joined stream will be of type <code class="docutils literal"><span
class="pre">KStream<K,</span> <span class="pre">...></span></code> rather
than <code class="docutils literal"><span
class="pre">KStream<Windowed<K>,</span> <span
class="pre">...></span></code>.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#leftJoin-org.apache.kafka.streams.kstream.KStream-org.apache.kafka.streams.kstream.ValueJoiner-org.apache.kafka.streams.kstream.JoinWindows-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#leftJoin-org.apache.kafka.streams.kstream.KStream-org.apache.kafka.streams.kstream.ValueJoiner-org.apache.kafka.streams.kstream.JoinWindows-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<p><strong>Causes data re-partitioning of
a stream if and only if the stream was marked for re-partitioning (if both are
marked, both are re-partitioned).</strong></p>
<p>Several variants of <code
class="docutils literal"><span class="pre">leftJoin</span></code> exists, see
the Javadocs for details.</p>
@@ -1881,7 +1881,7 @@
</td>
<td><p class="first">Performs an OUTER JOIN of
this stream with another stream.
Even though this operation is windowed,
the joined stream will be of type <code class="docutils literal"><span
class="pre">KStream<K,</span> <span class="pre">...></span></code> rather
than <code class="docutils literal"><span
class="pre">KStream<Windowed<K>,</span> <span
class="pre">...></span></code>.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#outerJoin-org.apache.kafka.streams.kstream.KStream-org.apache.kafka.streams.kstream.ValueJoiner-org.apache.kafka.streams.kstream.JoinWindows-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#outerJoin-org.apache.kafka.streams.kstream.KStream-org.apache.kafka.streams.kstream.ValueJoiner-org.apache.kafka.streams.kstream.JoinWindows-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<p><strong>Causes data re-partitioning of
a stream if and only if the stream was marked for re-partitioning (if both are
marked, both are re-partitioned).</strong></p>
<p>Several variants of <code
class="docutils literal"><span class="pre">outerJoin</span></code> exists, see
the Javadocs for details.</p>
@@ -1942,7 +1942,7 @@
The semantics of the various stream-stream join
variants are explained below.
To improve the readability of the table, assume
that (1) all records have the same key (and thus the key in the table is
omitted), (2) all records belong to a single join window, and (3) all records
are processed in timestamp order.
The columns INNER JOIN, LEFT JOIN, and OUTER JOIN
denote what is passed as arguments to the user-supplied
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/ValueJoiner.html">ValueJoiner</a>
for the <code class="docutils literal"><span class="pre">join</span></code>,
<code class="docutils literal"><span class="pre">leftJoin</span></code>, and
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/ValueJoiner.html">ValueJoiner</a>
for the <code class="docutils literal"><span class="pre">join</span></code>,
<code class="docutils literal"><span class="pre">leftJoin</span></code>, and
<code class="docutils literal"><span
class="pre">outerJoin</span></code> methods, respectively, whenever a new input
record is received on either side of the join. An empty table
cell denotes that the <code class="docutils
literal"><span class="pre">ValueJoiner</span></code> is not called at all.</p>
<table border="1" class="docutils">
@@ -2100,7 +2100,7 @@
</td>
<td><p class="first">Performs an INNER JOIN of
this table with another table.
The result is an ever-updating KTable that
represents the “current” result of the join.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#join-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#join-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<div class="highlight-java"><div
class="highlight"><pre><span></span><span class="n">KTable</span><span
class="o"><</span><span class="n">String</span><span class="o">,</span>
<span class="n">Long</span><span class="o">></span> <span
class="n">left</span> <span class="o">=</span> <span class="o">...;</span>
<span class="n">KTable</span><span class="o"><</span><span
class="n">String</span><span class="o">,</span> <span
class="n">Double</span><span class="o">></span> <span class="n">right</span>
<span class="o">=</span> <span class="o">...;</span>
@@ -2146,7 +2146,7 @@
</ul>
</td>
<td><p class="first">Performs a LEFT JOIN of
this table with another table.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#leftJoin-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#leftJoin-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<div class="highlight-java"><div
class="highlight"><pre><span></span><span class="n">KTable</span><span
class="o"><</span><span class="n">String</span><span class="o">,</span>
<span class="n">Long</span><span class="o">></span> <span
class="n">left</span> <span class="o">=</span> <span class="o">...;</span>
<span class="n">KTable</span><span class="o"><</span><span
class="n">String</span><span class="o">,</span> <span
class="n">Double</span><span class="o">></span> <span class="n">right</span>
<span class="o">=</span> <span class="o">...;</span>
@@ -2195,7 +2195,7 @@
</ul>
</td>
<td><p class="first">Performs an OUTER JOIN of
this table with another table.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#outerJoin-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KTable.html#outerJoin-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<div class="highlight-java"><div
class="highlight"><pre><span></span><span class="n">KTable</span><span
class="o"><</span><span class="n">String</span><span class="o">,</span>
<span class="n">Long</span><span class="o">></span> <span
class="n">left</span> <span class="o">=</span> <span class="o">...;</span>
<span class="n">KTable</span><span class="o"><</span><span
class="n">String</span><span class="o">,</span> <span
class="n">Double</span><span class="o">></span> <span class="n">right</span>
<span class="o">=</span> <span class="o">...;</span>
@@ -2244,7 +2244,7 @@
The semantics of the various table-table join
variants are explained below.
To improve the readability of the table, you can
assume that (1) all records have the same key (and thus the key in the table is
omitted) and that (2) all records are processed in timestamp order.
The columns INNER JOIN, LEFT JOIN, and OUTER JOIN
denote what is passed as arguments to the user-supplied
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/ValueJoiner.html">ValueJoiner</a>
for the <code class="docutils literal"><span class="pre">join</span></code>,
<code class="docutils literal"><span class="pre">leftJoin</span></code>, and
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/ValueJoiner.html">ValueJoiner</a>
for the <code class="docutils literal"><span class="pre">join</span></code>,
<code class="docutils literal"><span class="pre">leftJoin</span></code>, and
<code class="docutils literal"><span
class="pre">outerJoin</span></code> methods, respectively, whenever a new input
record is received on either side of the join. An empty table
cell denotes that the <code class="docutils
literal"><span class="pre">ValueJoiner</span></code> is not called at all.</p>
<table border="1" class="docutils">
@@ -2408,7 +2408,7 @@
</ul>
</td>
<td><p class="first">Performs an INNER JOIN of
this stream with the table, effectively doing a table lookup.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#join-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#join-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<p><strong>Causes data re-partitioning of
the stream if and only if the stream was marked for
re-partitioning.</strong></p>
<p>Several variants of <code
class="docutils literal"><span class="pre">join</span></code> exists, see the
Javadocs for details.</p>
@@ -2461,7 +2461,7 @@
</ul>
</td>
<td><p class="first">Performs a LEFT JOIN of
this stream with the table, effectively doing a table lookup.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#leftJoin-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#leftJoin-org.apache.kafka.streams.kstream.KTable-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p><strong>Data must be
co-partitioned</strong>: The input data for both sides must be <a
class="reference internal"
href="#streams-developer-guide-dsl-joins-co-partitioning"><span class="std
std-ref">co-partitioned</span></a>.</p>
<p><strong>Causes data re-partitioning of
the stream if and only if the stream was marked for
re-partitioning.</strong></p>
<p>Several variants of <code
class="docutils literal"><span class="pre">leftJoin</span></code> exists, see
the Javadocs for details.</p>
@@ -2517,7 +2517,7 @@
To improve the readability of the table we assume
that (1) all records have the same key (and thus we omit the key in
the table) and that (2) all records are processed
in timestamp order.
The columns INNER JOIN and LEFT JOIN denote what
is passed as arguments to the user-supplied
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/ValueJoiner.html">ValueJoiner</a>
for the <code class="docutils literal"><span class="pre">join</span></code>
and <code class="docutils literal"><span class="pre">leftJoin</span></code>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/ValueJoiner.html">ValueJoiner</a>
for the <code class="docutils literal"><span class="pre">join</span></code>
and <code class="docutils literal"><span class="pre">leftJoin</span></code>
methods, respectively, whenever a new input record
is received on either side of the join. An empty table
cell denotes that the <code class="docutils
literal"><span class="pre">ValueJoiner</span></code> is not called at all.</p>
<table border="1" class="docutils">
@@ -2679,7 +2679,7 @@
</ul>
</td>
<td><p class="first">Performs an INNER JOIN of
this stream with the global table, effectively doing a table lookup.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#join-org.apache.kafka.streams.kstream.GlobalKTable-org.apache.kafka.streams.kstream.KeyValueMapper-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#join-org.apache.kafka.streams.kstream.GlobalKTable-org.apache.kafka.streams.kstream.KeyValueMapper-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p>The <code class="docutils
literal"><span class="pre">GlobalKTable</span></code> is fully bootstrapped
upon (re)start of a <code class="docutils literal"><span
class="pre">KafkaStreams</span></code> instance, which means the table is fully
populated with all the data in the underlying topic that is
available at the time of the startup.
The actual data processing begins only once the bootstrapping has completed.</p>
<p><strong>Causes data re-partitioning of
the stream if and only if the stream was marked for
re-partitioning.</strong></p>
@@ -2733,7 +2733,7 @@
</ul>
</td>
<td><p class="first">Performs a LEFT JOIN of
this stream with the global table, effectively doing a table lookup.
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#leftJoin-org.apache.kafka.streams.kstream.GlobalKTable-org.apache.kafka.streams.kstream.KeyValueMapper-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#leftJoin-org.apache.kafka.streams.kstream.GlobalKTable-org.apache.kafka.streams.kstream.KeyValueMapper-org.apache.kafka.streams.kstream.ValueJoiner-">(details)</a></p>
<p>The <code class="docutils
literal"><span class="pre">GlobalKTable</span></code> is fully bootstrapped
upon (re)start of a <code class="docutils literal"><span
class="pre">KafkaStreams</span></code> instance, which means the table is fully
populated with all the data in the underlying topic that is
available at the time of the startup.
The actual data processing begins only once the bootstrapping has completed.</p>
<p><strong>Causes data re-partitioning of
the stream if and only if the stream was marked for
re-partitioning.</strong></p>
@@ -3076,11 +3076,11 @@ grouped
</td>
<td><p class="first"><strong>Terminal
operation.</strong> Applies a <code class="docutils literal"><span
class="pre">Processor</span></code> to each record.
<code class="docutils literal"><span
class="pre">process()</span></code> allows you to leverage the <a
class="reference internal"
href="processor-api.html#streams-developer-guide-processor-api"><span
class="std std-ref">Processor API</span></a> from the DSL.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#process-org.apache.kafka.streams.processor.ProcessorSupplier-java.lang.String...-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#process-org.apache.kafka.streams.processor.ProcessorSupplier-java.lang.String...-">details</a>)</p>
<p>This is essentially equivalent to adding the
<code class="docutils literal"><span class="pre">Processor</span></code> via
<code class="docutils literal"><span
class="pre">Topology#addProcessor()</span></code> to your
<a class="reference internal"
href="../core-concepts.html#streams_topology"><span class="std
std-ref">processor topology</span></a>.</p>
<p class="last">An example is available in the
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#process-org.apache.kafka.streams.processor.ProcessorSupplier-java.lang.String...-">javadocs</a>.</p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#process-org.apache.kafka.streams.processor.ProcessorSupplier-java.lang.String...-">javadocs</a>.</p>
</td>
</tr>
<tr class="row-odd"><td><p
class="first"><strong>Transform</strong></p>
@@ -3090,7 +3090,7 @@ grouped
</td>
<td><p class="first">Applies a <code class="docutils
literal"><span class="pre">Transformer</span></code> to each record.
<code class="docutils literal"><span
class="pre">transform()</span></code> allows you to leverage the <a
class="reference internal"
href="processor-api.html#streams-developer-guide-processor-api"><span
class="std std-ref">Processor API</span></a> from the DSL.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transform-org.apache.kafka.streams.kstream.TransformerSupplier-java.lang.String...-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transform-org.apache.kafka.streams.kstream.TransformerSupplier-java.lang.String...-">details</a>)</p>
<p>Each input record is transformed into zero,
one, or more output records (similar to the stateless <code class="docutils
literal"><span class="pre">flatMap</span></code>).
The <code class="docutils literal"><span
class="pre">Transformer</span></code> must return <code class="docutils
literal"><span class="pre">null</span></code> for zero output.
You can modify the record’s key and
value, including their types.</p>
@@ -3100,7 +3100,7 @@ grouped
<p><code class="docutils literal"><span
class="pre">transform</span></code> is essentially equivalent to adding the
<code class="docutils literal"><span class="pre">Transformer</span></code> via
<code class="docutils literal"><span
class="pre">Topology#addProcessor()</span></code> to your
<a class="reference internal"
href="../core-concepts.html#streams_topology"><span class="std
std-ref">processor topology</span></a>.</p>
<p class="last">An example is available in the
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transform-org.apache.kafka.streams.kstream.TransformerSupplier-java.lang.String...-">javadocs</a>.
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transform-org.apache.kafka.streams.kstream.TransformerSupplier-java.lang.String...-">javadocs</a>.
</p>
</td>
</tr>
@@ -3112,14 +3112,14 @@ grouped
</td>
<td><p class="first">Applies a <code class="docutils
literal"><span class="pre">ValueTransformer</span></code> to each record, while
retaining the key of the original record.
<code class="docutils literal"><span
class="pre">transformValues()</span></code> allows you to leverage the <a
class="reference internal"
href="processor-api.html#streams-developer-guide-processor-api"><span
class="std std-ref">Processor API</span></a> from the DSL.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transformValues-org.apache.kafka.streams.kstream.ValueTransformerSupplier-java.lang.String...-">details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transformValues-org.apache.kafka.streams.kstream.ValueTransformerSupplier-java.lang.String...-">details</a>)</p>
<p>Each input record is transformed into exactly
one output record (zero output records or multiple output records are not
possible).
The <code class="docutils literal"><span
class="pre">ValueTransformer</span></code> may return <code class="docutils
literal"><span class="pre">null</span></code> as the new value for a record.</p>
<p><code class="docutils literal"><span
class="pre">transformValues</span></code> is preferable to <code
class="docutils literal"><span class="pre">transform</span></code> because it
will not cause data re-partitioning.</p>
<p><code class="docutils literal"><span
class="pre">transformValues</span></code> is essentially equivalent to adding
the <code class="docutils literal"><span
class="pre">ValueTransformer</span></code> via <code class="docutils
literal"><span class="pre">Topology#addProcessor()</span></code> to your
<a class="reference internal"
href="../core-concepts.html#streams_topology"><span class="std
std-ref">processor topology</span></a>.</p>
<p class="last">An example is available in the
- <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transformValues-org.apache.kafka.streams.kstream.ValueTransformerSupplier-java.lang.String...-">javadocs</a>.</p>
+ <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#transformValues-org.apache.kafka.streams.kstream.ValueTransformerSupplier-java.lang.String...-">javadocs</a>.</p>
</td>
</tr>
</tbody>
@@ -3269,7 +3269,7 @@ groupedTable
</ul>
</td>
<td><p class="first"><strong>Terminal operation.</strong>
Write the records to Kafka topic(s).
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#to(java.lang.String)">KStream
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#to(java.lang.String)">KStream
details</a>)</p>
<p>When to provide serdes explicitly:</p>
<ul class="simple">
<li>If you do not specify SerDes explicitly, the
default SerDes from the
@@ -3318,7 +3318,7 @@ groupedTable
</td>
<td><p class="first">Write the records to a Kafka topic
and create a new stream/table from that topic.
Essentially a shorthand for <code class="docutils
literal"><span class="pre">KStream#to()</span></code> followed by <code
class="docutils literal"><span
class="pre">StreamsBuilder#stream()</span></code>, same for tables.
- (<a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#through(java.lang.String)">KStream
details</a>)</p>
+ (<a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/kstream/KStream.html#through(java.lang.String)">KStream
details</a>)</p>
<p>When to provide SerDes explicitly:</p>
<ul class="simple">
<li>If you do not specify SerDes explicitly, the
default SerDes from the
diff --git a/docs/streams/developer-guide/interactive-queries.html
b/docs/streams/developer-guide/interactive-queries.html
index 8d6177a..8d8143f 100644
--- a/docs/streams/developer-guide/interactive-queries.html
+++ b/docs/streams/developer-guide/interactive-queries.html
@@ -371,7 +371,7 @@ interactive queries</span></p>
<p>To enable remote state store discovery in a distributed
Kafka Streams application, you must set the <a class="reference internal"
href="config-streams.html#streams-developer-guide-required-configs"><span
class="std std-ref">configuration property</span></a> in the config properties.
The <code class="docutils literal"><span
class="pre">application.server</span></code> property defines a unique <code
class="docutils literal"><span class="pre">host:port</span></code> pair that
points to the RPC endpoint of the respective instance of a Kafka Streams
application.
The value of this configuration property will vary across
the instances of your application.
- When this property is set, Kafka Streams will keep track
of the RPC endpoint information for every instance of an application, its state
stores, and assigned stream partitions through instances of <a class="reference
external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/state/StreamsMetadata.html">StreamsMetadata</a>.</p>
+ When this property is set, Kafka Streams will keep track
of the RPC endpoint information for every instance of an application, its state
stores, and assigned stream partitions through instances of <a class="reference
external"
href="/{{version}}/javadoc/org/apache/kafka/streams/state/StreamsMetadata.html">StreamsMetadata</a>.</p>
<div class="admonition tip">
<p><b>Tip</b></p>
<p class="last">Consider leveraging the exposed RPC
endpoints of your application for further functionality, such as
@@ -416,7 +416,7 @@ interactive queries</span></p>
</div>
<div class="section"
id="discovering-and-accessing-application-instances-and-their-local-state-stores">
<span
id="streams-developer-guide-interactive-queries-discover-app-instances-and-stores"></span><h3><a
class="toc-backref" href="#id10">Discovering and accessing application
instances and their local state stores</a><a class="headerlink"
href="#discovering-and-accessing-application-instances-and-their-local-state-stores"
title="Permalink to this headline"></a></h3>
- <p>The following methods return <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/state/StreamsMetadata.html">StreamsMetadata</a>
objects, which provide meta-information about application instances such as
their RPC endpoint and locally available state stores.</p>
+ <p>The following methods return <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/state/StreamsMetadata.html">StreamsMetadata</a>
objects, which provide meta-information about application instances such as
their RPC endpoint and locally available state stores.</p>
<ul class="simple">
<li><code class="docutils literal"><span
class="pre">KafkaStreams#allMetadata()</span></code>: find all instances of
this application</li>
<li><code class="docutils literal"><span
class="pre">KafkaStreams#allMetadataForStore(String</span> <span
class="pre">storeName)</span></code>: find those applications instances that
manage local instances of the state store “storeName”</li>
@@ -425,7 +425,7 @@ interactive queries</span></p>
</ul>
<div class="admonition attention">
<p class="first admonition-title">Attention</p>
- <p class="last">If <code class="docutils literal"><span
class="pre">application.server</span></code> is not configured for an
application instance, then the above methods will not find any <a
class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/state/StreamsMetadata.html">StreamsMetadata</a>
for it.</p>
+ <p class="last">If <code class="docutils literal"><span
class="pre">application.server</span></code> is not configured for an
application instance, then the above methods will not find any <a
class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/state/StreamsMetadata.html">StreamsMetadata</a>
for it.</p>
</div>
<p>For example, we can now find the <code class="docutils
literal"><span class="pre">StreamsMetadata</span></code> for the state store
named “word-count” that we defined in the
code example shown in the previous section:</p>
diff --git a/docs/streams/developer-guide/processor-api.html
b/docs/streams/developer-guide/processor-api.html
index 1e7d673..119c85a 100644
--- a/docs/streams/developer-guide/processor-api.html
+++ b/docs/streams/developer-guide/processor-api.html
@@ -66,7 +66,7 @@
You can combine the convenience of the DSL with the power
and flexibility of the Processor API as described in the
section <a class="reference internal"
href="dsl-api.html#streams-developer-guide-dsl-process"><span class="std
std-ref">Applying processors and transformers (Processor API
integration)</span></a>.</p>
</div>
- <p>For a complete list of available API functionality, see the <a
href="../../../{{version}}/javadoc/org/apache/kafka/streams/package-summary.html">Streams</a>
API docs.</p>
+ <p>For a complete list of available API functionality, see the <a
href="/{{version}}/javadoc/org/apache/kafka/streams/package-summary.html">Streams</a>
API docs.</p>
</div>
<div class="section" id="defining-a-stream-processor">
<span id="streams-developer-guide-stream-processor"></span><h2><a
class="toc-backref" href="#id2">Defining a Stream Processor</a><a
class="headerlink" href="#defining-a-stream-processor" title="Permalink to this
headline"></a></h2>
@@ -227,7 +227,7 @@
space.</li>
<li>RocksDB settings can be fine-tuned, see
<a class="reference internal"
href="config-streams.html#streams-developer-guide-rocksdb-config"><span
class="std std-ref">RocksDB configuration</span></a>.</li>
- <li>Available <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/state/Stores.PersistentKeyValueFactory.html">store
variants</a>:
+ <li>Available <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/state/Stores.PersistentKeyValueFactory.html">store
variants</a>:
time window key-value store, session window
key-value store.</li>
</ul>
<div class="highlight-java"><div
class="highlight"><pre><span></span><span class="c1">// Creating a persistent
key-value store:</span>
@@ -349,7 +349,7 @@
as <code class="docutils literal"><span
class="pre">KeyValueStore</span></code>.</p>
<p>Note that your customized <code class="docutils
literal"><span
class="pre">org.apache.kafka.streams.processor.StateStore</span></code>
implementation also needs to provide the logic on how to restore the state
via the <code class="docutils literal"><span
class="pre">org.apache.kafka.streams.processor.StateRestoreCallback</span></code>
or <code class="docutils literal"><span
class="pre">org.apache.kafka.streams.processor.BatchingStateRestoreCallback</span></code>
interface.
- Details on how to instantiate these interfaces can be
found in the <a class="reference external"
href="../../../{{version}}/javadoc/org/apache/kafka/streams/processor/StateStore.html">javadocs</a>.</p>
+ Details on how to instantiate these interfaces can be
found in the <a class="reference external"
href="/{{version}}/javadoc/org/apache/kafka/streams/processor/StateStore.html">javadocs</a>.</p>
<p>You also need to provide a “builder” for the
store by implementing the
<code class="docutils literal"><span
class="pre">org.apache.kafka.streams.state.StoreBuilder</span></code>
interface, which Kafka Streams uses to create instances of
your store.</p>
