Flink简单项目整体流程

原創 原创 2021-02-01 09:16

项目概述

CDN热门分发网络，日志数据分析，日志数据内容包括

aliyun
CN
E
[17/Jul/2018:17:07:50 +0800]
223.104.18.110
v2.go2yd.com
17168

接入的数据类型就是日志

离线：Flume==>HDFS

实时:  Kafka==>流处理引擎==>ES==>Kibana

数据查询

接口名 功能描述
汇总统计查询

峰值带宽

总流量

总请求数

项目功能

  1. 统计一分钟内每个域名访问产生的流量，Flink接收Kafka的数据进行处理
  2. 统计一分钟内每个用户产生的流量，域名和用户是有对应关系的，Flink接收Kafka的数据进行处理+Flink读取域名和用户的配置数据(在MySQL中)进行处理

项目架构

Mock数据

@Component
@Slf4j
public class KafkaProducer {
    private static final String TOPIC = "pktest";
    @Autowired
    private KafkaTemplate<String,String> kafkaTemplate;

    @SuppressWarnings("unchecked")
    public void produce(String message) {
        try {
            ListenableFuture future = kafkaTemplate.send(TOPIC, message);
            SuccessCallback<SendResult<String,String>> successCallback = new SuccessCallback<SendResult<String, String>>() {
                @Override
                public void onSuccess(@Nullable SendResult<String, String> result) {
                    log.info("发送消息成功");
                }
            };
            FailureCallback failureCallback = new FailureCallback() {
                @Override
                public void onFailure(Throwable ex) {
                    log.error("发送消息失败",ex);
                    produce(message);
                }
            };
            future.addCallback(successCallback,failureCallback);
        } catch (Exception e) {
            log.error("发送消息异常",e);
        }
    }

    @Scheduled(fixedRate = 1000 * 2)
    public void send() {
        StringBuilder builder = new StringBuilder();
        builder.append("aliyun").append("\t")
                .append("CN").append("\t")
                .append(getLevels()).append("\t")
                .append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                        .format(new Date())).append("\t")
                .append(getIps()).append("\t")
                .append(getDomains()).append("\t")
                .append(getTraffic()).append("\t");
        log.info(builder.toString());
        produce(builder.toString());
    }

    /**
     * 生产Level数据
     * @return
     */
    private String getLevels() {
        List<String> levels = Arrays.asList("M","E");
        return levels.get(new Random().nextInt(levels.size()));
    }

    /**
     * 生产IP数据
     * @return
     */
    private String getIps() {
        List<String> ips = Arrays.asList("222.104.18.111",
                "223.101.75.185",
                "27.17.127.133",
                "183.225.121.16",
                "112.1.65.32",
                "175.147.222.190",
                "183.227.43.68",
                "59.88.168.87",
                "117.28.44.29",
                "117.59.34.167");
        return ips.get(new Random().nextInt(ips.size()));
    }

    /**
     * 生产域名数据
     * @return
     */
    private String getDomains() {
        List<String> domains = Arrays.asList("v1.go2yd.com",
                "v2.go2vd.com",
                "v3.go2yd.com",
                "v4.go2yd.com",
                "vmi.go2yd.com");
        return domains.get(new Random().nextInt(domains.size()));
    }

    /**
     * 生产流量数据
     * @return
     */
    private int getTraffic() {
        return new Random().nextInt(10000);
    }
}

关于Springboot Kafka其他配置请参考Springboot2整合Kafka

打开Kafka服务器消费者，可以看到

说明Kafka数据发送成功

Flink消费者

public class LogAnalysis {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        String topic = "pktest";
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers","外网ip:9092");
        properties.setProperty("group.id","test");
        DataStreamSource<String> data = env.addSource(new FlinkKafkaConsumer<>(topic,
                new SimpleStringSchema(), properties));
        data.print().setParallelism(1);
        env.execute("LogAnalysis");
    }
}

接收到的消息

aliyun	CN	M	2021-01-31 23:43:07	222.104.18.111	v1.go2yd.com	4603	
aliyun	CN	E	2021-01-31 23:43:09	222.104.18.111	v4.go2yd.com	6313	
aliyun	CN	E	2021-01-31 23:43:11	222.104.18.111	v2.go2vd.com	4233	
aliyun	CN	E	2021-01-31 23:43:13	222.104.18.111	v4.go2yd.com	2691	
aliyun	CN	E	2021-01-31 23:43:15	183.225.121.16	v1.go2yd.com	212	
aliyun	CN	E	2021-01-31 23:43:17	183.225.121.16	v4.go2yd.com	7744	
aliyun	CN	M	2021-01-31 23:43:19	175.147.222.190	vmi.go2yd.com	1318

数据清洗

数据清洗就是按照我们的业务规则把原始输入的数据进行一定业务规则的处理，使得满足我们业务需求为准

@Slf4j
public class LogAnalysis {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        String topic = "pktest";
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers","外网ip:9092");
        properties.setProperty("group.id","test");
        DataStreamSource<String> data = env.addSource(new FlinkKafkaConsumer<>(topic,
                new SimpleStringSchema(), properties));
        data.map(new MapFunction<String, Tuple4<String, Long, String, String>>() {
            @Override
            public Tuple4<String, Long, String, String> map(String value) throws Exception {
                String[] splits = value.split("\t");
                String level = splits[2];
                String timeStr = splits[3];
                Long time = 0L;
                try {
                    time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(timeStr).getTime();
                } catch (ParseException e) {
                    log.error("time转换错误:" + timeStr + "," + e.getMessage());
                }
                String domain = splits[5];
                String traffic = splits[6];
                return new Tuple4<>(level,time,domain,traffic);
            }
        }).filter(x -> (Long) x.getField(1) != 0)
          //此处我们只需要Level为E的数据
          .filter(x -> x.getField(0).equals("E"))
          //抛弃level
          .map(new MapFunction<Tuple4<String,Long,String,String>, Tuple3<Long,String,Long>>() {
              @Override
              public Tuple3<Long, String, Long> map(Tuple4<String, Long, String, String> value) throws Exception {
                  return new Tuple3<>(value.getField(1),value.getField(2),Long.parseLong(value.getField(3)));
              }
          })
          .print().setParallelism(1);
        env.execute("LogAnalysis");
    }
}

运行结果

(1612130315000,v1.go2yd.com,533)
(1612130319000,v4.go2yd.com,8657)
(1612130321000,vmi.go2yd.com,4353)
(1612130327000,v1.go2yd.com,9566)
(1612130329000,v2.go2vd.com,1460)
(1612130331000,vmi.go2yd.com,1444)
(1612130333000,v3.go2yd.com,6955)
(1612130337000,v1.go2yd.com,9612)
(1612130341000,vmi.go2yd.com,1732)
(1612130345000,v3.go2yd.com,694)

Scala代码

import java.text.SimpleDateFormat
import java.util.Properties

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.slf4j.LoggerFactory
import org.apache.flink.api.scala._

object LogAnalysis {
  val log = LoggerFactory.getLogger(LogAnalysis.getClass)

  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val topic = "pktest"
    val properties = new Properties
    properties.setProperty("bootstrap.servers", "外网ip:9092")
    properties.setProperty("group.id","test")
    val data = env.addSource(new FlinkKafkaConsumer[String](topic, new SimpleStringSchema, properties))
    data.map(x => {
      val splits = x.split("\t")
      val level = splits(2)
      val timeStr = splits(3)
      var time: Long = 0l
      try {
        time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(timeStr).getTime
      }catch {
        case e: Exception => {
          log.error(s"time转换错误: $timeStr",e.getMessage)
        }
      }
      val domain = splits(5)
      val traffic = splits(6)
      (level,time,domain,traffic)
    }).filter(_._2 != 0)
      .filter(_._1 == "E")
      .map(x => (x._2,x._3,x._4.toLong))
      .print().setParallelism(1)
    env.execute("LogAnalysis")
  }
}

数据分析

现在我们要分析的是在一分钟内的域名流量

@Slf4j
public class LogAnalysis {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        String topic = "pktest";
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers","外网ip:9092");
        properties.setProperty("group.id","test");
        DataStreamSource<String> data = env.addSource(new FlinkKafkaConsumer<>(topic,
                new SimpleStringSchema(), properties));
        data.map(new MapFunction<String, Tuple4<String, Long, String, String>>() {
            @Override
            public Tuple4<String, Long, String, String> map(String value) throws Exception {
                String[] splits = value.split("\t");
                String level = splits[2];
                String timeStr = splits[3];
                Long time = 0L;
                try {
                    time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(timeStr).getTime();
                } catch (ParseException e) {
                    log.error("time转换错误:" + timeStr + "," + e.getMessage());
                }
                String domain = splits[5];
                String traffic = splits[6];
                return new Tuple4<>(level,time,domain,traffic);
            }
        }).filter(x -> (Long) x.getField(1) != 0)
          //此处我们只需要Level为E的数据
          .filter(x -> x.getField(0).equals("E"))
          //抛弃level
          .map(new MapFunction<Tuple4<String,Long,String,String>, Tuple3<Long,String,Long>>() {
              @Override
              public Tuple3<Long, String, Long> map(Tuple4<String, Long, String, String> value) throws Exception {
                  return new Tuple3<>(value.getField(1),value.getField(2),Long.parseLong(value.getField(3)));
              }
          })
          .setParallelism(1).assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<Tuple3<Long, String, Long>>() {
            private Long maxOutOfOrderness = 10000L;
            private Long currentMaxTimestamp = 0L;

            @Nullable
            @Override
            public Watermark getCurrentWatermark() {
                return new Watermark(currentMaxTimestamp - maxOutOfOrderness);
            }

            @Override
            public long extractTimestamp(Tuple3<Long, String, Long> element, long previousElementTimestamp) {
                Long timestamp = element.getField(0);
                currentMaxTimestamp = Math.max(timestamp,currentMaxTimestamp);
                return timestamp;
            }
        }).keyBy(x -> (String) x.getField(1))
          .timeWindow(Time.minutes(1))
          //输出格式：一分钟的时间间隔，域名，该域名在一分钟内的总流量
          .apply(new WindowFunction<Tuple3<Long,String,Long>, Tuple3<String,String,Long>, String, TimeWindow>() {
              @Override
              public void apply(String s, TimeWindow window, Iterable<Tuple3<Long, String, Long>> input, Collector<Tuple3<String, String, Long>> out) throws Exception {
                  List<Tuple3<Long,String,Long>> list = (List) input;
                  Long sum = list.stream().map(x -> (Long) x.getField(2)).reduce((x, y) -> x + y).get();
                  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                  out.collect(new Tuple3<>(format.format(window.getStart()) + " - " + format.format(window.getEnd()),s,sum));
              }
          })
          .print().setParallelism(1);
        env.execute("LogAnalysis");
    }
}

运行结果

(2021-02-01 07:14:00 - 2021-02-01 07:15:00,vmi.go2yd.com,6307)
(2021-02-01 07:15:00 - 2021-02-01 07:16:00,v4.go2yd.com,15474)
(2021-02-01 07:15:00 - 2021-02-01 07:16:00,v2.go2vd.com,9210)
(2021-02-01 07:15:00 - 2021-02-01 07:16:00,v3.go2yd.com,190)
(2021-02-01 07:15:00 - 2021-02-01 07:16:00,v1.go2yd.com,12787)
(2021-02-01 07:15:00 - 2021-02-01 07:16:00,vmi.go2yd.com,14250)
(2021-02-01 07:16:00 - 2021-02-01 07:17:00,v4.go2yd.com,33298)
(2021-02-01 07:16:00 - 2021-02-01 07:17:00,v1.go2yd.com,37140)

Scala代码

import java.text.SimpleDateFormat
import java.util.Properties

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.slf4j.LoggerFactory
import org.apache.flink.api.scala._
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.AssignerWithPeriodicWatermarks
import org.apache.flink.streaming.api.scala.function.WindowFunction
import org.apache.flink.streaming.api.watermark.Watermark
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

object LogAnalysis {
  val log = LoggerFactory.getLogger(LogAnalysis.getClass)

  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    val topic = "pktest"
    val properties = new Properties
    properties.setProperty("bootstrap.servers", "外网ip:9092")
    properties.setProperty("group.id","test")
    val data = env.addSource(new FlinkKafkaConsumer[String](topic, new SimpleStringSchema, properties))
    data.map(x => {
      val splits = x.split("\t")
      val level = splits(2)
      val timeStr = splits(3)
      var time: Long = 0l
      try {
        time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(timeStr).getTime
      }catch {
        case e: Exception => {
          log.error(s"time转换错误: $timeStr",e.getMessage)
        }
      }
      val domain = splits(5)
      val traffic = splits(6)
      (level,time,domain,traffic)
    }).filter(_._2 != 0)
      .filter(_._1 == "E")
      .map(x => (x._2,x._3,x._4.toLong))
      .setParallelism(1).assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks[(Long, String, Long)] {
      var maxOutOfOrderness: Long = 10000l
      var currentMaxTimestamp: Long = _

      override def getCurrentWatermark: Watermark = {
        new Watermark(currentMaxTimestamp - maxOutOfOrderness)
      }

      override def extractTimestamp(element: (Long, String, Long), previousElementTimestamp: Long): Long = {
        val timestamp = element._1
        currentMaxTimestamp = Math.max(timestamp,currentMaxTimestamp)
        timestamp
      }
    }).keyBy(_._2)
      .timeWindow(Time.minutes(1))
      .apply(new WindowFunction[(Long,String,Long),(String,String,Long),String,TimeWindow] {
          override def apply(key: String, window: TimeWindow, input: Iterable[(Long, String, Long)], out: Collector[(String, String, Long)]): Unit = {
            val list = input.toList
            val sum = list.map(_._3).sum
            val format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
            out.collect((format.format(window.getStart) + " - " + format.format(window.getEnd),key,sum))
          }
      })
      .print().setParallelism(1)
    env.execute("LogAnalysis")
  }
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

hadoop-2单节点和hive安装

1、下載hadoop-x.y.x.tar.gz 2、解壓：tar -zxvf hadoop-2.y.x.tar.gz 3、配置環境變量：$JAVA_HOME、$HADOOP_HOME、$PATH 4、修改配置：$HADOOP_HOME/et

原創 2024-05-24 23:51:33

【开启报名】开源之夏2024精彩继续！Apache Linkis项目课题正式发布

開源之夏是什麼 “開源之夏（OSPP）” 是中國科學院軟件研究所 “開源軟件供應鏈點亮計劃” 指導下的系列暑期活動，旨在鼓勵在校學生積極參與開源軟件的開發維護，培養和發掘更多優秀的開發者，促進優秀開源軟件社區的蓬勃發展，助力開

微衆開源 2024-05-21 21:38:53

对话阿里云云原生产品负责人李国强：推进可观测产品与OpenTelemetry开源生态全面融合

5 月 22 日，在最新一期的飛天發佈時刻上，阿里雲宣佈多款可觀測產品全面升級，其中一項是應用實時監控服務 ARMS 在業內率先推進了與 OpenTelemetry 開源生態的全面融合，極大豐富了可觀測的數據類型及規模，大幅增強了 ARMS

原創 2024-05-24 21:13:50

DolphinScheduler 3.3.0版本更新一览

Apache DolphinScheduler即將迎來3.3.0版本的發佈，屆時將有一系列重要的更新和改進。在近期的社區5月份用戶線上分享會上，項目PMC 阮文俊爲大家介紹了3.3.0版本將帶來的主要更新和改進，併爲大家指出瞭如何參與社區的

原創 2024-05-23 21:22:09

Spring优雅使用log4j2日志

1-前言 Spring框架本身提供了對日誌的集成，對logback的支持非常好，但是對log4j和log4j2的支持就沒那麼好。 在同步打印日誌的場景下logback擁有最高的日誌吞吐量《Logback Throughput Benchma

原創 2024-05-22 23:12:10

构建无服务器数仓（三 ）EMR Serverless 操作要点、优化以及开放集成测试

引言 在數據驅動的世界中，企業正在尋求可靠且高性能的解決方案來管理其不斷增長的數據需求。本系列博客從一個重視數據安全和合規性的 B2C 金融科技客戶的角度來討論雲上雲下混合部署的情況下如何利用亞馬遜雲科技雲原生服務、開源社區產品以及第三方工

原創 2024-05-23 21:22:10

Volcano社区新版本发布！7大功能全面增强队列能力与调度稳定性

本文分享自華爲雲社區《Volcano 社區 v1.9.0 版本正式發佈！全面增強隊列能力與調度穩定性》，作者：雲容器大未來。 北京時間2024年5月21日，Volcano社區v1.9.0版本正式發佈，此次版本增加了以下新特性：

原創 2024-05-24 10:58:20

智能高效的IDE GoLand v2024.1全新发布 - 进一步升级AI辅助工具

GoLand 使 Go 代碼的閱讀、編寫和更改變得非常容易。即時錯誤檢測和修復建議，通過一步撤消快速安全重構，智能代碼完成，死代碼檢測和文檔提示幫助所有 Go 開發人員，從新手到經驗豐富的專業人士，創建快速、高效、和可靠的代碼。 立即獲取G

原創 2024-05-21 12:19:26

复杂SQL治理实践

一、前言 軟件在持續的開發和維護過程中，會不斷添加新功能和修復舊的缺陷，這往往伴隨着代碼的快速增長和複雜性的提升。若代碼庫沒有得到良好的管理和重構，就可能積累大量的技術債務，包括不一致的設計、冗餘代碼、過時的庫和框架以及不再使用的功能。

京東雲開發者 2024-05-24 11:56:56

昔日辉煌不再，PHP老矣，尚能饭否？

導語 | 近期 TIOBE 最新指數顯示，PHP 的流行度降至了歷史最低，排在第 17 名，同時，在年度 Stack Overflow 開發者調查報告中，PHP 在開發者中的受歡迎程度已經從之前的約 30% 萎縮至現在的 18%。“P

原創 2024-05-23 23:48:42

Spring项目中使用NIO并行调用http接口指南

1-背景 後臺BFF層服務爲了SEO，涉及大量對底層數據的聚合，如果按照過程化編程，串行執行請求數據再聚合會造成很高的延遲，因此我們往往大量使用多線程技術並行化多個查詢，來減少單個請求的響應時間。 多線程一定程度上也能達成通過並行化提升

原創 2024-05-23 11:10:25

Java实现抓取在线视频并提取视频语音为文本

一、 背景 最近在做大模型相關的項目，其中有個模塊需要提取在線視頻語音爲文本並輸出給用戶。作爲一個純後端Jave工程師，搞這個確實是初次嘗試。 二、 調研 基於上述功能模塊，主要有三大任務：1、 提取網頁中的視頻 2、 視頻轉語音 3、 語

原創 2024-05-22 11:56:46

线程池那些坑爹的参数-核心线程数&最大线程数&工作队列

1-前言 本文根據實際遇到的線程池使用導致的性能問題，從代碼層面解析 線程池 核心線程數、最大線程數、工作隊列三個參數配置不佳容易產生的問題，以及對這些問題的建議 對線程池的更多解析，這篇文章講得已經比較詳細了，建議大家仔細研讀：《阿里規

原創 2024-05-21 23:11:06

IO密集型场景CompletableFuture使用的陷阱

1-概述 1.1 背景 企知道後臺服務存在大量的查詢可以併發，大量用到了java8的CompletableFuture特性，但是在性能測試中，遇到了併發的瓶頸。 經過分析，發現是由於CompletableFuture默認線程池以及公共線

原創 2024-05-21 23:11:05

高并发系统-使用自定义日志埋点快速排查问题

背景 在高併發的系統中，通常不會打印除參數校驗失敗或捕獲異常之外的日誌，防止對接口的性能產生影響。 那對於請求不符合預期的情況，我們如何快速找到是哪塊邏輯影響的至關重要。 Pfinder提供的鏈路監控，更多的是性能層面的監控，無法滿足

原創 2024-05-21 11:56:04