一个Flink程序，其实就是对DataStream的各种转换。具体来说，代码基本上都由以下几部分构成

1.获取执行环境（execution environment）
2.读取数据源（source）
3.定义基于数据的转换操作（transformations）
4.定义计算结果的输出位置（sink）
5.触发程序执行（execute）

其中，获取环境和触发执行，都可以认为是针对执行环境的操作。所以本章我们就从执行环境、数据源（source）、转换操作（transformation）、输出（sink）四大部分，对常用的DataStream API做基本介绍。

一、执行环境（Execution Environment）

Flink程序可以在各种上下文环境中运行：我们可以在本地JVM中执行程序，也可以提交到远程集群上运行。

不同的环境，代码的提交运行的过程会有所不同。这就要求我们在提交作业执行计算时，首先必须获取当前Flink的运行环境，从而建立起与Flink框架之间的联系。只有获取了环境上下文信息，才能将具体的任务调度到不同的TaskManager执行。

1、创建执行环境

编写Flink程序的第一步，就是创建执行环境。我们要获取的执行环境，是StreamExecutionEnvironment类的对象，这是所有Flink程序的基础。在代码中创建执行环境的方式，就是调用这个类的静态方法，具体有以下三种。

1. getExecutionEnvironment

最简单的方式，就是直接调用getExecutionEnvironment方法。它会根据当前运行的上下文直接得到正确的结果：如果程序是独立运行的，就返回一个本地执行环境；如果是创建了jar包，然后从命令行调用它并提交到集群执行，那么就返回集群的执行环境。也就是说，这个方法会根据当前运行的方式，自行决定该返回什么样的运行环境。

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

这种“智能”的方式不需要我们额外做判断，用起来简单高效，是最常用的一种创建执行环境的方式。

2. createLocalEnvironment

这个方法返回一个本地执行环境。可以在调用时传入一个参数，指定默认的并行度；如果不传入，则默认并行度就是本地的CPU核心数

StreamExecutionEnvironment localEnv = StreamExecutionEnvironment.createLocalEnvironment();

3. createRemoteEnvironment

这个方法返回集群执行环境。需要在调用时指定JobManager的主机名和端口号，并指定要在集群中运行的Jar包。

StreamExecutionEnvironment remoteEnv = StreamExecutionEnvironment
  		.createRemoteEnvironment(
    			"host", // JobManager主机名
    			1234, // JobManager进程端口号
   			"path/to/jarFile.jar"  // 提交给JobManager的JAR包
		); 

在获取到程序执行环境后，我们还可以对执行环境进行灵活的设置。比如可以全局设置程序的并行度、禁用算子链，还可以定义程序的时间语义、配置容错机制。关于时间语义和容错机制，我们会在后续的章节介绍。

二、执行模式(Execution Mode)

上节中我们获取到的执行环境，是一个StreamExecutionEnvironment，顾名思义它应该是做流处理的。那对于批处理，又应该怎么获取执行环境呢？

在之前的Flink版本中，批处理的执行环境与流处理类似，是调用类ExecutionEnvironment的静态方法，返回它的对象：

// 批处理环境
ExecutionEnvironment batchEnv = ExecutionEnvironment.getExecutionEnvironment();
// 流处理环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

基于ExecutionEnvironment读入数据创建的数据集合，就是DataSet；对应的调用的一整套转换方法，就是DataSet API。这些我们在第二章的批处理word count程序中已经有了基本了解。

而从1.12.0版本起，Flink实现了API上的流批统一。DataStream API新增了一个重要特性：可以支持不同的“执行模式”（execution mode），通过简单的设置就可以让一段Flink程序在流处理和批处理之间切换。这样一来，DataSet API也就没有存在的必要了。

流执行模式（STREAMING）

这是DataStream API最经典的模式，一般用于需要持续实时处理的无界数据流。默认情况下，程序使用的就是STREAMING执行模式。

批执行模式（BATCH）

专门用于批处理的执行模式, 这种模式下，Flink处理作业的方式类似于MapReduce框架。对于不会持续计算的有界数据，我们用这种模式处理会更方便。

自动模式（AUTOMATIC）

在这种模式下，将由程序根据输入数据源是否有界，来自动选择执行模式。

1. BATCH模式的配置方法

由于Flink程序默认是STREAMING模式，我们这里重点介绍一下BATCH模式的配置。主要有两种方式：

（1）通过命令行配置

bin/flink run -Dexecution.runtime-mode=BATCH ...

在提交作业时，增加execution.runtime-mode参数，指定值为BATCH。

（2）通过代码配置

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setRuntimeMode(RuntimeExecutionMode.BATCH);

在代码中，直接基于执行环境调用setRuntimeMode方法，传入BATCH模式

建议: 不要在代码中配置，而是使用命令行。这同设置并行度是类似的：在提交作业时指定参数可以更加灵活，同一段应用程序写好之后，既可以用于批处理也可以用于流处理。而在代码中硬编码（hard code）的方式可扩展性比较差，一般都不推荐。

2. 什么时候选择BATCH模式

我们知道，Flink本身持有的就是流处理的世界观，即使是批量数据，也可以看作“有界流”来进行处理。所以STREAMING 执行模式对于有界数据和无界数据都是有效的；而BATCH模式仅能用于有界数据。

看起来BATCH模式似乎被STREAMING模式全覆盖了，那还有必要存在吗？我们能不能所有情况下都用流处理模式呢？

当然是可以的，但是这样有时不够高效。

我们可以仔细回忆一下word count程序中，批处理和流处理输出的不同：在STREAMING模式下，每来一条数据，就会输出一次结果（即使输入数据是有界的）；而BATCH模式下，只有数据全部处理完之后，才会一次性输出结果。最终的结果两者是一致的，但是流处理模式会将更多的中间结果输出。在本来输入有界、只希望通过批处理得到最终的结果的场景下，STREAMING模式的逐个输出结果就没有必要了。

所以总结起来，一个简单的原则就是：用BATCH模式处理批量数据，用STREAMING模式处理流式数据。因为数据有界的时候，直接输出结果会更加高效；而当数据无界的时候, 我们没得选择——只有STREAMING模式才能处理持续的数据流。

当然，在后面的示例代码中，即使是有界的数据源，我们也会统一用STREAMING模式处理。这是因为我们的主要目标还是构建实时处理流数据的程序，有界数据源也只是我们用来测试的手段。

三、触发程序执行

有了执行环境，我们就可以构建程序的处理流程了：基于环境读取数据源，进而进行各种转换操作，最后输出结果到外部系统。

需要注意的是，写完输出（sink）操作并不代表程序已经结束。因为当main()方法被调用时，其实只是定义了作业的每个执行操作，然后添加到数据流图中；这时并没有真正处理数据——因为数据可能还没来。Flink是由事件驱动的，只有等到数据到来，才会触发真正的计算，这也被称为“延迟执行”或“懒执行”（lazy execution）。

所以我们需要显式地调用执行环境的execute()方法，来触发程序执行。execute()方法将一直等待作业完成，然后返回一个执行结果（JobExecutionResult）。

四、源算子（Source）

创建环境之后，就可以构建数据处理的业务逻辑了，如图5-2所示，本节将主要讲解Flink的源算子（Source）。想要处理数据，先得有数据，所以首要任务就是把数据读进来。

Flink可以从各种来源获取数据，然后构建DataStream进行转换处理。一般将数据的输入来源称为数据源(data source)，而读取数据的算子就是源算子（source operator）。所以，source就是我们整个处理程序的输入端。

Flink代码中通用的添加source的方式，是调用执行环境的addSource()方法：

DataStream<String> stream = env.addSource(...);

方法传入一个对象参数，需要实现SourceFunction接口；返回DataStreamSource。这里的DataStreamSource类继承自SingleOutputStreamOperator类，又进一步继承自DataStream。所以很明显，读取数据的source操作是一个算子，得到的是一个数据流（DataStream）。

这里可能会有些麻烦：传入的参数是一个“源函数”（source function），需要实现SourceFunction接口。这是何方神圣，又该怎么实现呢？

自己去实现它显然不会是一件容易的事。好在Flink直接提供了很多预实现的接口，此外还有很多外部连接工具也帮我们实现了对应的source function，通常情况下足以应对我们的实际需求。接下来我们就详细展开讲解。

1、 准备工作

为了更好地理解，我们先构建一个实际应用场景。比如网站的访问操作，可以抽象成一个三元组（用户名，用户访问的urrl，用户访问url的时间戳），所以在这里，我们可以创建一个类Event，将用户行为包装成它的一个对象。Event包含了以下一些字段

package com.example.chapter05;


import java.sql.Timestamp;

public class Event {
    public String user;
    public String url;
    public Long timestamp;


    public Event() {

    }

    public Event(String user, String url, Long timestamp) {
        this.user = user;
        this.url = url;
        this.timestamp = timestamp;
    }


    @Override
    public String toString() {
        return "Event{" +
                "user='" + user + ''' +
                ", url='" + url + ''' +
                ", timestamp='" + new Timestamp(timestamp) + ''' +
                '}';
    }
}

Flink会把这样的类作为一种特殊的POJO数据类型来对待，方便数据的解析和序列化。

2、从集合中读取数据

最简单的读取数据的方式，就是在代码中直接创建一个Java集合然后调用执行环境的fromCollection方法进行读取。这相当于将数据临时存储到内存中

package com.example.chapter05;

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;

import java.util.ArrayList;
import java.util.Properties;

/**
 * 从各种方面读取
 * 各种数据
 */
public class SourceTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1); //并行度

        ArrayList<Integer> nums = new ArrayList<>();
        nums.add(2);
        nums.add(5);

        DataStreamSource<Integer> collection = env.fromCollection(nums);
			//TODO 从集合中读取
        ArrayList<Event> events = new ArrayList<>();
        events.add(new Event("Mary", "./home", 1000L));
        events.add(new Event("Bob", "./cart", 2000L));
        DataStreamSource<Event> stream2 = env.fromCollection(events);

        //从元素中读取
        DataStreamSource<Event> stream3 = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 1000L));
        
        stream1.print("nums ");
        stream2.print("2");
        env.execute();
    }
}

3、从文件读取数据

真正的实际应用中，自然不会直接将数据写在代码中。通常情况下，我们会从存储介质中获取数据，一个比较常见的方式就是读取日志文件。这也是批处理中最常见的读取方式。

说明:
参数可以是目录，也可以是文件；
路径可以是相对路径，也可以是绝对路径；
相对路径是从系统属性user.dir获取路径: idea下是project的根目录, standalone模式下是集群节点根目录；
也可以从hdfs目录下读取, 

package com.example.chapter05;

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;

import java.util.ArrayList;
import java.util.Properties;

/**
 * 从各种方面读取
 * 各种数据
 */
public class SourceTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1); //并行度
        //TODO 文件中读取
        DataStreamSource<String> stream1 = env.readTextFile("input/clicks.txt");
        stream1.print("1");
        env.execute();
    }
}

4、从Socket读取数据

不论从集合还是文件，我们读取的其实都是有界数据。在流处理的场景中，数据往往是无界的。这时又从哪里读取呢？

一个简单的方式，就是我们之前用到的读取socket文本流。这种方式由于吞吐量小、稳定性较差，一般也是用于测试。

package com.example.chapter05;

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;

import java.util.ArrayList;
import java.util.Properties;

/**
 * 从各种方面读取
 * 各种数据
 */
public class SourceTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1); //并行度
        
        //从Socket文本流中读取
        DataStreamSource<String> stream4 = env.socketTextStream("localhost", 7777);
        stream4.print("4");
        env.execute();
    }
}

5、从Kafka读取数据

那对于真正的流数据，实际项目应该怎样读取呢？

Kafka作为分布式消息传输队列，是一个高吞吐、易于扩展的消息系统。而消息队列的传输方式，恰恰和流处理是完全一致的。所以可以说Kafka和Flink天生一对，是当前处理流式数据的双子星。在如今的实时流处理应用中，由Kafka进行数据的收集和传输，Flink 进行分析计算，这样的架构已经成为众多企业的首选，

略微遗憾的是，与Kafka的连接比较复杂，Flink内部并没有提供预实现的方法。所以我们只能采用通用的addSource方式、实现一个SourceFunction了。

好在Kafka与Flink确实是非常契合，所以Flink官方提供了连接工具flink-connector-kafka，直接帮我们实现了一个消费者FlinkKafkaConsumer，它就是用来读取Kafka数据的SourceFunction。

所以想要以Kafka作为数据源获取数据，我们只需要引入Kafka连接器的依赖。Flink官方提供的是一个通用的Kafka连接器，它会自动跟踪最新版本的Kafka客户端。目前最新版本只支持0.10.0版本以上的Kafka，读者使用时可以根据自己安装的Kafka版本选定连接器的依赖版本。这里我们需要导入的依赖如下。

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
    <version>${flink.version}</version>
</dependency>

然后调用env.addSource()，传入FlinkKafkaConsumer的对象实例就可以了。

package com.example.chapter05;

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;

import java.util.ArrayList;
import java.util.Properties;

/**
 * 从各种方面读取
 * 各种数据
 */
public class SourceTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1); //并行度
        
        //从kafaka读取数据
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "hadoop102:9092");
        properties.setProperty("group.id", "consumer-group");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "latest");

        // String topic, DeserializationSchema<T> valueDeserializer(序列化器), Properties props
        DataStreamSource<String> kafkaStream = env.addSource(
                new FlinkKafkaConsumer<String>("click", new SimpleStringSchema(), properties));
        kafkaStream.print();

        env.execute();
    }
}

创建FlinkKafkaConsumer时需要传入三个参数：

第一个参数topic，定义了从哪些主题中读取数据。可以是一个topic，也可以是topic列表，还可以是匹配所有想要读取的topic的正则表达式。当从多个topic中读取数据时，Kafka连接器将会处理所有topic的分区，将这些分区的数据放到一条流中去。

第二个参数是一个DeserializationSchema或者KeyedDeserializationSchema。Kafka消息被存储为原始的字节数据，所以需要反序列化成Java或者Scala对象。上面代码中使用的SimpleStringSchema，是一个内置的DeserializationSchema，它只是将字节数组简单地反序列化成字符串。DeserializationSchema和KeyedDeserializationSchema是公共接口，所以我们也可以自定义反序列化逻辑。

第三个参数是一个Properties对象，设置了Kafka客户端的一些属性。

五、自定义Source

大多数情况下，前面的数据源已经能够满足需要。但是凡事总有例外，如果遇到特殊情况，我们想要读取的数据源来自某个外部系统，而flink既没有预实现的方法、也没有提供连接器，又该怎么办呢？

那就只好自定义实现SourceFunction了。

接下来我们创建一个自定义的数据源，实现SourceFunction接口。主要重写两个关键方法：run()和cancel()。

1、自定义ClickSource

run()方法：使用运行时上下文对象（SourceContext）向下游发送数据；
cancel()方法：通过标识位控制退出循环，来达到中断数据源的效果。

代码如下：
我们先来自定义一下数据源：

package com.example.chapter05;

import org.apache.flink.streaming.api.functions.source.SourceFunction;

import java.util.Calendar;
import java.util.Random;

/**
 * 自定义数据源
 */
public class ClickSource implements SourceFunction<Event> {

    //声明标志位
    private Boolean running = true;

    @Override
    public void run(SourceContext<Event> sourceContext) throws Exception {

        //随机生成数据
        Random random = new Random();

        //定义字段选取的数据集
        String[] users = {"Mary", "Alice", "Bob", "Cary"};
        String[] urls = {"./home", "./cart", "./fav", "./prod?id =100", "./prod?id=10"};

        //循环生成数据
        while (running) {
            String user = users[random.nextInt(users.length)];
            String url = urls[random.nextInt(urls.length)];
            long timeInMillis = Calendar.getInstance().getTimeInMillis();
            sourceContext.collect(new Event(user, url, timeInMillis));
            Thread.sleep(1000L);
        }

    }

    @Override
    public void cancel() {
        running = false;
    }
}

这个数据源，我们后面会频繁使用，所以在后面的代码中涉及到ClickSource()数据源，使用上面的代码就可以了。

下面的代码我们来读取一下自定义的数据源。有了自定义的source function，接下来只要调用addSource()就可以了：

2、调用自定义ClickSource

package com.example.chapter05;

import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;

import java.util.Random;

/**
 * 有了自定义的 source function，接下来只要
   调用 addSource()就可以了
 */
public class SourceCustomTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1); //全局并行度

        //TODO 当前的并行度对于非并行的算子而言只能是1
       DataStreamSource<Event> customStream = env.addSource(new ClickSource());
        customStream.print();
        env.execute();
    }


}

3、自定义(SourceFunction)问题

这里要注意的是 SourceFunction 接口定义的数据源，并行度只能设置为 1，如果数据源设
置为大于 1 的并行度，则会抛出异常。如下程序所示：

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import java.util.Random;
public class SourceThrowException {
 public static void main(String[] args) throws Exception {
 StreamExecutionEnvironment env = 
StreamExecutionEnvironment.getExecutionEnvironment();
 env.addSource(new ClickSource()).setParallelism(2).print();
 env.execute();
 } }

输出的异常如下：

Exception in thread "main" java.lang.IllegalArgumentException: The parallelism 
of non parallel operator must be 1.

4、自定义并行的数据源(ParallelSourceFunction)

所以如果我们想要自定义并行的数据源的话，需要使用 ParallelSourceFunction，示例程序
如下

package com.example.chapter05;

import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;

import java.util.Random;

/**
 *
 * 自定义数据源
 * 自定义并行ParallelSourceFunction
 * 
 */
public class SourceCustomTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4); //全局并行度

        //TODO 当前的并行度对于非并行的算子而言只能是1
       //DataStreamSource<Event> customStream = env.addSource(new ClickSource());

        //TODO 实现更高的并行度 实现 ParallelSourceFunction
        DataStreamSource<Integer> customStream = env.addSource(new ParallelCustomSource())
                .setParallelism(2); //并行度为2（正常运行）
        customStream.print();
        env.execute();
    }

    /**
     * 自定义并行Source
     */
    public static class ParallelCustomSource implements ParallelSourceFunction<Integer> {

        private Boolean running = true;
        private Random random = new Random();

        @Override
        public void run(SourceContext<Integer> ctx) throws Exception {
            while (running) {
                ctx.collect(random.nextInt());
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }
}

2> -686169047
2> 429515397
2> -223516288
2> 1137907312
2> -380165730
2> 2082090389

六、Flink 支持的数据类型

1. Flink的类型系统

为什么会出现“不支持”的数据类型呢？因为Flink作为一个分布式处理框架，处理的是以数据对象作为元素的流。如果用水流来类比，那么我们要处理的数据元素就是随着水流漂动的物体。在这条流动的河里，可能漂浮着小木块，也可能行驶着内部错综复杂的大船。要分布式地处理这些数据，就不可避免地要面对数据的网络传输、状态的落盘和故障恢复等问题，这就需要对数据进行序列化和反序列化。小木块是容易序列化的；而大船想要序列化之后传输，就需要将它拆解、清晰地知道其中每一个零件的类型。

为了方便地处理数据，Flink有自己一整套类型系统。Flink使用“类型信息”（TypeInformation）来统一表示数据类型。TypeInformation类是Flink中所有类型描述符的基类。它涵盖了类型的一些基本属性，并为每个数据类型生成特定的序列化器、反序列化器和比较器。

2. Flink支持的数据类型

简单来说，对于常见的Java和Scala数据类型，Flink都是支持的。Flink在内部，Flink对支持不同的类型进行了划分，这些类型可以在Types工具类中找到：

（1）基本类型

所有Java基本类型及其包装类，再加上Void、String、Date、BigDecimal和BigInteger。

（2）数组类型

包括基本类型数组（PRIMITIVE_ARRAY）和对象数组(OBJECT_ARRAY)

（3）复合数据类型

Java元组类型（TUPLE）：这是Flink内置的元组类型，是Java API的一部分。最多25个字段，也就是从Tuple0~Tuple25，不支持空字段
Scala 样例类及Scala元组：不支持空字段
行类型（ROW）：可以认为是具有任意个字段的元组,并支持空字段
POJO：Flink自定义的类似于Java bean模式的类

（4）辅助类型

Option、Either、List、Map等

（5）泛型类型（GENERIC）

Flink支持所有的Java类和Scala类。不过如果没有按照上面POJO类型的要求来定义，就会被Flink当作泛型类来处理。Flink会把泛型类型当作黑盒，无法获取它们内部的属性；它们也不是由Flink本身序列化的，而是由Kryo序列化的。

在这些类型中，元组类型和POJO类型最为灵活，因为它们支持创建复杂类型。而相比之下，POJO还支持在键（key）的定义中直接使用字段名，这会让我们的代码可读性大大增加。所以，在项目实践中，往往会将流处理程序中的元素类型定为Flink的POJO类型。

Flink对POJO类型的要求如下：

类是公共的（public）和独立的（standalone，也就是说没有非静态的内部类）；

类有一个公共的无参构造方法；

类中的所有字段是public且非final的；或者有一个公共的getter和setter方法，这些方法需要符合Java bean的命名规范。

所以我们看到，之前的UserBehavior，就是我们创建的符合Flink POJO定义的数据类型。

3. 类型提示（Type Hints）

Flink还具有一个类型提取系统，可以分析函数的输入和返回类型，自动获取类型信息，从而获得对应的序列化器和反序列化器。但是，由于Java中泛型擦除的存在，在某些特殊情况下（比如Lambda表达式中），自动提取的信息是不够精细的——只告诉Flink当前的元素由“船头、船身、船尾”构成，根本无法重建出“大船”的模样；这时就需要显式地提供类型信息，才能使应用程序正常工作或提高其性能。

为了解决这类问题，Java API提供了专门的“类型提示”（type hints）。

回忆一下之前的word count流处理程序，我们在将String类型的每个词转换成（word， count）二元组后，就明确地用returns指定了返回的类型。因为对于map里传入的Lambda表达式，系统只能推断出返回的是Tuple2类型，而无法得到Tuple2<String, Long>。只有显式地告诉系统当前的返回类型，才能正确地解析出完整数据。

.map(word -> Tuple2.of(word, 1L))
.returns(Types.TUPLE(Types.STRING, Types.LONG));

这是一种比较简单的场景，二元组的两个元素都是基本数据类型。那如果元组中的一个元素又有泛型，该怎么处理呢？

Flink专门提供了TypeHint类，它可以捕获泛型的类型信息，并且一直记录下来，为运行时提供足够的信息。我们同样可以通过.returns()方法，明确地指定转换之后的DataStream里元素的类型。

returns(new TypeHint<Tuple2<Integer, SomeType>>(){})

七、转换算子（Transformation）

数据源读入数据之后，我们就可以使用各种转换算子，将一个或多个 DataStream 转换为
新的 DataStream，一个 Flink 程序的核心，其实就是所有的转换操作，它们决 定了处理的业务逻辑

1、 基本转换算子

1. 映射（map）

map是大家非常熟悉的大数据操作算子，主要用于将数据流中的数据进行转换，形成新的数据流。简单来说，就是一个“一一映射”，消费一个元素就产出一个元素

我们只需要基于DataStrema调用map()方法就可以进行转换处理。方法需要传入的参数是接口MapFunction的实现；返回值类型还是DataStream，不过泛型（流中的元素类型）可能改变。

实现了提取Event中的user字段的功能。

package com.example.chapter05;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * DataStreamApi
 * Transform-Map
 */
public class TransformMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home", 1000L),
                new Event("Silly", "/Persion", 2000L),
                new Event("Lisi", "/CAR", 3000L));

        //进行转换计算、提取User字段
        //TODO 1、使用自定义类、实现
        SingleOutputStreamOperator<String> result = stream.map(new MyMapper());

        //TODO 2、不想实现方法的话、直接使用匿名类部类
        SingleOutputStreamOperator<String> result2 = stream.map(new MapFunction<Event, String>() {
            @Override
            public String map(Event event) throws Exception {
                return event.user;
            }
        });

        //TODO 3、传入Lambda表达式
        SingleOutputStreamOperator<String> result3 = stream.map(data -> data.user);

        result.print();
        result2.print();
        result3.print();
        env.execute();

    }

    //自定义 MapFunction<T, R>
    public static class MyMapper implements MapFunction<Event,String>{

        /**
         * Event{user='Mary', url='/home', timestamp='1970-01-01 08:00:01.0'}
         * @param event
         * @return
         * @throws Exception
         */
        @Override
        public String map(Event event) throws Exception {
            System.out.println(event);
            return event.user;
        }
    }
}

2. 过滤（filter）

filter转换操作，顾名思义是对数据流执行一个过滤，通过一个布尔条件表达式设置过滤条件，对于每一个流内元素进行判断，若为true则元素正常输出，若为false则元素被过滤掉，

进行filter转换之后的新数据流的数据类型与原数据流是相同的。filter转换需要传入的参数需要实现FilterFunction接口，而FilterFunction内要实现filter()方法，就相当于一个返回布尔类型的条件表达式。

将数据流中用户Mary的浏览行为过滤出来

package com.example.chapter05;

import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * DataStreamApi
 * Transform-Map
 */
public class TransformFilterTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);


        DataStreamSource<Event> stream = env.fromElements(
        new Event("Mary", "/home", 1000L),
         new Event("Silly", "/Persion", 2000L), 
        new Event("Lisi", "/CAR", 3000L));


        //TODO 1、自定义 FilterFunction的类的对象
        SingleOutputStreamOperator<Event> filter = stream.filter(new MyFilter());

        //TODO 2、传入一个匿名类实现 FilterFunction的类的对象
        SingleOutputStreamOperator<Event> filter1 = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event value) throws Exception {
                return value.user.equals("Silly");
            }
        });

        //TODO 3、传入表达式
        SingleOutputStreamOperator<Event> filter2 = stream.
        filter(data ->data.user.equals("Silly"));

        filter.print();
        filter1.print();
        filter2.print();
        env.execute();
        
    }

    private static class MyFilter implements FilterFunction<Event> {
        @Override
        public boolean filter(Event event) throws Exception {
            return event.user.equals("Silly");
        }
    }
}

3. 扁平映射（flatMap）

flatMap操作又称为扁平映射，主要是将数据流中的整体（一般是集合类型）拆分成一个一个的个体使用。消费一个元素，可以产生0到多个元素。flatMap可以认为是“扁平化”（flatten）和“映射”（map）两步操作的结合，也就是先按照某种规则对数据进行打散拆分，再对拆分后的元素做转换处理

同map一样，flatMap也可以使用Lambda表达式或者FlatMapFunction接口实现类的方式来进行传参，返回值类型取决于所传参数的具体逻辑，可以与原数据流相同，也可以不同

flatMap操作会应用在每一个输入事件上面， FlatMapFunction接口中定义了flatMap方法，用户可以重写这个方法，在这个方法中对输入数据进行处理，并决定是返回0个、1个或多个结果数据。因此flatMap并没有直接定义返回值类型，而是通过一个“收集器”（Collector）来指定输出。希望输出结果时，只要调用收集器的.collect()方法就可以了；这个方法可以多次调用，也可以不调用。所以flatMap方法也可以实现map方法和filter方法的功能，当返回结果是0个的时候，就相当于对数据进行了过滤，当返回结果是1个的时候，相当于对数据进行了简单的转换操作。

package com.example.chapter05;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;


/**
 * DataStreamApi
 * Transform-Map
 */
public class TransformFlatMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home", 1000L),
                new Event("Silly", "/Persion", 2000L),
                new Event("Bob", "/CAR", 3000L));


        //进行转换计算、提取User字段
        //TODO 1、使用自定义类、实现
        SingleOutputStreamOperator<String> result = stream.flatMap(new MyMapper());


        //TODO 2、不想实现方法的话、直接使用匿名类部类
        SingleOutputStreamOperator<String> result2 = stream.flatMap(new FlatMapFunction<Event, String>() {
            @Override
            public void flatMap(Event value, Collector<String> out) throws Exception {
                out.collect(value.user);
            }
        });


        //TODO 3、传入Lambda表达式-->多个参数使用collect 时候不会自动获取类型导致报错
        /**
         * Caused by: org.apache.flink.api.common.functions.InvalidTypesException: The generic type parameters of 'Collector' are missing. In many cases lambda methods don't provide enough
         * information for automatic type extraction when Java generics are involved. An easy workaround is to use an (anonymous) class instead that implements the 'org.apache.flink.api.common.
         * functions.FlatMapFunction' interface.
         * Otherwise the type has to be specified explicitly using type information.
         */
        SingleOutputStreamOperator<String> result3 = stream.flatMap((Event value, Collector<String> out)->{
            if(value.user.equals("Silly")){
                out.collect(value.url);
            }else if (value.user.equals("Bob")){
                out.collect(value.user);
                out.collect(value.url);
                out.collect(value.timestamp.toString());
            }

        }).returns(new TypeHint<String>() {  });

//        result.print();
//        result2.print("result2");
        result3.print("result3");

        env.execute();

    }

    //自定义 MapFunction<T, R>
    public static class MyMapper implements FlatMapFunction<Event, String> {
        @Override
        public void flatMap(Event value, Collector<String> out) throws Exception {
            out.collect(value.user);
        }
    }
}

2、聚合算子（Aggregation）

直观上看，基本转换算子确实是在“转换”——因为它们都是基于当前数据，去做了处理和输出。而在实际应用中，我们往往需要对大量的数据进行统计或整合，从而提炼出更有用的信息。比如之前word count程序中，要对每个词出现的频次进行叠加统计。这种操作，计算的结果不仅依赖当前数据，还跟之前的数据有关，相当于要把所有数据聚在一起进行汇总合并——这就是所谓的“聚合”（Aggregation），也对应着MapReduce中的reduce操作。

1. 按键分区（keyBy）

对于Flink而言，DataStream是没有直接进行聚合的API的。因为我们对海量数据做聚合肯定要进行分区并行处理，这样才能提高效率。所以在Flink中，要做聚合，需要先进行分区；这个操作就是通过keyBy来完成的。

keyBy是聚合前必须要用到的一个算子。keyBy通过指定键（key），可以将一条流从逻辑上划分成不同的分区（partitions）。这里所说的分区，其实就是并行处理的子任务，也就对应着任务槽（task slot）。

基于不同的key，流中的数据将被分配到不同的分区中去，如图5-8所示；这样一来，所有具有相同的key的数据，都将被发往同一个分区，那么下一步算子操作就将会在同一个slot中进行处理了。

package com.example.chapter05;

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformSimpleAggTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home", 1000L),
                new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/Persion?id=1", 4000L),
                new Event("Bob", "/home", 5000L),
                new Event("999", "/home", 4500L),

                new Event("Bob", "/prod?id=2", 6000L),
                new Event("Bob", "/prod?id=3", 7000L));

               //   TODO 按键 分组之后进行聚合

        stream.keyBy(new KeySelector<Event, String>() {

            @Override
            public String getKey(Event value) throws Exception {
                return value.user;
            }
        }).max("timestamp").print("max: ");



        stream.keyBy(data->data.user)
                .maxBy("timestamp")
                .print("maxBy: ");


        env.execute();

    }
}

2.归约聚合（reduce）

它可以对已有的数据进行归约处理，把每一个新输入的数据和当前已经归约出来的值,再做一个聚合计算。

与简单聚合类似，reduce操作也会将KeyedStream转换为DataStream。它不会改变流的元素数据类型，所以输出类型和输入类型是一样的。

调用KeyedStream的reduce方法时，需要传入一个参数，实现ReduceFunction接口

ReduceFunction接口里需要实现reduce()方法，这个方法接收两个输入事件，经过转换处理之后输出一个相同类型的事件；所以，对于一组数据，我们可以先取两个进行合并，然后再将合并的结果看作一个数据、再跟后面的数据合并，最终会将它“简化”成唯一的一个数据，这也就是reduce“归约”的含义

其实，reduce的语义是针对列表进行规约操作，运算规则由ReduceFunction中的reduce方法来定义，而在ReduceFunction内部会维护一个初始值为空的累加器，注意累加器的类型和输入元素的类型相同，当第一条元素到来时，累加器的值更新为第一条元素的值，当新的元素到来时，新元素会和累加器进行累加操作，这里的累加操作就是reduce函数定义的运算规则。然后将更新以后的累加器的值向下游输出。

我们可以单独定义一个函数类实现ReduceFunction接口，也可以直接传入一个匿名类。当然，同样也可以通过传入Lambda表达式实现类似的功能。

package com.example.chapter05;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * 归约聚合（reduce）
 *
 * 规约聚合、必须先分组KEYBY
 */
public class TransformReduceTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home", 1000L),
                new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/Persion?id=1", 4000L),
                new Event("Bob", "/home", 5000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/prod?id=2", 6000L));


        //   TODO 统计每个用户的访问频次
        SingleOutputStreamOperator<Tuple2<String, Long>> clickUser =
                stream.map(new MapFunction<Event, Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> map(Event event) throws Exception {
                        return Tuple2.of(event.user, 1L);
                    }
                }).keyBy(data -> data.f0)
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> t1, Tuple2<String, Long> t2) throws Exception {
                        return Tuple2.of(t1.f0, t1.f1 + t2.f1);
                    }
                });


        //选取当前最活跃的用户
        SingleOutputStreamOperator<Tuple2<String, Long>> reduce = clickUser.keyBy(data -> "key")
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    //Tuple2<String, Long> value1 之前的得到的某个用户最大的值
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        return value1.f1 > value2.f1 ? value1 : value2;
                    }
                });


//        clickUser.print();
        reduce.print();
        env.execute();

    }
}

3、用户自定义函数（UDF）

Flink的DataStream API编程风格其实是一致的：基本上都是基于DataStream调用一个方法，表示要做一个转换操作；方法需要传入一个参数，这个参数都是需要实现一个接口

这些接口有一个共同特点：全部都以算子操作名称 + Function命名

例如源算子需要实现SourceFunction接口，map算子需要实现MapFunction接口，reduce算子需要实现ReduceFunction接口。而且查看源码会发现，它们都继承自Function接口;这个接口是空的，主要就是为了方便扩展为单一抽象方法（Single Abstract Method，SAM）接口，这就是我们所说的“函数接口”——比如MapFunction中需要实现一个map()方法，ReductionFunction中需要实现一个reduce()方法，它们都是SAM接口。我们知道，Java 8新增的Lambda表达式就可以实现SAM接口；所以这样的好处就是，我们不仅可以通过自定义函数类或者匿名类来实现接口，也可以直接传入Lambda表达式。这就是所谓的用户自定义函数（user-defined function，UDF）。

1. 函数类（Function Classes）

对于大部分操作而言，都需要传入一个用户自定义函数（UDF），实现相关操作的接口，来完成处理逻辑的定义。Flink暴露了所有UDF函数的接口，具体实现方式为接口或者抽象类，例如MapFunction、FilterFunction、ReduceFunction等。

package com.example.chapter05;

import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * DataStreamApi
 * Transform-Map
 */
public class TransformFilterTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);


        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home", 1000L), new Event("Silly", "/Persion", 2000L), new Event("Lisi", "/CAR", 3000L));


        //TODO 1、自定义 FilterFunction的类的对象
        SingleOutputStreamOperator<Event> filter = stream.filter(new MyFilter());

        //TODO 2、传入一个匿名类实现 FilterFunction的类的对象
        SingleOutputStreamOperator<Event> filter1 = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event value) throws Exception {
                return value.user.equals("Silly");
            }
        });

        //TODO 3、传入表达式
        SingleOutputStreamOperator<Event> filter2 = stream.filter(data -> data.user.equals("Silly"));

        filter.print();
        filter1.print();
        filter2.print();
        env.execute();

    }

    private static class MyFilter implements FilterFunction<Event> {
        @Override
        public boolean filter(Event event) throws Exception {
            return event.user.equals("Silly");
        }
    }
}

2. 匿名函数（Lambda）

匿名函数（Lambda表达式）是Java 8 引入的新特性

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class ReturnTypeResolve {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> clicks = env.fromElements(
                new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L)
        );

        // 想要转换成二元组类型，需要进行以下处理
        // 1) 使用显式的 ".returns(...)"
        DataStream<Tuple2<String, Long>> stream3 = clicks
                .map( event -> Tuple2.of(event.user, 1L) )
                .returns(Types.TUPLE(Types.STRING, Types.LONG));
        stream3.print();


        // 2) 使用类来替代Lambda表达式
        clicks.map(new MyTuple2Mapper())
                .print();

        // 3) 使用匿名类来代替Lambda表达式
        clicks.map(new MapFunction<Event, Tuple2<String, Long>>() {
            @Override
            public Tuple2<String, Long> map(Event value) throws Exception {
                return Tuple2.of(value.user, 1L);
            }
        }).print();

        env.execute();
    }

    // 自定义MapFunction的实现类
    public static class MyTuple2Mapper implements MapFunction<Event, Tuple2<String, Long>>{
        @Override
        public Tuple2<String, Long> map(Event value) throws Exception {
            return Tuple2.of(value.user, 1L);
        }
    }
}

这些方法对于其它泛型擦除的场景同样适用。

3. 富函数类（ Function Classes）

“富函数类”也是DataStream API提供的一个函数类的接口，所有的Flink函数类都有其Rich版本。富函数类一般是以抽象类的形式出现的。例如：RichMapFunction、RichFilterFunction、RichReduceFunction等。
既然“富”，那么它一定会比常规的函数类提供更多、更丰富的功能。与常规函数类的不同主要在于，富函数类可以获取运行环境的上下文，并拥有一些生命周期方法，所以可以实现更复杂的功能。

注：生命周期的概念在编程中其实非常重要，到处都有体现。例如：对于C语言来说，我们需要手动管理内存的分配和回收，也就是手动管理内存的生命周期。分配内存而不回收，会造成内存泄漏，回收没有分配过的内存，会造成空指针异常。而在JVM中，虚拟机会自动帮助我们管理对象的生命周期。对于前端来说，一个页面也会有生命周期。数据库连接、网络连接以及文件描述符的创建和关闭，也都形成了生命周期。所以生命周期的概念在编程中是无处不在的，需要我们多加注意。
Rich Function有生命周期的概念。典型的生命周期方法有：

open()方法，是Rich Function的初始化方法，也就是会开启一个算子的生命周期。当一个算子的实际工作方法例如map()或者filter()方法被调用之前，open()会首先被调用。所以像文件IO的创建，数据库连接的创建，配置文件的读取等等这样一次性的工作，都适合在open()方法中完成。。

close()方法，是生命周期中的最后一个调用的方法，类似于解构方法。一般用来做一些清理工作。
需要注意的是，这里的生命周期方法，对于一个并行子任务来说只会调用一次；而对应的，实际工作方法，例如RichMapFunction中的map()，在每条数据到来后都会触发一次调用。

package com.example.chapter05;

import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * 富函数类
 * 比常用的函数类提供更大的功能
 *      1、获取运行环境的上下文
 *      2、生命周期
 */
public class TransformRichFunctionTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);

        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home", 1000L),
                new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L));

        stream.map(new MyRichMapper())
                .print();

        env.execute();

    }

    //实现一个自定义的富函数类
    public static class MyRichMapper extends RichMapFunction<Event, Integer> {
        @Override
        public void close() throws Exception {
            super.close();
            System.out.println("close 声明周期被调用" + getRuntimeContext().getIndexOfThisSubtask() + "号任务启动");
        }

        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            System.out.println("open 声明周期被调用" + getRuntimeContext().getIndexOfThisSubtask() + "号任务启动");
        }

        @Override
        public Integer map(Event value) throws Exception {
            return value.url.length();
        }
    }
}

4、物理分区（Physical Partitioning）

顾名思义，“分区”（partitioning）操作就是要将数据进行重新分布，传递到不同的流分区去进行下一步处理。其实我们对分区操作并不陌生，前面介绍聚合算子时，已经提到了keyBy，它就是一种按照键的哈希值来进行重新分区的操作。只不过这种分区操作只能保证把数据按key“分开”，至于分得均不均匀、每个key的数据具体会分到哪一区去，这些是完全无从控制的——所以我们有时也说，keyBy是一种逻辑分区（logical partitioning）操作。

如果说keyBy这种逻辑分区是一种“软分区”，那真正硬核的分区就应该是所谓的“物理分区”（physical partitioning）。也就是我们要真正控制分区策略，精准地调配数据，告诉每个数据到底去哪里。其实这种分区方式在一些情况下已经在发生了：例如我们编写的程序可能对多个处理任务设置了不同的并行度，那么当数据执行的上下游任务并行度变化时，数据就不应该还在当前分区以直通（forward）方式传输了——因为如果并行度变小，当前分区可能没有下游任务了；而如果并行度变大，所有数据还在原先的分区处理就会导致资源的浪费。所以这种情况下，系统会自动地将数据均匀地发往下游所有的并行任务，保证各个分区的负载均衡。

有些时候，我们还需要手动控制数据分区分配策略。比如当发生数据倾斜的时候，系统无法自动调整，这时就需要我们重新进行负载均衡，将数据流较为平均地发送到下游任务操作分区中去。Flink对于经过转换操作之后的DataStream，提供了一系列的底层操作接口，能够帮我们实现数据流的手动重分区。为了同keyBy相区别，我们把这些操作统称为“物理分区”操作。物理分区与keyBy另一大区别在于，keyBy之后得到的是一个KeyedStream，而物理分区之后结果仍是DataStream，且流中元素数据类型保持不变。从这一点也可以看出，分区算子并不对数据进行转换处理，只是定义了数据的传输方式。

常见的物理分区策略有随机分配（Random）、轮询分配（Round-Robin）、重缩放（Rescale）和广播（Broadcast），下边我们分别来做了解。

1. 随机分区（shuffle）
   最简单的重分区方式就是直接“洗牌”。通过调用DataStream的.shuffle()方法，将数据随机地分配到下游算子的并行任务中去。
   随机分区服从均匀分布（uniform distribution），所以可以把流中的数据随机打乱，均匀地传递到下游任务分区，如图5-9所示。因为是完全随机的，所以对于同样的输入数据, 每次执行得到的结果也不会相同。

2. 轮询分区（Round-Robin）
   轮询也是一种常见的重分区方式。简单来说就是“发牌”，按照先后顺序将数据做依次分发，通过调用DataStream的.rebalance()方法，就可以实现轮询重分区。rebalance使用的是Round-Robin负载均衡算法，可以将输入流数据平均分配到下游的并行任务中去。
   注：Round-Robin算法用在了很多地方，例如Kafka和Nginx。

3. 重缩放分区（rescale）
   重缩放分区和轮询分区非常相似。当调用rescale()方法时，其实底层也是使用Round-Robin算法进行轮询，但是只会将数据轮询发送到下游并行任务的一部分中，也就是说，“发牌人”如果有多个，那么rebalance的方式是每个发牌人都面向所有人发牌；而rescale的做法是分成小团体，发牌人只给自己团体内的所有人轮流发牌。

package com.example.chapter05;

import org.apache.flink.api.common.functions.Partitioner;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;
import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;


/**
 * keyBy 逻辑分区
 * <p>
 * 物理分区
 * shuffle() 随机分区
 *
 * 轮询分区 并行的
 * rescale 重缩放分区
 * 广播-每条数据都被处理了四次
 * 全局分区 -把所有的数据都分别配到一个分区里面、已经做过分析计算得到的少量结果、这个时候可以使用全局分区
 * 自定义重分区(partitionCustom用户自定义的)
 */
public class TransformPartitionTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "/home",
                1000L), new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/Persion?id=1", 4000L),
                new Event("Bob", "/home", 5000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/prod?id=2", 6000L));


        //随机分区
        // stream.shuffle().print().setParallelism(4);

        //轮询分区 并行的
//        stream.print().setParallelism(4);


        //rescale 重缩放分区
        env.addSource(new RichParallelSourceFunction<Integer>() {
            @Override
            public void run(SourceContext<Integer> ctx) throws Exception {
                for (int i = 0; i < 8; i++) {
                    //偶数0 奇是1
                    //将奇偶数分别发送到0和1号并行分区
                    if (i % 2 == getRuntimeContext().getIndexOfThisSubtask()) {
                        ctx.collect(i);
                    }
                }
            }

            @Override
            public void cancel() {

            }
        }).setParallelism(2);//setParallelism 并行子任务
//                .rebalance()
//                .print()
//                .setParallelism(4);


        //4、广播-每条数据都被处理了四次
//        stream.broadcast().print().setParallelism(4);

        //5、全局分区 -把所有的数据都分别配到一个分区里面、已经做过分析计算得到的少量结果、这个时候可以使用全局分区
//        stream.global().print().setParallelism(4);

        //6、自定义重分区(partitionCustom用户自定义的)
        env.fromElements(1, 2, 3, 4, 5, 6, 7, 8)
                .partitionCustom(new Partitioner<Integer>() {
                    @Override
                    public int partition(Integer key, int numPartitions) {
                        return key % 2;
                    }
                }, new KeySelector<Integer, Integer>() {
                    @Override
                    public Integer getKey(Integer value) throws Exception {
                        return value;
                    }
                })
                .print().setParallelism(4);

        env.execute();
    }
}


/**
 * rescale
 * 2> 2
 * 1> 0
 * 4> 3
 * 3> 1
 * 4> 7
 * 1> 4
 * 2> 6
 * 3> 5
 * <p>
 * 1234 完全轮询
 * rebalance
 * 3> 5
 * 2> 3
 * 4> 7
 * 1> 1
 * 1> 0
 * 3> 4
 * 2> 2
 * 4> 6
 */

八、输出算子（Sink）

Flink作为数据处理框架，最终还是要把计算处理的结果写入外部存储，为外部应用提供支持，如图5-12所示，本节将主要讲解Flink中的Sink操作。我们已经了解了Flink程序如何对数据进行读取、转换等操作，最后一步当然就应该将结果数据保存或输出到外部系统了。

1、连接到外部系统

在Flink中，如果我们希望将数据写入外部系统，其实并不是一件难事。我们知道所有算子都可以通过实现函数类来自定义处理逻辑，所以只要有读写客户端，与外部系统的交互在任何一个处理算子中都可以实现。例如在MapFunction中，我们完全可以构建一个到Redis的连接，然后将当前处理的结果保存到Redis中。如果考虑到只需建立一次连接，我们也可以利用RichMapFunction，在open() 生命周期中做连接操作。

这样看起来很方便，却会带来很多问题。Flink作为一个快速的分布式实时流处理系统，对稳定性和容错性要求极高。一旦出现故障，我们应该有能力恢复之前的状态，保障处理结果的正确性。这种性质一般被称作“状态一致性”。Flink内部提供了一致性检查点（checkpoint）来保障我们可以回滚到正确的状态；但如果我们在处理过程中任意读写外部系统，发生故障后就很难回退到从前了。

为了避免这样的问题，Flink的DataStream API专门提供了向外部写入数据的方法：addSink。与addSource类似，addSink方法对应着一个“Sink”算子，主要就是用来实现与外部系统连接、并将数据提交写入的；Flink程序中所有对外的输出操作，一般都是利用Sink算子完成的。

Sink一词有“下沉”的意思，有些资料会相对于“数据源”把它翻译为“数据汇”。不论怎样理解，Sink在Flink中代表了将结果数据收集起来、输出到外部的意思，所以我们这里统一把它直观地叫作“输出算子”。

addSource的参数需要实现一个SourceFunction接口；类似地，addSink方法同样需要传入一个参数，实现的是SinkFunction接口。在这个接口中只需要重写一个方法invoke(),用来将指定的值写入到外部系统中。这个方法在每条数据记录到来时都会调用：

default void invoke(IN value, Context context) throws Exception

SinkFuntion多数情况下同样并不需要我们自己实现。Flink官方提供了一部分的框架的Sink连接器。如图5-13所示，列出了Flink官方目前支持的第三方系统连接器

我们可以看到，像Kafka之类流式系统，Flink提供了完美对接，source/sink两端都能连接，可读可写；而对于Elasticsearch、文件系统（FileSystem）、JDBC等数据存储系统，则只提供了输出写入的sink连接器。

除Flink官方之外，Apache Bahir作为给Spark和Flink提供扩展支持的项目，也实现了一些其他第三方系统与Flink的连接器，如图5-14所示。

除此以外，就需要用户自定义实现sink连接器了。

行编码：StreamingFileSink.forRowFormat（basePath，rowEncoder）。

批量编码：StreamingFileSink.forBulkFormat（basePath，bulkWriterFactory）。

1）读取文件

package com.example.chapter05;

import org.apache.flink.api.common.serialization.SimpleStringEncoder;
import org.apache.flink.core.fs.Path;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.sink.filesystem.StreamingFileSink;
import org.apache.flink.streaming.api.functions.sink.filesystem.rollingpolicies.DefaultRollingPolicy;

import java.util.concurrent.TimeUnit;


/**
 * 输出到文件
 * Sink
 */
public class SinkToFileTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);


        DataStreamSource<Event> stream = env.fromElements(
                new Event("Mary", "/home", 1000L), new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/Persion?id=1", 4000L),
                new Event("Bob", "/home", 5000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/prod?id=2", 6000L));


        /**
         * 行编码：StreamingFileSink.forRowFormat（basePath，rowEncoder）。
         * 批量编码：StreamingFileSink.forBulkFormat（basePath，bulkWriterFactory）。
         */
        StreamingFileSink<String> build = StreamingFileSink.<String>forRowFormat(new Path("./output"),
                        new SimpleStringEncoder<>("UTF-8"))
                        .withRollingPolicy(
                                DefaultRollingPolicy.builder()          //builder 设计模式
                        .withMaxPartSize(1024 * 1024 * 1024) //如果是1G的字节的话（1024 * 1024 * 1024） 大于一G进行归档保存、然后开启新的文件保存
                        .withRolloverInterval(TimeUnit.MINUTES.toMinutes(15)) //隔多少时间间隔都要滚动一次、那就是相当于要开启一个新的文件
                        .withInactivityInterval(TimeUnit.MINUTES.toMinutes(5))// 当前不活跃的间隔时间、隔了多少时间没有数据到来、我就认为当前事件已经结束了、
                        .build()
                )//滚动策略
                .build();

        stream.map(data -> data.toString())
                .addSink(build);

        env.execute();

    }
}

2、链接到KafKa

1）输出到Kafka

Kafka是一个分布式的基于发布/订阅的消息系统，本身处理的也是流式数据，所以跟Flink“天生一对”，经常会作为Flink的输入数据源和输出系统。Flink官方为Kafka提供了Source和Sink的连接器，我们可以用它方便地从Kafka读写数据。如果仅仅是支持读写，那还说明不了Kafka和Flink关系的亲密；真正让它们密不可分的是，Flink与Kafka的连接器提供了端到端的精确一次（exactly once）语义保证，这在实际项目中是最高级别的一致性保证。

2) 导入依赖

    <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>

3) 编码

package com.example.chapter05;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;

import java.util.Properties;

/**
 * Sink
 * 输出到 Kafka
 */
public class SinkToKafka {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "hadoop102:9092");
        DataStreamSource<String> kafkaStream = env.addSource(
                new FlinkKafkaConsumer<String>("click", new SimpleStringSchema(), properties));


        //2、用flink进行转换处理
        SingleOutputStreamOperator<String> result = kafkaStream.map(
                new MapFunction<String, String>() {
                    @Override
                    public String map(String value) throws Exception {
                        String[] fields = value.split(",");
                        return new Event(fields[0].trim(), fields[1].trim(), Long.valueOf(fields[2].trim())).toString();
                    }
                }
        );

        //3、结果数据写入kafka
        result.addSink(new FlinkKafkaProducer<String>(
                "hadoop102:9092",
                "evens",
                new SimpleStringSchema()));

        env.execute();
    }
}

3、输出到Redis

Redis是一个开源的内存式的数据存储，提供了像字符串（string）、哈希表（hash）、列表（list）、集合（set）、排序集合（sorted set）、位图（bitmap）、地理索引和流（stream）等一系列常用的数据结构。因为它运行速度快、支持的数据类型丰富，在实际项目中已经成为了架构优化必不可少的一员，一般用作数据库、缓存，也可以作为消息代理。

（1）导入的Redis连接器依赖

<dependency>
  <groupId>org.apache.bahir</groupId>
  <artifactId>flink-connector-redis_2.11</artifactId>
  <version>1.0</version>
</dependency>

（2） 编码

package com.example.chapter05;

import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.redis.RedisSink;
import org.apache.flink.streaming.connectors.redis.common.config.FlinkJedisPoolConfig;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommand;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommandDescription;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisMapper;

/**
 *
 * 输出到Redis
 * 
 */
public class SinkToRedis {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);


        DataStreamSource<Event> stream = env.addSource(new ClickSource());

        FlinkJedisPoolConfig config = new FlinkJedisPoolConfig.Builder()
                .setHost("hadoop102")
                .setPassword("000000")
                .build();

        stream.addSink(new RedisSink<>(config, new MyRedisMapper()));

        env.execute();
    }


    //自定义MyRedisMapper 接口
    public static class MyRedisMapper implements RedisMapper<Event> {

        @Override
        public RedisCommandDescription getCommandDescription() {
            return new RedisCommandDescription(RedisCommand.HSET, "clicks");
        }

        @Override
        public String getKeyFromData(Event data) {
            return data.user;
        }

        @Override
        public String getValueFromData(Event data) {
            return data.url;
        }
    }
}

4、输出到ES

ElasticSearch是一个分布式的开源搜索和分析引擎，适用于所有类型的数据。ElasticSearch有着简洁的REST风格的API，以良好的分布式特性、速度和可扩展性而闻名，在大数据领域应用非常广泛。
Flink为ElasticSearch专门提供了官方的Sink 连接器，Flink 1.13支持当前最新版本的ElasticSearch。

与RedisSink类似，连接器也为我们实现了写入到Elasticsearch的SinkFunction——ElasticsearchSink。区别在于，这个类的构造方法是私有（private）的，我们需要使用ElasticsearchSink的Builder内部静态类，调用它的build()方法才能创建出真正的SinkFunction。
而Builder的构造方法中又有两个参数：
httpHosts：连接到的Elasticsearch集群主机列表
elasticsearchSinkFunction：这并不是我们所说的SinkFunction，而是用来说明具体处理逻辑、准备数据向Elasticsearch发送请求的函数
具体的操作需要重写中elasticsearchSinkFunction中的process方法，我们可以将要发送的数据放在一个HashMap中，包装成IndexRequest向外部发送HTTP请求。

（1）添加Elasticsearch 连接器依赖

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-connector-elasticsearch7_${scala.binary.version}</artifactId>
    <version>${flink.version}</version>
</dependency>

（2）编码

package com.example.chapter05;

import org.apache.flink.api.common.functions.RuntimeContext;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.elasticsearch.ElasticsearchSinkFunction;
import org.apache.flink.streaming.connectors.elasticsearch.RequestIndexer;
import org.apache.flink.streaming.connectors.elasticsearch7.ElasticsearchSink;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.Requests;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * SINK
 * 输出到ES
 */
public class SinkToEs {
    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);


        DataStreamSource<Event> stream = env.fromElements(
                new Event("Mary", "/home", 1000L), new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/Persion?id=1", 4000L),
                new Event("Bob", "/home", 5000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/prod?id=2", 6000L));


        List<HttpHost> httpHosts = new ArrayList<>();
        httpHosts.add(new HttpHost("hadoop102", 9200));

        //定义ElasticsearchSinkFunction
        ElasticsearchSinkFunction<Event> elasticsearchSinkFunction = new ElasticsearchSinkFunction<Event>() {


            /**
             *
             * @param event 每一个元素
             * @param runtimeContext 运行时上下文
             * @param requestIndexer 发送请求
             */
            @Override
            public void process(Event event, RuntimeContext runtimeContext, RequestIndexer requestIndexer) {
                HashMap<String, String> map = new HashMap<>();
                map.put(event.user, event.url);

                //构建一个IndexRequest
                IndexRequest request = Requests.indexRequest()
                        .index("clicks") //类似表名
                        .type("type") //ES6需要定义type、7不需要
                        .source(map); //数据

                requestIndexer.add(request);
            }
        };

        //写入ES
        stream.addSink(new ElasticsearchSink.Builder<>(httpHosts, elasticsearchSinkFunction).build());

    }
}

5、输出到MySQL（JDBC）

关系型数据库有着非常好的结构化数据设计、方便的SQL查询，是很多企业中业务数据存储的主要形式。MySQL就是其中的典型代表。尽管在大数据处理中直接与MySQL交互的场景不多，但最终处理的计算结果是要给外部应用消费使用的，而外部应用读取的数据存储往往就是MySQL。所以我们也需要知道如何将数据输出到MySQL这样的传统数据库。

（1）添加依赖

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-connector-jdbc_${scala.binary.version}</artifactId>
    <version>${flink.version}</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

(2) 启动MySQL，在database库下建表clicks

mysql> create table clicks(
    -> user varchar(20) not null,
    -> url varchar(100) not null);

package com.example.chapter05;

import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
import org.apache.flink.connector.jdbc.JdbcSink;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;


/**
 * Sink
 * 输出Mysql
 */
public class SinkMySQL {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<Event> stream = env.fromElements(
                new Event("Mary", "/home", 1000L), new Event("Silly", "/Persion", 2000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/Persion?id=1", 4000L),
                new Event("Bob", "/home", 5000L),
                new Event("Alice", "/Persion?id=100", 3000L),
                new Event("Bob", "/prod?id=2", 6000L));

        /**
         * 参数1 sql
         * 参数2 占位符
         * 参数三配置链接
         */
        stream.addSink(JdbcSink.sink(
                "INSERT INTO clicks (user,url) VALUES (?,?)",
                ((statement, event) -> {
                    statement.setString(1, event.user);
                    statement.setString(2, event.url);
                }),

              //mysql 配置
                new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
                        .withUrl("")
                        .withDriverName("com.mysql.jdbc.Driver")
                        .withUsername("root")
                        .withPassword("uexpo@110")
                        .build()

        ));
        env.execute();
    }
}

6、自定义Sink输出

如果我们想将数据存储到我们自己的存储设备中，而Flink并没有提供可以直接使用的连接器，又该怎么办呢？

与Source类似，Flink为我们提供了通用的SinkFunction接口和对应的RichSinkDunction抽象类，只要实现它，通过简单地调用DataStream的.addSink()方法就可以自定义写入任何外部存储。之前与外部系统的连接，其实都是连接器帮我们实现了SinkFunction，现在既然没有现成的，我们就只好自力更生了。例如，Flink并没有提供HBase的连接器，所以需要我们自己写。

在实现SinkFunction的时候，需要重写的一个关键方法invoke()，在这个方法中我们就可以实现将流里的数据发送出去的逻辑。

我们这里使用了SinkFunction的富函数版本，因为这里我们又使用到了生命周期的概念，创建HBase的连接以及关闭HBase的连接需要分别放在open()方法和close()方法中

（1）导入依赖

<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>${hbase.version}</version>
</dependency>

（2）编码

package com.example.chapter05.datasource;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;

import java.nio.charset.StandardCharsets;

/**
 * 自定义Sink输出
 * 自定义连接器
 */
public class SinkToHbase {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<String> streamSource = env.fromElements("hello", "world");

        streamSource.addSink(
                new RichSinkFunction<String>() {
                    public org.apache.hadoop.conf.Configuration configuration; // 管理Hbase的配置信息,这里因为Configuration的重名问题，将类以完整路径导入
                    public Connection connection; // 管理Hbase连接

                    @Override
                    public void open(Configuration parameters) throws Exception {
                        super.open(parameters);
                        configuration = HBaseConfiguration.create();
                        configuration.set("hbase.zookeeper.quorum", "hadoop102:2181");
                        connection = ConnectionFactory.createConnection(configuration);
                    }

                    @Override
                    public void invoke(String value, Context context) throws Exception {
                        Table table = connection.getTable(TableName.valueOf("test")); // 表名为test
                        Put put = new Put("rowkey".getBytes(StandardCharsets.UTF_8)); // 指定rowkey
                        put.addColumn("info".getBytes(StandardCharsets.UTF_8) // 指定列名
                                , value.getBytes(StandardCharsets.UTF_8) // 写入的数据
                                , "1".getBytes(StandardCharsets.UTF_8)); // 写入的数据
                        table.put(put); // 执行put操作
                        table.close(); // 将表关闭
                    }

                    @Override
                    public void close() throws Exception {
                        super.close();
                        connection.close(); // 关闭连接
                    }
                }
        );

        env.execute();
    }

}

最后

以上就是虚幻发带为你收集整理的DataStream API（基础篇） 完整使用 (第五章)一、执行环境（Execution Environment）二、执行模式(Execution Mode)三、触发程序执行四、源算子（Source）五、自定义Source六、Flink 支持的数据类型七、转换算子（Transformation）八、输出算子（Sink）的全部内容，希望文章能够帮你解决DataStream API（基础篇） 完整使用 (第五章)一、执行环境（Execution Environment）二、执行模式(Execution Mode)三、触发程序执行四、源算子（Source）五、自定义Source六、Flink 支持的数据类型七、转换算子（Transformation）八、输出算子（Sink）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。