在维表关联中定时全量加载是针对维表数据量较少并且业务对维表数据变化的敏感程度较低的情况下可采取的一种策略，对于这种方案使用有几点需要注意：

  1. 全量加载有可能会比较耗时，所以必须是一个异步加载过程

  2. 内存维表数据需要被流表数据关联读取、也需要被定时重新加载，这两个过程是不同线程执行，为了尽可能保证数据一致性，可使用原子引用变量包装内存维表数据对象即AtomicReference

  3. 查内存维表数据非异步io过程

具体实例：广告流量统计，广告流量数据包含：广告位id,用户设备id,事件类型(点击、浏览)，发生时间，现在需要统计每个广告主在每一个时间段内的点击、浏览数量，流量数据中只有广告位id, 广告位id与广告主id对应的关系在mysql 中，这是一个典型的流表关联维表过程，需要从mysql中获取该广告位id对应的广告主id, 然后在来统计。接下来看维表关联的实现代码：


  2. class SideFlatMapFunction extends RichFlatMapFunction[AdData, AdData] {

  4.   private var sideInfo: AtomicReference[java.util.Map[Int, Int]] = _

  6.   override def open(parameters: Configuration): Unit = {
  7.     sideInfo = new AtomicReference[java.util.Map[Int, Int]]()
  8.     sideInfo.set(loadData)
  9.     val executors=Executors.newSingleThreadScheduledExecutor()
  10.     executors.scheduleAtFixedRate(new Runnable {
  11.       override def run(): Unit = reload()
  12.     },5,5, TimeUnit.MINUTES)
  13.   }

  15.   override def flatMap(value: AdData, out: Collector[AdData]): Unit = {
  16.     val tid=value.tId
  17.     val aid=sideInfo.get().get(tid)
  18.     var newV=AdData(aid,value.tId,value.clientId,value.actionType,value.time)
  19.     out.collect(newV)
  20.   }


  23.   def reload()={
  24.     try{
  25.       println("do reload~")
  26.       val newData=loadData()
  27.       sideInfo.set(newData)
  28.       println("reload ok~")
  29.     }catch {
  30.       case e:Exception=>{
  31.         e.printStackTrace()
  32.       }
  33.     }
  34.   }

  36.   def loadData(): util.Map[Int, Int] = {
  37.     val data = new util.HashMap[Int, Int]()
  38.     Class.forName("com.mysql.jdbc.Driver")
  39.     val con = DriverManager.getConnection("jdbc:mysql://localhost:3306/paul", "root", "123456")
  40.     val sql = "select aid,tid from ads"
  41.     val statement = con.prepareStatement(sql)
  42.     val rs = statement.executeQuery()
  43.     while (rs.next()) {
  44.       val aid = rs.getInt("aid")
  45.       val tid = rs.getInt("tid")
  46.       data.put(tid, aid)
  47.     }
  48.     con.close()
  49.     data
  50.   }
  51. }

  2. case class AdData(aId: Int, tId: Int, clientId: String, actionType: Int, time: Long)

  4. object Demo1 {

  6.   def main(args: Array[String]): Unit = {

  8.     val env = StreamExecutionEnvironment.getExecutionEnvironment

  10.     val kafkaConfig = new Properties();
  11.     kafkaConfig.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
  12.     kafkaConfig.put(ConsumerConfig.GROUP_ID_CONFIG, "test1");
  13.     val consumer = new FlinkKafkaConsumer011[String]("topic1", new SimpleStringSchema(), kafkaConfig);
  14.     env.addSource(consumer)
  15.       .map(x => {
  16.         val a: Array[String] = x.split(",")
  17.         AdData(0, a(0).toInt, a(1), a(2).toInt, a(3).toLong) //默认aid为0
  18.       })
  19.       .flatMap(new SideFlatMapFunction)
  20.       .print()
  21.     env.execute()
  22.   }

  24. }
在kafka端生产数据：1,clientId1,1,1571646006000
控制台打印
> AdData(1,1,clientId1,1,1571646006000)
然后将MySQL维表中tid为1的aid 变为2，待一分钟后继续输入数据：1,clientId1,1,1571646006000
控制台打印
>AdData(2,1,clientId1,1,1571646006000)
说明维表数据的更新已经被加载了。
对于该demo还有两点值得思考：
  1. 异步加载过程是异步线程执行，如果异步线程加载抛出异常是无法被Task检测，也就是无法导致任务失败，那么就会导致使用的维表数据一直都是变化之前的，对于业务来说是无法容忍的，解决方式自定义一个维表关联的StreamOperator, 可获取到StreamTask， 然后再异步加载的异常处理中调用StreamTask.handleAsyncException方法，就可以导致任务失败，给用户发出警告
  2. 维表全量加载是在每个task里面执行，那么就会导致每个task里面都有一份全量的维表数据，可采取优化方式是在维表关联前根据关联字段做keyBy操作，那么就会根据关联字段hash然后对并行度取余得到相同的值就会被分配到同一个task里面，所以在加载维表数据的时候也可以在每个task加载与其对应的维表数据， 就可以减少加载的数据量。其具体计算的规则是：
    （MathUtils.murmurHash(key.hashCode()) % maxParallelism）*parallelism / maxParallelism
    得到的值就是IndexOfThisSubtask 即task的索引，那么可使用同样的算法过滤维表数据。