Flink读取Kafka数据下沉到HDFS

1：采用BucketingSink的方式

public class BucketingSinkDemo {
	public static void main(String[] args) throws Exception {
	
		long rolloverInterval = 2 * 60 * 1000;
		long batchSize = 1024 * 1024 * 100;

		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setParallelism(1);
	    System.setProperty("HADOOP_USER_NAME", "hadoop");
		String topic = "ods_lark_order";
		Properties prop = new Properties();
		prop.setProperty("bootstrap.servers","ip:port");
		prop.setProperty("group.id","groupid");
		FlinkKafkaConsumer<String> kafkaConsumer = new FlinkKafkaConsumer<>(topic, new SimpleStringSchema(), prop);
		kafkaConsumer.setStartFromGroupOffsets();//默认消费策略
		DataStreamSource<String> source = env.addSource(kafkaConsumer);
		//
		BucketingSink<String> hadoopSink = new BucketingSink<>("hdfs://ip:port/flink/order_sink");
		// HDFS的配置
		Configuration configuration = new Configuration();
		// 1.能够指定block的副本数
		configuration.set("dfs.replication","1");
		hadoopSink.setFSConfig(configuration);
		// 2.指定分区文件夹的命名
		hadoopSink.setBucketer(new DateTimeBucketer<>("yyyy-MM-dd--HH", ZoneId.of("Asia/Shanghai")));
		// 3.指定块大小和时间间隔生成新的文件
		hadoopSink.setBatchSize(batchSize);
		hadoopSink.setBatchRolloverInterval(rolloverInterval);
		// 4.指定生成文件的前缀，后缀，正在运行文件前缀
		hadoopSink.setPendingPrefix("order_sink");
		hadoopSink.setPendingSuffix("");
		hadoopSink.setInProgressPrefix(".in");
		source.addSink(hadoopSink);
		env.execute();
	}
}

采用这种方式的好处：

1.能够指定block的副本数

2.指定分区文件夹的命名

3.指定块大小和时间间隔生成新的文件

4.指定生成文件的前缀，后缀，正在运行文件前缀

缺点：

该方法已经过期，新版建议采用StreamingFileSink，笔者第一次找到该类发现能够写入成功，但是没有找到如何能够对写入HDFS进行压缩，比如parquet或者orc

2：采用StreamingFileSink的方式-行编码【forRowFormat】

public class StreamingFileSinkForRowFormatDemo {
	public static void main(String[] args) throws Exception {

		//获取Flink的运行环境
		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setParallelism(1);
		System.setProperty("HADOOP_USER_NAME", "hadoop");
		String topic = "ods_lark_order";
		Properties prop = new Properties();
		prop.setProperty("bootstrap.servers","ip:port");
		prop.setProperty("group.id","first");

		FlinkKafkaConsumer<String> myConsumer = new FlinkKafkaConsumer<>(topic, new SimpleStringSchema(), prop);
		myConsumer.setStartFromGroupOffsets();//默认消费策略
		DataStreamSource<String> source = env.addSource(myConsumer);


		// 自定义滚动策略
		DefaultRollingPolicy<String, String> rollPolicy = DefaultRollingPolicy.builder()
				.withRolloverInterval(TimeUnit.MINUTES.toMillis(2))/*每隔多长时间生成一个文件*/
				.withInactivityInterval(TimeUnit.MINUTES.toMillis(5))/*默认60秒,未写入数据处于不活跃状态超时会滚动新文件*/
				.withMaxPartSize(128 * 1024 * 1024)/*设置每个文件的最大大小 ,默认是128M*/
				.build();
		// 输出文件的前、后缀配置
		OutputFileConfig config = OutputFileConfig
				.builder()
				.withPartPrefix("prefix")
				.withPartSuffix(".txt")
				.build();
		StreamingFileSink<String> streamingFileSink = StreamingFileSink
				.forRowFormat(new Path("hdfs://192.168.1.204:9000/flink/data/"),new SimpleStringEncoder<String>("UTF-8") )
				.withBucketAssigner(new DateTimeBucketAssigner<>())
				// 设置指定的滚动策略
				.withRollingPolicy(rollPolicy)
				// 桶检查间隔，这里设置为1s
				.withBucketCheckInterval(1)
				// 指定输出文件的前、后缀
				.withOutputFileConfig(config)
				.build();
		source.addSink(streamingFileSink);
		env.execute("StreamingFileSinkTest");
	}
}

采用这种方式的好处：

1.能够指定block的副本数

2.指定分区文件夹的命名

3.指定块大小和时间间隔生成新的文件

4.指定生成文件的前缀，后缀，正在运行文件前缀

缺点：

由于是按照行进行的，所以不能进行压缩

3：采用StreamingFileSink的方式-bucket压缩 【forBulkFormat】

public class StreamingFileSinkDemo {
	public static void main(String[] args) throws Exception {

		//获取Flink的运行环境
		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setParallelism(1);
		// checkpoint配置
		env.enableCheckpointing(60000);
		System.setProperty("HADOOP_USER_NAME", "hadoop");
		String topic = "ods_lark_order";
		Properties prop = new Properties();
		prop.setProperty("bootstrap.servers","ip:port");
		prop.setProperty("group.id","first");
        // 获取流
		FlinkKafkaConsumer<String> myConsumer = new FlinkKafkaConsumer<>(topic, new SimpleStringSchema(), prop);
		myConsumer.setStartFromGroupOffsets();
		DataStreamSource<String> source = env.addSource(myConsumer);
		DataStream<Order> nameDS = source.map(new MapFunction<String, Order>() {
			@Override
			public Order map(String s) throws Exception {
				Order order = new Order();
				JSONObject jsonObject = JSONObject.parseObject(s);
				order.setName(jsonObject.getString("name"));
				return order;
			}
		});

		// 1.输出文件的前、后缀配置
		OutputFileConfig config = OutputFileConfig
				.builder()
				.withPartPrefix("prefix")
				.withPartSuffix(".txt")
				.build();
		// 设置为Parquet的压缩方式
		StreamingFileSink<Order> streamingFileSink = StreamingFileSink
				.forBulkFormat(new Path("hdfs://192.168.1.204:9000/flink/data/"), ParquetAvroWriters.forReflectRecord(Order.class))
				/*这里是采用默认的分桶策略DateTimeBucketAssigner，它基于时间的分配器，每小时产生一个桶，格式如下yyyy-MM-dd--HH*/
				.withBucketAssigner(new DateTimeBucketAssigner<>())
				.withRollingPolicy(OnCheckpointRollingPolicy.build())
				.withOutputFileConfig(config)
				.build();
				
		nameDS.addSink(streamingFileSink);
		env.execute("StreamingFileSinkTest");
	}
}

采用这种方式的好处：

1.输出文件的前、后缀配置

2.设置为Parquet的压缩方式

缺点：

文件生成是通过checkpoint时候触发的，当checkpoint 过于频繁的话会生成很多的小文件，同时任务数过多，也会生成很多小文件，涉及到后续的小文件合并的情况