如何在flink中传递参数

众所周知，flink作为流计算引擎，处理源源不断的数据是其本意，但是在处理数据的过程中，往往可能需要一些参数的传递，那么有哪些方法进行参数的传递？在什么时候使用？这里尝试进行简单的总结。

• 使用configuration

　　在main函数中定义变量

 // Class in Flink to store parameters
 Configuration configuration = new Configuration();
 configuration.setString("genre", "Action");
 
 lines.filter(new FilterGenreWithParameters())
         // Pass parameters to a function
         .withParameters(configuration)
         .print();

　　使用参数的function需要继承自一个rich的function，这样才可以在open方法中获取相应的参数。

 class FilterGenreWithParameters extends RichFilterFunction<Tuple3<Long, String, String>> {
 
     String genre;
 
     @Override
     public void open(Configuration parameters) throws Exception {
         // Read the parameter
         genre = parameters.getString("genre", "");
     }
 
     @Override
     public boolean filter(Tuple3<Long, String, String> movie) throws Exception {
         String[] genres = movie.f2.split("\\|");
 
         return Stream.of(genres).anyMatch(g -> g.equals(genre));
     }
 }

• 使用ParameterTool

使用configuration虽然传递了参数，但显然不够动态，每次参数改变，都涉及到程序的变更，既然main函数能够接受参数，flink自然也提供了相应的承接的机制，即ParameterTool。

如果使用ParameterTool，则在参数传递上如下

 public static void main(String... args) {
     // Read command line arguments
     ParameterTool parameterTool = ParameterTool.fromArgs(args);
 
 final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
 env.getConfig().setGlobalJobParameters(parameterTool);
 ...
 
 // This function will be able to read these global parameters
 lines.filter(new FilterGenreWithGlobalEnv())
                 .print();
 }

如上面代码，使用parameterTool来承接main函数的参数，通过env来设置全局变量来进行分发，那么在继承了rich函数的逻辑中就可以使用这个全局参数。

 class FilterGenreWithGlobalEnv extends RichFilterFunction<Tuple3<Long, String, String>> {
 
     @Override
     public boolean filter(Tuple3<Long, String, String> movie) throws Exception {
         String[] genres = movie.f2.split("\\|");
         // Get global parameters
         ParameterTool parameterTool = (ParameterTool) getRuntimeContext().getExecutionConfig().getGlobalJobParameters();
         // Read parameter
         String genre = parameterTool.get("genre");
 
         return Stream.of(genres).anyMatch(g -> g.equals(genre));
     }
 }

• 使用broadcast变量

在上面使用configuration和parametertool进行参数传递会很方便，但是也仅仅适用于少量参数的传递，如果有比较大量的数据传递，flink则提供了另外的方式来进行，其中之一即是broadcast，这个也是在其他计算引擎中广泛使用的方法之一。

 DataSet<Integer> toBroadcast = env.fromElements(1, 2, 3);
 // Get a dataset with words to ignore
 DataSet<String> wordsToIgnore = ...
 
 data.map(new RichFlatMapFunction<String, String>() {
 
     // A collection to store words. This will be stored in memory
     // of a task manager
     Collection<String> wordsToIgnore;
 
     @Override
     public void open(Configuration parameters) throws Exception {
         // Read a collection of words to ignore
         wordsToIgnore = getRuntimeContext().getBroadcastVariable("wordsToIgnore");
     }
 
     @Override
     public String map(String line, Collector<String> out) throws Exception {
         String[] words = line.split("\\W+");
         for (String word : words)
             // Use the collection of words to ignore
             if (wordsToIgnore.contains(word))
                 out.collect(new Tuple2<>(word, 1));
     }
     // Pass a dataset via a broadcast variable
 }).withBroadcastSet(wordsToIgnore, "wordsToIgnore");

在第3行定义了需要进行广播的数据集，在第27行指定了将此数据集进行广播的目的地。

广播的变量会保存在tm的内存中，这个也必然会使用tm有限的内存空间，也因此不能广播太大量的数据。

那么，对于数据量更大的广播需要，要如何进行？flink也提供了缓存文件的机制，如下。

• 使用distributedCache

首先还是需要在定义dag图的时候指定缓存文件：

 ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
 
 // Register a file from HDFS
 env.registerCachedFile("hdfs:///path/to/file", "machineLearningModel")
 
 ...
 
 env.execute()

flink本身支持指定本地的缓存文件，但一般而言，建议指定分布式存储比如hdfs上的文件，并为其指定一个名称。

使用起来也很简单，在rich函数的open方法中进行获取。

 class MyClassifier extends RichMapFunction<String, Integer> {
 
     @Override
     public void open(Configuration config) {
       File machineLearningModel = getRuntimeContext().getDistributedCache().getFile("machineLearningModel");
       ...
     }
 
     @Override
     public Integer map(String value) throws Exception {
       ...
     }
 }

上面的代码忽略了对文件内容的处理。

在上面的几个方法中，应该说参数本身都是static的，不会变化，那么如果参数本身随着时间也会发生变化，怎么办？

嗯，那就用connectStream，其实也是流的聚合了。

• 使用connectStream

使用ConnectedStream的前提当然是需要有一个动态的流，比如在主数据之外，还有一些规则数据，这些规则数据会通过Restful服务来发布，假如我们的主数据来自于kafka，

那么，就可以如下：

 DataStreamSource<String> input = (DataStreamSource) KafkaStreamFactory
                 .getKafka08Stream(env, srcCluster, srcTopic, srcGroup);
 
 DataStream<Tuple2<String, String>> appkeyMeta = env.addSource(new AppKeySourceFunction(), "appkey")
 
 ConnectedStreams<String, Tuple2<String, String>> connectedStreams = input.connect(appkeyMeta.broadcast());
 
 DataStream<String> cleanData = connectedStreams.flatMap(new DataCleanFlatMapFunction())

其实可以看到，上面的代码中做了四件事，首先在第1行定义了获取主数据的流，在第4行定义了获取规则数据的流，在AppKeySourceFunction中实现了读取Restful的逻辑，

在第6行实现了将规则数据广播到主数据中去，最后在第8行实现了从connectedStream中得到经过处理的数据。其中的关键即在于DataCleanFlatMapFunction。

 public class DataCleanFlatMapFunction extends RichCoFlatMapFunction<String, Tuple2<String, String>, String>{
 
 public void flatMap1(String s, Collector<String> collector){...}
 
 public void flatMap2(Tuple2<String, String> s, Collector<String> collector) {...}
 
 }

这是一段缩减的代码，关键在于第一行，首先这个函数需要实现RichCoFlatMapFunction这个抽象类，其次在类实现中，flatMap2会承接规则函数，flatMap1会承接主函数。

当然，参数可以从client发送到task，有时候也需要从task发回到client，一般这里就会使用accumulator。

这里先看一个简单的例子，实现单词的计数以及处理文本的记录数：

 DataSet<String> lines = ...
 
 // Word count algorithm
 lines.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
     @Override
     public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception {
         String[] words = line.split("\\W+");
         for (String word : words) {
             out.collect(new Tuple2<>(word, 1));
         }
     }
 })
 .groupBy(0)
 .sum(1)
 .print();
 
 // Count a number of lines in the text to process
 int linesCount = lines.count()
 System.out.println(linesCount);

上面的代码中，第14行实现了单词的计算，第18行实现了处理记录的行数，但很可惜，这里会产生两个job，仅仅第18行一句代码，就会产生一个job，无疑是不高效的。

flink提供了accumulator来实现数据的回传，亦即从tm传回到JM。

flink本身提供了一些内置的accumulator:

• IntCounter, LongCounter, DoubleCounter – allows summing together int, long, double values sent from task managers
• AverageAccumulator – calculates an average of double values
• LongMaximum, LongMinimum, IntMaximum, IntMinimum, DoubleMaximum, DoubleMinimum – accumulators to determine maximum and minimum values for different types
• Histogram – used to computed distribution of values from task managers

首先需要定义一个accumulator，然后在某个自定义函数中来注册它，这样在客户端就可以获取相应的的值。

 lines.flatMap(new RichFlatMapFunction<String, Tuple2<String, Integer>>() {
 
     // Create an accumulator
     private IntCounter linesNum = new IntCounter();
 
     @Override
     public void open(Configuration parameters) throws Exception {
         // Register accumulator
         getRuntimeContext().addAccumulator("linesNum", linesNum);
     }
 
     @Override
     public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception {
         String[] words = line.split("\\W+");
         for (String word : words) {
             out.collect(new Tuple2<>(word, 1));
         }
 
         // Increment after each line is processed
         linesNum.add(1);
     }
 })
 .groupBy(0)
 .sum(1)
 .print();
 
 // Get accumulator result
 int linesNum = env.getLastJobExecutionResult().getAccumulatorResult("linesNum");
 System.out.println(linesNum);

当然，如果内置的accumulator不能满足需求，可以自定义accumulator，只需要继承两个接口之一即可，Accumulator或者SimpleAccumulato。

上面介绍了几种参数传递的方式，在日常的使用中，可能不仅仅是使用其中一种，或许是某些的组合，比如通过parametertool来传递hdfs的路径，再通过filecache来读取缓存。