本指南从创建项目开始，逐步编写 Kafka Streams 流处理应用。如果尚未运行过 Streams 应用，建议先阅读快速入门。
创建 Maven 项目
使用 Kafka Streams Maven Archetype 创建项目结构：
$ mvn archetype:generate \
-DarchetypeGroupId=org.apache.kafka \
-DarchetypeArtifactId=streams-quickstart-java \
-DarchetypeVersion=4.3.1 \
-DgroupId=streams.examples \
-DartifactId=streams-quickstart \
-Dversion=0.1 \
-Dpackage=myapps
可以自行修改 groupId、artifactId 与 package。采用上面的参数时，生成的项目结构如下：
$ tree streams-quickstart
streams-quickstart
|-- pom.xml
|-- src
|-- main
|-- java
| |-- myapps
| |-- LineSplit.java
| |-- Pipe.java
| |-- WordCount.java
|-- resources
|-- log4j.properties
项目中的 pom.xml 已定义 Streams 依赖；生成的 pom.xml 将 Java 11 设为编译目标。
src/main/java 中已经有几个 Streams 示例。因为本教程要从零开始编写，可以删除这些生成的示例：
$ cd streams-quickstart
$ rm src/main/java/myapps/*.java
这条删除命令只针对刚生成项目内的示例文件，执行前应确认目录中没有自己的代码。
第一个应用：Pipe
将 Maven 项目导入 IDE，或在文本编辑器中创建 src/main/java/myapps/Pipe.java：
package myapps;
public class Pipe {
public static void main(String[] args) throws Exception {
}
}
接下来逐步填写 main 方法。逐步示例省略 import，IDE 通常可以自动补齐；使用文本编辑器时需要自行添加。本节末尾会提供带 import 的完整代码。
首先创建 java.util.Properties，设置 StreamsConfig 定义的运行参数。两个关键配置是：BOOTSTRAP_SERVERS_CONFIG 指定初次连接 Kafka 集群使用的主机与端口；APPLICATION_ID_CONFIG 为 Streams 应用提供唯一标识，以便与连接同一 Kafka 集群的其他应用区分。
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-pipe");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092"); // assuming that the Kafka broker this application is talking to runs on local machine with port 9092
还可以在同一配置对象中设置其他参数，例如键值记录默认使用的序列化和反序列化类：
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
所有配置项参见 Kafka Streams 配置。
接下来定义计算逻辑。Kafka Streams 用相互连接的处理节点构成拓扑；先创建拓扑构建器：
final StreamsBuilder builder = new StreamsBuilder();
用它从名为 streams-plaintext-input 的 Kafka 主题创建源流：
KStream<String, String> source = builder.stream("streams-plaintext-input");
这个 KStream 持续从源主题产生记录，每条记录的键和值都是 String。最简单的处理是把记录写入另一个 Kafka 主题 streams-pipe-output：
source.to("streams-pipe-output");
上面创建源流和写出的两句也可以连成一句：
builder.stream("streams-plaintext-input").to("streams-pipe-output");
构建拓扑：
final Topology topology = builder.build();
将拓扑描述打印到标准输出：
System.out.println(topology.describe());
如果到这里就编译并运行，官方示例显示以下拓扑信息：
$ mvn clean package
$ mvn exec:java -Dexec.mainClass=myapps.Pipe
Sub-topologies:
Sub-topology: 0
Source: KSTREAM-SOURCE-0000000000(topics: streams-plaintext-input) --> KSTREAM-SINK-0000000001
Sink: KSTREAM-SINK-0000000001(topic: streams-pipe-output) <-- KSTREAM-SOURCE-0000000000
Global Stores:
none
拓扑包含两个处理节点：源节点 KSTREAM-SOURCE-0000000000 持续从 streams-plaintext-input 读取记录，传给下游的接收节点 KSTREAM-SINK-0000000001；接收节点将收到的记录依次写入 streams-pipe-output。描述中的 --> 和 <-- 分别表示下游和上游节点，也就是图中的子节点和父节点。这个简单拓扑没有全局状态存储，后面会继续介绍状态存储。
在构建过程中，随时可以像这样查看拓扑描述，逐步检查计算逻辑。透传拓扑准备好后，用配置对象和 Topology 创建 Streams 客户端：
final KafkaStreams streams = new KafkaStreams(topology, props);
调用 start() 后客户端开始执行，并一直运行到调用 close()。例如可以注册关闭钩子，并用 CountDownLatch 捕获用户中断，在退出程序时关闭客户端：
final CountDownLatch latch = new CountDownLatch(1);
// attach shutdown handler to catch control-c
Runtime.getRuntime().addShutdownHook(new Thread("streams-shutdown-hook") {
@Override
public void run() {
streams.close();
latch.countDown();
}
});
try {
streams.start();
latch.await();
} catch (Throwable e) {
System.exit(1);
}
System.exit(0);
到这里，完整代码如下：
package myapps;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.Topology;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
public class Pipe {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-pipe");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
final StreamsBuilder builder = new StreamsBuilder();
builder.stream("streams-plaintext-input").to("streams-pipe-output");
final Topology topology = builder.build();
final KafkaStreams streams = new KafkaStreams(topology, props);
final CountDownLatch latch = new CountDownLatch(1);
// attach shutdown handler to catch control-c
Runtime.getRuntime().addShutdownHook(new Thread("streams-shutdown-hook") {
@Override
public void run() {
streams.close();
latch.countDown();
}
});
try {
streams.start();
latch.await();
} catch (Throwable e) {
System.exit(1);
}
System.exit(0);
}
}
如果 Kafka broker 已经在 localhost:9092 运行，并且创建了 streams-plaintext-input 和 streams-pipe-output 主题，可以在 IDE 中运行，也可以用 Maven：
$ mvn clean package
$ mvn exec:java -Dexec.mainClass=myapps.Pipe
怎样运行应用和观察计算结果，参见快速入门中的 Play with a Streams Application。后面不再重复运行步骤。
第二个应用：Line Split
前面已经用 StreamsConfig 与 Topology 创建客户端，现在向拓扑加入实际处理逻辑。先复制 Pipe.java：
$ cp src/main/java/myapps/Pipe.java src/main/java/myapps/LineSplit.java
修改类名和 application id，让它与原来的程序区分：
public class LineSplit {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-linesplit");
// ...
}
}
源流的每条记录都是 String 键值对。把值视为一行文本，用 flatMapValues 拆成单词：
代码校注：当前官方网页及其 Markdown 源中的 8 个分词片段将 Java 正则字符串写成 "\W+"。按 Java 语言规范的转义规则，这会产生非法转义。以下原文代码块仍逐字保留；复制运行时，应将对应字符串改成包含两个反斜杠的 "\\W+"。校正写法单独列在这里：
value.split("\\W+")
value.toLowerCase(Locale.getDefault()).split("\\W+")
KStream<String, String> source = builder.stream("streams-plaintext-input");
KStream<String, String> words = source.flatMapValues(new ValueMapper<String, Iterable<String>>() {
@Override
public Iterable<String> apply(String value) {
return Arrays.asList(value.split("\W+"));
}
});
这个算子按顺序处理源流中的每条记录，把值拆成单词列表，并为每个单词产生一条新记录，组成 words 流。它无须记住以前的记录或结果，是无状态算子。采用 Java 8 引入的 lambda 语法时，可以简化为：
KStream<String, String> source = builder.stream("streams-plaintext-input");
KStream<String, String> words = source.flatMapValues(value -> Arrays.asList(value.split("\W+")));
最后把单词流写入另一个主题 streams-linesplit-output。两步可以连写：
KStream<String, String> source = builder.stream("streams-plaintext-input");
source.flatMapValues(value -> Arrays.asList(value.split("\W+")))
.to("streams-linesplit-output");
再次用 System.out.println(topology.describe()) 描述拓扑，官方示例输出如下：
$ mvn clean package
$ mvn exec:java -Dexec.mainClass=myapps.LineSplit
Sub-topologies:
Sub-topology: 0
Source: KSTREAM-SOURCE-0000000000(topics: streams-plaintext-input) --> KSTREAM-FLATMAPVALUES-0000000001
Processor: KSTREAM-FLATMAPVALUES-0000000001(stores: []) --> KSTREAM-SINK-0000000002 <-- KSTREAM-SOURCE-0000000000
Sink: KSTREAM-SINK-0000000002(topic: streams-linesplit-output) <-- KSTREAM-FLATMAPVALUES-0000000001
Global Stores:
none
新的 KSTREAM-FLATMAPVALUES-0000000001 节点被插入源与接收节点之间。它以上游源节点为父节点，以接收节点为子节点。源节点取得的每条记录先经过这个新节点，产生一条或多条记录，再流向接收节点写回 Kafka。描述中的 stores: [] 表示它不关联状态存储，因此是无状态节点。
采用 lambda 的代码如下。其中结尾标注与 Pipe.java 相同的关闭和运行逻辑，需要复用前一个完整示例：
package myapps;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.Topology;
import org.apache.kafka.streams.kstream.KStream;
import java.util.Arrays;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
public class LineSplit {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-linesplit");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
final StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> source = builder.stream("streams-plaintext-input");
source.flatMapValues(value -> Arrays.asList(value.split("\W+")))
.to("streams-linesplit-output");
final Topology topology = builder.build();
final KafkaStreams streams = new KafkaStreams(topology, props);
final CountDownLatch latch = new CountDownLatch(1);
// ... same as Pipe.java above
}
}
第三个应用：WordCount
继续加入有状态计算，统计源文本流拆出的单词出现次数。以 LineSplit.java 为基础创建新程序：
public class WordCount {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-wordcount");
// ...
}
}
先修改 flatMapValues，将单词统一转成小写：
source.flatMapValues(new ValueMapper<String, Iterable<String>>() {
@Override
public Iterable<String> apply(String value) {
return Arrays.asList(value.toLowerCase(Locale.getDefault()).split("\W+"));
}
});
要聚合计数，首先用 groupBy 将记录按小写单词，也就是原来的值，重新分组。生成的分组流经 count 聚合，得到每个键持续更新的计数：
KTable<String, Long> counts =
source.flatMapValues(new ValueMapper<String, Iterable<String>>() {
@Override
public Iterable<String> apply(String value) {
return Arrays.asList(value.toLowerCase(Locale.getDefault()).split("\W+"));
}
})
.groupBy(new KeyValueMapper<String, String, String>() {
@Override
public String apply(String key, String value) {
return value;
}
})
// Materialize the result into a KeyValueStore named "counts-store".
// The Materialized store is always of type <Bytes, byte[]> as this is the format of the inner most store.
.count(Materialized.<String, Long, KeyValueStore<Bytes, byte[]>> as("counts-store"));
count 的 Materialized 参数指定将计数保存在名为 counts-store 的状态存储中。这个存储可以实时查询，详见开发者手册中的交互式查询。
也可以将 counts KTable 的变更日志流写回 streams-wordcount-output。因为输出是变更日志流，该主题应启用日志压缩。此时值的类型从 String 变成 Long，默认序列化类不能继续用于写出；必须显式指定 Long 序列化，否则会在运行时抛出异常：
counts.toStream().to("streams-wordcount-output", Produced.with(Serdes.String(), Serdes.Long()));
读取该变更日志流时，值的反序列化器需要设置为 org.apache.kafka.common.serialization.LongDeserializer。具体步骤见快速入门的应用运行部分。采用 lambda 时，上面的逻辑可以简化为：
KStream<String, String> source = builder.stream("streams-plaintext-input");
source.flatMapValues(value -> Arrays.asList(value.toLowerCase(Locale.getDefault()).split("\W+")))
.groupBy((key, value) -> value)
.count(Materialized.<String, Long, KeyValueStore<Bytes, byte[]>>as("counts-store"))
.toStream()
.to("streams-wordcount-output", Produced.with(Serdes.String(), Serdes.Long()));
再次描述拓扑，官方示例输出如下：
$ mvn clean package
$ mvn exec:java -Dexec.mainClass=myapps.WordCount
Sub-topologies:
Sub-topology: 0
Source: KSTREAM-SOURCE-0000000000(topics: streams-plaintext-input) --> KSTREAM-FLATMAPVALUES-0000000001
Processor: KSTREAM-FLATMAPVALUES-0000000001(stores: []) --> KSTREAM-KEY-SELECT-0000000002 <-- KSTREAM-SOURCE-0000000000
Processor: KSTREAM-KEY-SELECT-0000000002(stores: []) --> KSTREAM-FILTER-0000000005 <-- KSTREAM-FLATMAPVALUES-0000000001
Processor: KSTREAM-FILTER-0000000005(stores: []) --> KSTREAM-SINK-0000000004 <-- KSTREAM-KEY-SELECT-0000000002
Sink: KSTREAM-SINK-0000000004(topic: counts-store-repartition) <-- KSTREAM-FILTER-0000000005
Sub-topology: 1
Source: KSTREAM-SOURCE-0000000006(topics: counts-store-repartition) --> KSTREAM-AGGREGATE-0000000003
Processor: KSTREAM-AGGREGATE-0000000003(stores: [counts-store]) --> KTABLE-TOSTREAM-0000000007 <-- KSTREAM-SOURCE-0000000006
Processor: KTABLE-TOSTREAM-0000000007(stores: []) --> KSTREAM-SINK-0000000008 <-- KSTREAM-AGGREGATE-0000000003
Sink: KSTREAM-SINK-0000000008(topic: streams-wordcount-output) <-- KTABLE-TOSTREAM-0000000007
Global Stores:
none
拓扑现在有两个不直接连接的子拓扑。第一个子拓扑的接收节点 KSTREAM-SINK-0000000004 写入重分区主题 counts-store-repartition，第二个子拓扑的源节点 KSTREAM-SOURCE-0000000006 读取该主题。重分区主题按聚合键重新分配源流记录；这里的聚合键就是原记录的值，即单词。
第一个子拓扑还在分组节点 KSTREAM-KEY-SELECT-0000000002 和接收节点之间插入无状态过滤节点 KSTREAM-FILTER-0000000005。原文将其描述为过滤聚合键为空的中间记录；按 KStream API 的分组规则，这里被丢弃的是分组键为 null 的记录，不能把空字符串理解为已被自动过滤。
第二个子拓扑中，聚合节点 KSTREAM-AGGREGATE-0000000003 关联用户在 count 中命名的 counts-store。每收到一条记录，它先查询该键当前的计数，加一，再把新计数写回存储。更新后的计数继续流向 KTABLE-TOSTREAM-0000000007；该节点将更新流解释为记录流，再送往 KSTREAM-SINK-0000000008 写回 Kafka。
采用 lambda 的代码如下；结尾仍需复用 Pipe.java 的运行和关闭逻辑：
package myapps;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.common.utils.Bytes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.Topology;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.Materialized;
import org.apache.kafka.streams.kstream.Produced;
import org.apache.kafka.streams.state.KeyValueStore;
import java.util.Arrays;
import java.util.Locale;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
public class WordCount {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-wordcount");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
final StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> source = builder.stream("streams-plaintext-input");
source.flatMapValues(value -> Arrays.asList(value.toLowerCase(Locale.getDefault()).split("\W+")))
.groupBy((key, value) -> value)
.count(Materialized.<String, Long, KeyValueStore<Bytes, byte[]>>as("counts-store"))
.toStream()
.to("streams-wordcount-output", Produced.with(Serdes.String(), Serdes.Long()));
final Topology topology = builder.build();
final KafkaStreams streams = new KafkaStreams(topology, props);
final CountDownLatch latch = new CountDownLatch(1);
// ... same as Pipe.java above
}
}
输出值是每个键更新后的累计计数，而不是需要再次累加的增量。上述代码没有配置恰好一次处理选项。原文有关 Java 8 的表述描述 lambda 语法，不能理解为 Kafka 4.3 的整套运行环境支持 Java 8；生成项目的 Java 11 编译目标也应与所选 Kafka/JDK 版本要求一起核对。
来源：Apache Kafka 4.3：Write a streams app，Apache Kafka 文档贡献者；页面最后修改日期为 2026-06-25，示例 Maven Archetype 版本为 4.3.1。Copyright © The Apache Software Foundation。依据 Apache License 2.0 提供。本中文版本翻译完整教学正文，保留全部 31 个原文代码与拓扑输出块，另加 1 个明确标注的 Java 正则转义校正块，补充生成文件删除范围、后续示例复用及输出语义说明。2026-10-03 仅静态核对，未启动 Kafka 集群或执行 Maven 构建。
Apache License 2.0 许可全文
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
暂无评论内容