flink学习(8)之分布式缓存、广播变量、累加器

1、分布式缓存缓存的是文件，当程序启动的时候把把这份文件拷贝到没给TaskManager上，当该taskManager上的task使用的时候直接调去本地副本上的文件即可。
经常用到的一个函数就是RichMapFunction和open方法。
代码：

import org.apache.commons.io.FileUtils;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.configuration.Configuration;
import scala.Int;

import java.io.File;
import java.util.List;

public class DistributeCacheDemo {
    public static void main(String[] args) throws Exception {
        //创建一个离线计算的运行环境
        ExecutionEnvironment env=ExecutionEnvironment.getExecutionEnvironment();
        //注册一个本地文件，也可以是HDFS
        env.registerCachedFile("G:\\aa\\CCC.CSV","localfile");
        DataSet<Integer> source=env.fromElements(1,2,3,4,5,6);
        source.map(new RichMapFunction<Integer, String>() {
            //保存缓存的数据
            private String cacheData="";
            @Override
            public void open(Configuration parameters) throws Exception {
                File file = getRuntimeContext().getDistributedCache().getFile("localfile");
                List<String> lines = FileUtils.readLines(file);
                cacheData=lines.get(0);
            }

            public String map(Integer value) throws Exception {
                return value+cacheData;
            }

        }).print();
        //环境执行
        env.execute();
    }
}

2、广播变量和分布式缓存道理差不多，它是把一个变量广播出去，而不是文件。使用到的task共用用一份变量，这份变量被保存在每个节点的内存中。这些task可以在一个节点上也可以在不同的节点上。广播变量为了保证各个节点上的数据是一致的只能使用不能修改。
代码：

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import scala.Int;

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

public class BroadCastDemo {
    public static void main(String[] args) throws Exception {
        //获取执行环境
        ExecutionEnvironment env=ExecutionEnvironment.getExecutionEnvironment();
        //创建广播数据源
        List<Tuple2<String,Integer>> people=new ArrayList<Tuple2<String,Integer>>();
        //添加数据源
        people.add(new Tuple2<String, Integer>("Tom",23));
        people.add(new Tuple2<String, Integer>("Mary",20));
        people.add(new Tuple2<String, Integer>("Mike",26));
        DataSet<Tuple2<String, Integer>> peopleData=env.fromCollection(people);
        //定义一个需要广播的变量，把Tuple2----> HashMap
        DataSet<Map<String,Integer>> peopleBroadCast=
                peopleData.map(new MapFunction<Tuple2<String, Integer>, Map<String, Integer>>() {
                    public Map<String, Integer> map(Tuple2<String, Integer> value) throws Exception {
                        Map<String, Integer> map = new HashMap<String, Integer>();
                        map.put(value.f0,value.f1);
                        return map;
                    }
                });
        //执行计算：根据人的姓名来获取年龄
        DataSet<String> source=env.fromElements("Tom","Mary","Mike");
        source.map(new RichMapFunction<String,String>() {
            //定义一个HashMap保存所有广播变量的数据
            private HashMap<String,Integer> allMap=new HashMap<String, Integer>();
            @Override
            public void open(Configuration parameters) throws Exception {
                //获取广播变量的数据
                List<Map<String,Integer>> data=getRuntimeContext().getBroadcastVariable("mybroadcast");
                for (Map<String,Integer> d:data
                     ) {
                    allMap.putAll(d);
                }
            }

            public String map(String name) throws Exception {
                //根据人的姓名获取年龄
                Integer age=allMap.get(name);
                return "姓名："+name+"\t 年龄："+age;
            }
        }).withBroadcastSet(peopleBroadCast,"mybroadcast").withBroadcastSet(peopleBroadCast, "mybroadcast").print();;
        env.execute();
    }
}

在广播变量和分布式缓存中在获取文件或是变量的时候都是通过open方法。广播变量可以广播多个变量。广播变量和分布式缓存都适用于小文件和小数据量操作。
3、累加器，累加器是为了在各个节点操作加任务的时候保证数据一致。计数器就是累加器的一种。
代码：

import org.apache.flink.api.common.JobExecutionResult;
import org.apache.flink.api.common.accumulators.IntCounter;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.configuration.Configuration;

public class FlinkWithCounter {
    public static void main(String[] args) throws Exception {
        //获取执行环境
        ExecutionEnvironment env=ExecutionEnvironment.getExecutionEnvironment();
        //添加数据源
        DataSet<String> data=env.fromElements("Tom","Mary","Mike","Jone").setParallelism(2);
        DataSet<Integer> result=data.map(new RichMapFunction<String, Integer>() {
            //定义一个累加器(计数器)：全局只有一份
            private IntCounter intCounter=new IntCounter();
            //注册一个累加器
            @Override
            public void open(Configuration parameters) throws Exception {
                this.getRuntimeContext().addAccumulator("myCounter",intCounter);
            }

            @Override
            public Integer map(String s) throws Exception {
                this.intCounter.add(1);
                return 0;
            }
        }).setParallelism(2);
        result.writeAsText("G:\\aa\\a2.txt");
        //获取任务返回结果：获取累加器的结果
        //注意：只有任务执行完成了，才能获取累加器的结果
        JobExecutionResult execute = env.execute();
        int number=execute.getAccumulatorResult("myCounter");
        System.out.println("累加的结果是："+number);
    }
}