flink-2

最新推荐文章于 2023-10-13 10:01:57 发布
最新推荐文章于 2023-10-13 10:01:57 发布
阅读量340 收藏 2
点赞数 1
文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42716237/article/details/112506312
版权

实时数仓项目

 

第1章 分层设计

在之前介绍实时数仓概念时讨论过，建设实时数仓的目的。主要是增加数据计算的复用性。每次新增加统计需求时，不至于从原始数据进行计算，而是从半成品继续加工而成。

每层的职能

分层

数据描述

生成计算工具

存储媒介

ODS

原始数据，日志和业务数据

日志服务器，maxwell

kafka

DWD

根据数据对象为单位进行分流，比如订单、页面访问等等。

FLINK

kafka

DWM

对于部分数据对象进行进一步加工，比如独立访问、跳出行为。依旧是明细数据。

FLINK

 

DIM

维度数据

FLINK

HBase

DWS

根据某个维度主题将多个事实数据轻度聚合，形成主题宽表。

FLINK

Clickhouse

ADS

把Clickhouse中的数据根据可视化需要进行筛选聚合。

Clickhouse SQL

可视化展示

 

第2章 搭建工程

2.1 在工程中新建模块

 

 

2.3 创建包

目录介绍

目录

 

app

产生各层数据的flink任务

bean

数据对象

common

公共常量

utils

工具类

 

2.4 配置文件

2.4.1 pom.xml


<properties>
    <flink.version>1.11.2</flink.version>
    <scala.version>2.12</scala.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-java_${scala.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-kafka_${scala.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-cep_${scala.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-json</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.68</version>
    </dependency>

</dependencies>


<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.0.0</version>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2.4.2 logback.xml

Flink程序默认使用logback日志，所以为了控制日志输出，增加logback.xml放在resources目录下即可。

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%msg%n</pattern>
        </encoder>
    </appender>

    <root level="error">
        <appender-ref ref="console"/>
    </root>
</configuration>

第3章 计算DWD层（用户行为日志）

3.1 主要任务

1、分流处理，要把数据分成启动主题数据、页面主题数据、曝光主题数据。这三类数据虽然都是用户行为数据，但是有着完全不一样的数据结构，所以要拆分处理。

2、识别新老用户，本身客户端业务有新老用户的标识，但是不够准确，需要用实时计算再次确认。

3、推送下游的kafka

3.2 代码实现

3.2.1 功能一：接收Kafka数据，并进行转换

1）工具类

import org.apache.flink.api.common.serialization.SimpleStringSchema;

  import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;

  import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;

  import org.apache.flink.streaming.connectors.kafka.KafkaSerializationSchema;

  import org.apache.kafka.clients.consumer.ConsumerConfig;

  

  import java.util.Properties;

  

  public class MyKafkaUtil {

  

    private static Properties properties = new Properties();

    private static final String DEFAULT_TOPIC = "DEFAULT_DATA";

  

    static {

        String kafkaServer = "hadoop102:9092,hadoop103:9092,hadoop104:9092";

        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaServer);

    }

  

    public static FlinkKafkaConsumer<String> getKafkaSource(String topic, String groupId) {

        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, groupId);

        return new FlinkKafkaConsumer<>(topic, new SimpleStringSchema(), properties);

    }

}

 

2）主程序

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.logcat.utils.MyKafkaUtil;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.runtime.state.filesystem.FsStateBackend;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Dwd_Base_Log {

    //定义用户行为主题信息
    private static final String TOPIC_START = "DWD_START_LOG";
    private static final String TOPIC_PAGE = "DWD_PAGE_LOG";
    private static final String TOPIC_DISPLAY = "DWD_DISPLAY_LOG";

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

        //1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);

        //2.设置CK相关参数
        env.enableCheckpointing(5000, CheckpointingMode.EXACTLY_ONCE);
        env.getCheckpointConfig().setCheckpointTimeout(60000);
        env.setStateBackend(new FsStateBackend("hdfs://hadoop102:8020/gmall/flink/checkpoint"));

        //3.指定消费者配置信息
        String groupId = "ods_dwd_base_log_app";
        String topic = "ODS_BASE_LOG";

        //4.从指定的Kafka主题中读取数据
        FlinkKafkaConsumer<String> kafkaSource = MyKafkaUtil.getKafkaSource(topic, groupId);
        DataStreamSource<String> baseLogDS = env.addSource(kafkaSource);

        //5.转换为Json对象
        SingleOutputStreamOperator<JSONObject> jsonObjectDS = baseLogDS.process(new ProcessFunction<String, JSONObject>() {
            @Override
            public void processElement(String value, Context context, Collector<JSONObject> collector) throws Exception {
                try {
                    JSONObject jsonObject = JSON.parseObject(value);
                    collector.collect(jsonObject);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
        });
        
        //打印测试
        jsonObjectDS.print();
        env.execute("Dwd_Base_Log Job");
    }
}

3.2.2 功能二：增加识别新老访客

保存每个mid的首次访问日期，每条进入该算子的访问记录，都会把mid对应的首次访问时间读取出来，跟当前日期进行比较，只有首次访问时间不为空，且首次访问时间早于当日的，则认为该访客是老访客，否则是新访客。

      同时如果是新访客且没有访问记录的话，会写入首次访问时间。

主程序

//6.按照Mid分组
KeyedStream<JSONObject, String> midKeyedStream = jsonObjectDS.keyBy(data -> data.getJSONObject("common").getString("mid"));

//7.对数据做处理,校验数据中的Mid是否为今天第一次访问
SingleOutputStreamOperator<JSONObject> midWithNewFlagDStream = midKeyedStream.map(new RichMapFunction<JSONObject, JSONObject>() {

    //声明第一次访问日期的状态
    private ValueState<String> firstVisitDataState;

    //声明日期数据格式化对象
    private SimpleDateFormat simpleDateFormat;

    @Override
    public void open(Configuration parameters) throws Exception {
        //初始化数据
        firstVisitDataState = getRuntimeContext().getState(new ValueStateDescriptor<>("newMidDateState", String.class));
        simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
    }

    @Override
    public JSONObject map(JSONObject jsonObject) throws Exception {

        //打印数据
        System.out.println(jsonObject);
        //获取数据中所携带的是否为第一次访问标记("0"表示不是第一次,"1"表示为第一次)
        String isNew = jsonObject.getJSONObject("common").getString("is_new");
        //获取数据中的时间戳
        Long ts = jsonObject.getLong("ts");

        //判断标记如果为"1",则继续校验数据
        if ("1".equals(isNew)) {
            String newMidDate = firstVisitDataState.value();
            String tsDate = simpleDateFormat.format(new Date(ts));

            //如果新用户状态不为空,则将标记置为"0"
            if (newMidDate != null && newMidDate.length() == 0 && !newMidDate.equals(tsDate)) {
                isNew = "0";
                jsonObject.getJSONObject("common").put("is_new", isNew);
            }

            //更新状态
            firstVisitDataState.update(tsDate);
        }

        //返回添加了新的标记之后的数据
        return jsonObject;
    }
});

3.2.3 功能三：利用侧输出流实现数据拆分

//8.定义启动和曝光数据的侧输出流标签
final OutputTag<String> startTag = new OutputTag<String>("start") {};
final OutputTag<String> displayTag = new OutputTag<String>("display") {};

//9.根据数据内容,将数据分为3类,页面日志输出到主流,启动日志输出到启动侧输出流,曝光日志输出到曝光日志侧输出流
SingleOutputStreamOperator<String> pageDStream = midWithNewFlagDStream.process(new ProcessFunction<JSONObject, String>() {
    @Override
    public void processElement(JSONObject jsonObject, Context context, Collector<String> collector) throws Exception {

        //获取数据中的启动相关字段
        JSONObject startJsonObj = jsonObject.getJSONObject("start");

        //将数据转换为字符串,准备最后的输出
        String dataString = jsonObject.toString();

        //启动数据不为空，输出到侧输出流
        if (startJsonObj != null && startJsonObj.size() > 0) {
            context.output(startTag, dataString);
        } else {
            //非启动日志,则为页面日志或者曝光日志(携带页面信息)
            System.out.println("PageString:" + dataString);

            //将数据输出到主流,即是页面日志流
            collector.collect(dataString);

            //获取数据中的曝光数据,如果不为空,则将每条曝光数据取出输出到曝光日志侧输出流
            JSONArray display = jsonObject.getJSONArray("display");
            if (display != null && display.size() > 0) {
                for (int i = 0; i < display.size(); i++) {
                    JSONObject displayJsonObj = display.getJSONObject(i);
                    String pageId = jsonObject.getJSONObject("page").getString("page_id");
                    displayJsonObj.put("page_id", pageId);
                    context.output(displayTag, displayJsonObj.toString());
                }
            }
        }
    }
});

//10.获取侧输出流数据
DataStream<String> startDStream = pageDStream.getSideOutput(startTag);
DataStream<String> displayDStream = pageDStream.getSideOutput(displayTag);

3.2.4 功能四：把结果输出到Kafka中

1）工具类

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
import org.apache.flink.streaming.connectors.kafka.KafkaSerializationSchema;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

public class MyKafkaUtil {

    private static Properties properties = new Properties();
    private static final String DEFAULT_TOPIC = "DEFAULT_DATA";

    static {
        String kafkaServer = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaServer);
    }

//创建从Kafka读取数据的Source方法
    public static FlinkKafkaConsumer<String> getKafkaSource(String topic, String groupId) {
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        return new FlinkKafkaConsumer<>(topic, new SimpleStringSchema(), properties);
    }
    
//创建往Kafka写出数据的Sink方法
public static FlinkKafkaProducer<String> getKafkaSink(String topic) {
      return new FlinkKafkaProducer<>(topic, new SimpleStringSchema(), properties);
    }

}

2）主程序

//11.将各个流的数据写入对应的主题
FlinkKafkaProducer<String> startSink = MyKafkaUtil.getKafkaSink(TOPIC_START);
FlinkKafkaProducer<String> pageSink = MyKafkaUtil.getKafkaSink(TOPIC_PAGE);
FlinkKafkaProducer<String> displaySink = MyKafkaUtil.getKafkaSink(TOPIC_DISPLAY);

pageDStream.addSink(pageSink);
startDStream.addSink(startSink);
displayDStream.addSink(displaySink);

第4章 计算DWD层（业务数据）

4.1 主要任务

1、提取数据，把MaxWell抓取数据中有用的部分保留，没用的过滤掉。

2、实现动态分流功能。

3、把分好的流保存到对应表、主题中。

4.2 关于动态分流功能策略

由于MaxWell是把全部数据统一写入一个Topic中, 这样显然不利于日后的数据处理。所以需要把各个表拆开处理。但是由于每个表有不同的特点，有些表是维度表，有些表是事实表，有的表既是事实表在某种情况下也是维度表。

在实时计算中一般把维度数据写入存储容器，一般是方便通过主键查询的数据库比如HBase,Redis,MySQL等。一般把事实数据写入流中，进行进一步处理，最终形成宽表。但是作为Flink实时计算任务，如何得知哪些表是维度表，哪些是事实表呢？而这些表又应该采集哪些字段呢？

这样的配置不适合写在配置文件中，因为这样的话，业务端随着需求变化每增加一张表，就要修改配置重启计算程序。所以这里需要一种动态配置方案，把这种配置长期保存起来，一旦配置有变化，实时计算可以自动感知。

这种可以有两个方案实现，一种是用Zookeeper存储，通过Watch感知数据变化。

另一种是用mysql数据库存储，周期性的同步。

这里选择第二种方案，主要是mysql对于配置数据初始化和维护管理，用sql都比较方便，虽然周期性操作时效性差一点，但是配置变化并不频繁。

所以就有了如下图：

4.3 功能实现

4.3.1 功能一：接收Kafka数据，过滤空值数据

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.logcat.app.dwd.func.DimSink;
import com.logcat.app.dwd.func.TableProcessFunction;
import com.logcat.bean.TableProcess;
import com.logcat.utils.MyKafkaUtil;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.serialization.SerializationSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
import org.apache.flink.streaming.connectors.kafka.KafkaSerializationSchema;
import org.apache.flink.util.OutputTag;
import org.apache.kafka.clients.producer.ProducerRecord;

import javax.annotation.Nullable;

public class Dwd_Base_DB {

    public static void main(String[] args) {

        //1.创建执行环境并设置并行度
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);

        //2.定义消费者的
        String groupId = "ods_order_detail_group";
        String topic = "ODS_BASE_DB_M";

        //3.读取Kafka业务主题数据并转换为JSONObject
        FlinkKafkaConsumer<String> kafkaSource = MyKafkaUtil.getKafkaSource(topic, groupId);
        DataStreamSource<String> jsonDStream = env.addSource(kafkaSource);
        SingleOutputStreamOperator<JSONObject> jsonObjectDStream = jsonDStream.map(JSON::parseObject);

        //4.过滤掉空值数据
        SingleOutputStreamOperator<JSONObject> filterDS = jsonObjectDStream.filter(new FilterFunction<JSONObject>() {
            @Override
            public boolean filter(JSONObject value) throws Exception {
                return value.getString("table") != null &&
                        value.getString("data") != null &&
                        value.getString("data").length() > 3;
            }
        });
    }
}

4.3.2 功能二：根据MySQL的动态配置表，进行分流。

1）准备工作

导入依赖，创建JavaBean以及工具类

（1）引入pom.xml 依赖

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

（2）mysql 建库建表

create database gmall_reatime;

 

（3）建表

CREATE TABLE `table_process` (
  `source_table` varchar(200) NOT NULL COMMENT '来源表',
  `operate_type` varchar(200) NOT NULL COMMENT '操作类型 insert,update,delete',
   `sink_type` varchar(200) DEFAULT NULL COMMENT '输出类型 hbase kafka',
  `sink_table` varchar(200) DEFAULT NULL COMMENT '输出表(主题)',
  `sink_columns` varchar(2000) DEFAULT NULL COMMENT '输出字段',
  `sink_pk` varchar(200) DEFAULT NULL COMMENT '主键字段',
  `sink_extend` varchar(200) DEFAULT NULL COMMENT '建表扩展',
  PRIMARY KEY (`source_table`,`operate_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

 

（4）创建配置表实体类

import lombok.Data;

@Data
public class TableProcess {

    public static final String SINK_TYPE_HBASE = "HBASE";
    public static final String SINK_TYPE_KAFKA = "KAFKA";
    public static final String SINK_TYPE_CK = "CLICKHOUSE";

    String sourceTable;
    String operateType;
    String sinkType;
    String sinkTable;
    String sinkColumns;
    String sinkPk;
    String sinkExtend;
}

 

（5）MySQL工具类

import com.google.common.base.CaseFormat;
import org.apache.commons.beanutils.BeanUtils;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class MySQLUtil {

    public static <T> List<T> queryList(String sql, Class<T> clazz, Boolean underScoreToCamel) {

        //获取MySQL连接
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection connection = DriverManager.getConnection("jdbc:mysql://hadoop102:3306/gmall_test?characterEncoding=utf-8&useSSL=false", "root", "000000");

            //创建SQL执行语句
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);

            //获取查询结果中的元数据信息
            ResultSetMetaData metaData = resultSet.getMetaData();

            //创建集合用于存放结果数据
            ArrayList<T> resultList = new ArrayList<>();

            //遍历数据,将每行数据封装成对象存入集合
            while (resultSet.next()) {
                T obj = clazz.newInstance();
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    String columnName = metaData.getColumnName(i);
                    if (underScoreToCamel) {
                        CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, columnName);
                    }
                    BeanUtils.setProperty(obj, columnName, resultSet.getObject(i));
                }
                resultList.add(obj);
            }

            //释放资源
            statement.close();
            connection.close();
            
            //返回结果
            return resultList;

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("查询数据失败！！！");
        }
    }
}

程序流程分析

 

关于TableProcessFunction 这是一个自定义算子，这个算子包括了三条时间线的任务。

图中紫线，这个时间线与数据流入无关，只要任务启动就会执行。主要的任务方法是open()这个方法在任务启动时就会执行。他的主要工作就是初始化一些连接，开启周期调度。

图中绿线，这个时间线也与数据流入无关，只要周期调度启动，会自动周期性执行。主要的任务是同步配置表（tableProcessMap）。通过在open()方法中加入timer实现。同时还有个附带任务就是如果发现不存在数据表，要根据配置自动创建数据库表。

图中黑线，这个时间线就是随着数据的流入持续发生，这部分的任务就是根据同步到内存的tableProcessMap，来为流入的数据进行标识，同时清理掉没用的字段。

代码实现：

2）TableProcessFunction

自定义算子，实现将数据分流的业务


import com.alibaba.fastjson.JSONObject;
import com.logcat.bean.TableProcess;
import com.logcat.common.GmallConfig;
import com.logcat.utils.MySQLUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;

public class TableProcessFunction extends ProcessFunction<JSONObject, JSONObject> {

    //侧输出流标签
    private OutputTag<JSONObject> outputTag;

    public TableProcessFunction(OutputTag<JSONObject> outputTag) {
        this.outputTag = outputTag;
    }

    //用于在内存中存储表配置对象 [表名,表配置信息]
    private Map<String, TableProcess> tableProcessMap = null;

    //表示目前内存中已经存在的HBase表
    private Set<String> existsTables = new HashSet<>();

    //声明Phoenix连接
    private Connection connection = null;

}

校验表是否之前已经导入过，如果没有则在Pheonix中创建新增的表3）checkTable()

 

//用于检查字段，配置表中添加了新数据,在Phoenix中创建新的表
private void checkTable(String tableName, String fields, String pk, String ext) {

    //主键不存在,则给定默认值
    if (pk == null) {
        pk = "id";
    }

    //扩展字段不存在,则给定默认值
    if (ext == null) {
        ext = "";
    }

    //创建字符串拼接对象,用于拼接建表语句SQL
    StringBuilder createSql = new StringBuilder("create table if not exists " + GmallConfig.HBASE_SCHEMA + "." + tableName + "(");

    //将列做切分,并拼接至建表语句SQL中
    String[] fieldsArr = fields.split(",");
    for (int i = 0; i < fieldsArr.length; i++) {
        String field = fieldsArr[i];
        if (pk.equals(field)) {
            createSql.append(field).append(" varchar");
            createSql.append(" primary key ");
        } else {
            createSql.append("info.").append(field).append(" varchar");
        }
        if (i < fieldsArr.length - 1) {
            createSql.append(",");
        }
    }

    createSql.append(")");
    createSql.append(ext);

    try {
        //执行建表语句在Phoenix中创建表
        Statement statement = connection.createStatement();
        System.out.println(createSql);
        statement.execute(createSql.toString());
        statement.close();
    } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException("建表失败！！！");
    }
}

4）refreshMeta()

读取MySQL中关于需要写入的表的信息，更新到内存Map中

//用于读取配置表信息存入内存的方法
private Map<String, TableProcess> refreshMeta() {

    System.out.println("更新处理信息");

    //创建HashMap用于存放结果数据
    HashMap<String, TableProcess> processHashMap = new HashMap<>();

    //查询MySQL中的配置表数据
    List<TableProcess> tableProcessList = MySQLUtil.queryList("select * from table_process", TableProcess.class, true);

    //遍历查询结果,将数据存入结果集合
    for (TableProcess tableProcess : tableProcessList) {

        //获取源表表名
        String sourceTable = tableProcess.getSourceTable();
        //获取数据操作类型
        String operateType = tableProcess.getOperateType();
        //获取结果表表名
        String sinkTable = tableProcess.getSinkTable();
        //拼接字段创建主键
        String key = sourceTable + ":" + operateType;
        //将数据存入结果结合
        tableProcessMap.put(key, tableProcess);

        if ("insert".equals(operateType) && "hbase".equals(sinkTable)) {
            boolean noExist = existsTables.add(sourceTable);

            //如果表信息数据不存在内存,则在Phoenix中创建新的表
            if (noExist) {
                checkTable(sinkTable, tableProcess.getSinkColumns(), tableProcess.getSinkPk(), tableProcess.getSinkExtend());
            }
        }
    }

    if (tableProcessMap.size() == 0) {
        throw new RuntimeException("缺少处理信息");
    }

    //返回最新的配置表数据信息
    return processHashMap;
}

5）open()

声明周期方法，初始化连接，开启定时任务

//生命周期方法,初始化连接,初始化配置表信息并开启定时任务,用于不断读取配置表信息
@Override
public void open(Configuration parameters) throws Exception {

    //初始化连接
    Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
    connection = DriverManager.getConnection("jdbc:phoenix:hadoop102,hadoop103,hadoop104:2181");

    //初始化配置表信息
    tableProcessMap = refreshMeta();

    //开启定时任务,用于不断读取配置表信息
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
        @Override
        public void run() {
            tableProcessMap = refreshMeta();
        }
    }, 5000, 5000);
}

6）filterColumn()

校验字段，过滤掉多余的字段


private void filterColumn(JSONObject data, String sinkColumns) {
    String[] columns = StringUtils.split(sinkColumns, ",");
    Set<Map.Entry<String, Object>> entries = data.entrySet();
    List<String> columnList = Arrays.asList(columns);
    entries.removeIf(next -> !columnList.contains(next.getKey()));
}

 

7）processElement()

核心处理方法，根据MySQL中的数据，将流区分开

//根据配置表的信息为每条数据打标签，走kafka还是hbase
@Override
public void processElement(JSONObject value, Context ctx, Collector<JSONObject> out) throws Exception {

    String table = value.getString("table");
    String type = value.getString("type");
    JSONObject data = value.getJSONObject("data");

    if (data == null || data.size() <= 3) {
        return;
    }

    if (type.equals("bootstrap-insert")) {
        type = "insert";
        value.put("type", type);
    }

    if (tableProcessMap != null && tableProcessMap.size() > 0) {

        String key = table + ":" + type;
        TableProcess tableProcess = tableProcessMap.get(key);
        if (tableProcess != null) {
            value.put("sink_table", tableProcess.getSinkTable());
            if (tableProcess.getSinkColumns() != null && tableProcess.getSinkColumns().length() > 0) {
                filterColumn(value.getJSONObject("data"), tableProcess.getSinkColumns());
            }
        } else {
            System.out.println("No This Key:" + key);
        }

        if (tableProcess != null && TableProcess.SINK_TYPE_HBASE.equalsIgnoreCase(tableProcess.getSinkType())) {
            ctx.output(outputTag, value);
        } else if (tableProcess != null && TableProcess.SINK_TYPE_KAFKA.equalsIgnoreCase(tableProcess.getSinkType())) {
            out.collect(value);
        }
    }
}
 

 

8）主程序中调用TableProcessFunction

//5.定义输出到HBase的侧输出流标签
OutputTag<JSONObject> hbaseTag = new OutputTag<JSONObject>(TableProcess.SINK_TYPE_HBASE) {};

//6.使用ProcessFunction实现数据分流操作,事实表放入主流,维度表根据维度信息放入侧输出流
SingleOutputStreamOperator<JSONObject> kafkaDStream = filterDS.process(new TableProcessFunction(hbaseTag));

//7.获取侧输出流数据,即将来写往HBase(Phoenix)的数据
DataStream<JSONObject> hbaseDStream = kafkaDStream.getSideOutput(hbaseTag);

4.3.3 功能三：分表Sink之HBase(Phoenix)分表Sink

把分好的流保存到对应表、主题中，这个功能其实是两个问题，一个是Kafka的分表Sink，一个是HBase(Phoenix)的分表Sink。

首先先说HBase(Phoenix)的分表Sink。

流程分析：

DimSink 继承了RickSinkFunction,这个function的分两条时间线。

一条是任务启动时执行open操作（图中紫线），我们可以把连接的初始化工作放在此处一次性执行。

另一条是随着每条数据的到达反复执行invoke()（图中黑线）,在这里面我们要实现数据的保存，主要策略就是根据数据组合成sql提交给hbase。

代码实现:

1）引入phoenix依赖


<dependency>
    <groupId>org.apache.phoenix</groupId>
    <artifactId>phoenix-spark</artifactId>
    <version>5.0.0-HBase-2.0</version>
    <exclusions>
        <exclusion>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.el</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2）因为要用单独的schema,所以在程序中加入hbase-site.xml

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>

<configuration>
    <property>
        <name>hbase.rootdir</name>
        <value>hdfs://hadoop102:8020/hbase</value>
    </property>

    <property>
        <name>hbase.cluster.distributed</name>
        <value>true</value>
    </property>

    <property>
        <name>hbase.zookeeper.quorum</name>
        <value>hadoop102,hadoop103,hadoop104</value>
    </property>

    <property>
        <name>hbase.unsafe.stream.capability.enforce</name>
        <value>false</value>
    </property>

    <property>
        <name>hbase.wal.provider</name>
        <value>filesystem</value>
    </property>

    <!-- phoenix master 配置参数 -->
    <property>
        <name>hbase.master.loadbalancer.class</name>
        <value>org.apache.phoenix.hbase.index.balancer.IndexLoadBalancer</value>
    </property>

    <property>
        <name>hbase.coprocessor.master.classes</name>
        <value>org.apache.phoenix.hbase.index.master.IndexMasterObserver</value>
    </property>

    <!-- phoenix regionserver 配置参数 -->
    <property>
        <name>hbase.regionserver.wal.codec</name>
        <value>org.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec</value>
    </property>

    <property>
        <name>hbase.region.server.rpc.scheduler.factory.class</name>
        <value>org.apache.hadoop.hbase.ipc.PhoenixRpcSchedulerFactory</value>
        <description>Factory to create the Phoenix RPC Scheduler that uses separate queues for index and metadata
            updates
        </description>
    </property>

    <property>
        <name>hbase.rpc.controllerfactory.class</name>
        <value>org.apache.hadoop.hbase.ipc.controller.ServerRpcControllerFactory</value>
        <description>Factory to create the Phoenix RPC Scheduler that uses separate queues for index and metadata
            updates
        </description>
    </property>

    <property>
        <name>phoenix.schema.isNamespaceMappingEnabled</name>
        <value>true</value>
    </property>

    <property>
        <name>phoenix.schema.mapSystemTablesToNamespace</name>
        <value>true</value>
    </property>

</configuration>

3）在phoenix中执行

create schema GMALL_REALTIME;

4）创建公共配置类


public class GmallConfig {

    public static final String HBASE_SCHEMA = "GMALL_REALTIME";

    public static final String PHOENIX_SERVER="jdbc:phoenix:hadoop102,hadoop103,hadoop104:2181";

}

5）DimSink

import java.util.Set;
import java.sql.Statement;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.DriverManager;
import com.logcat.common.GmallConfig;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;

public class DimSink extends RichSinkFunction<JSONObject> {

    private Connection connection = null;

    @Override
    public void open(Configuration parameters) throws Exception {
        Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
        connection = DriverManager.getConnection(GmallConfig.PHOENIX_SERVER);
    }

    @Override
    public void invoke(JSONObject value, Context context) {

        String tableName = value.getString("sink_table");
        JSONObject data = value.getJSONObject("data");
        if (data != null && data.size() > 0) {
            try {
                String upsertSql = genUpsertSql(tableName.toUpperCase(), data);
                System.out.println(upsertSql);
                Statement statement = connection.createStatement();
                statement.executeUpdate(upsertSql);
                connection.commit();
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException("执行SQL失败！");
            }
        }
    }

    private String genUpsertSql(String tableName, JSONObject data) {
        Set<String> fields = data.keySet();
        String upsertSql = "upsert into " + GmallConfig.HBASE_SCHEMA + "." + tableName + "(" + StringUtils.join(fields, ",") + ")";
        String valuesSql = " values('" + StringUtils.join(data.values(), "','") + "')";
        return upsertSql + valuesSql;
    }
}

 

6）主程序中调用DimSink

//8.将侧输出流数据写入HBase(Phoenix)
hbaseDStream.addSink(new DimSink());

4.3.4 功能四：分表Sink之Kafka分表Sink

getKafkaSinkBySchema

在之前的KafkaUtil中我们实现了如下方法， 但是这种方式创建的FlinkKafkaProducer只能针对一个主题进行写入。而该功能要求针对不同的数据写入到不同的主题中。


public static FlinkKafkaProducer<String> getKafkaSink(String topic) {
    return new FlinkKafkaProducer<>(topic, new SimpleStringSchema(), properties);
}

所以在KafkaUtil中加入另外一个方式创建FlinkKafkaProducer

public static <T> FlinkKafkaProducer<T> getKafkaSinkBySchema(KafkaSerializationSchema<T> serializationSchema) {
    return new FlinkKafkaProducer<>(DEFAULT_TOPIC, serializationSchema, properties, FlinkKafkaProducer.Semantic.EXACTLY_ONCE);
}

在主程序中加入新KafkaSink这两者创建 FlinkKafkaProducer的区别是前者给定确定的Topic,而后者除了缺省情况下回采用DEFAULT_TOPIC，一般情况下可以根据不同的业务数据在KafkaSerializationSchema中通过方法实现。

//9.将主流数据写入Kafka
FlinkKafkaProducer<JSONObject> kafkaSink = MyKafkaUtil.getKafkaSinkBySchema(new KafkaSerializationSchema<JSONObject>() {
    @Override
    public void open(SerializationSchema.InitializationContext context) throws Exception {
        System.out.println("启动Kafka Sink");
    }
    @Override
    public ProducerRecord<byte[], byte[]> serialize(JSONObject jsonObject, @Nullable Long aLong) {
        return new ProducerRecord<>(topic, jsonObject.toJSONString().getBytes());
    }
});

kafkaDStream.addSink(kafkaSink);

第5章 总结

DWD的实时计算核心就是数据分流，其次是状态识别。

在开发过程中我们实践了几个灵活度较强算子，比如RichMapFunction, ProcessFunction, RichSinkFunction。 那这几个我们什么时候会用到呢？如何选择？

Function

可转换结构

可过滤数据

侧输出

open方法

可以使用状态

输出至

MapFunction

Yes

No

No

No

No

下游算子

FilterFunction

No

Yes

No

No

No

下游算子

RichMapFunction

Yes

No

No

Yes

Yes

下游算子

RichFilterFunction

No

Yes

No

Yes

Yes

下游算子

ProcessFunction

Yes

Yes

Yes

Yes

Yes

下游算子

SinkFunction

Yes

Yes

No

No

No

外部

RichSinkFunction

Yes

Yes

No

Yes

Yes

外部

从对比表中能明显看出，Rich系列能功能强大，ProcessFunction功能更强大，但是相对的越全面的算子使用起来也更加繁琐。

不爱吃鱼的馋猫
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Flink内核源码解析系列（六）：调用执行环境的execute方法
打工日常
06-08 1023
在上一篇《Flink内核源码解析系列（五）：解析并通过执行用户的命令来执行用户jar中的main方法》中，讲到了在CliFronted类生成了PackageProgram，同时通过它执行用户的main方法。 那写过Flink Jar任务代码的读者都知道，在main方法的最后一行，有代码如下： env.execute(jobName); 因此接下来，就会调用执行环境的execute方法。而执行环境是StreamExecutionEnvironment所在的类的execute方法。 public Jo
Flink中调用执行环境的execute()方法
小泽
11-20 669
flink
flink深入研究(07) flink的StreamExecutionEnvironment.execute()函数调用过程01
weixin_39935887的博客
12-21 2049
今天我们开始分析Flink中第一个流程图StreamGraph的生成，StreamGraph 相关的代码主要在org.apache.flink.streaming.api.graph包中。构造StreamGraph的入口函数是StreamGraphGenerator.generate(env, transformations)。该函数会由触发程序执行的方法StreamExecutionEnv...
Flink五步开发之第五步：Execute
渐宽阁读书小弟
03-27 2565
文章目录execute()执行程序 execute()执行程序 streamExecutionEnvrinonment.execute(“JobName”) 给任务命名，方便在集群上观察
【Flink源码】从StreamExecutionEnvironment.execute看Flink提交过程
wwb44444的博客
11-06 1207
相信大家对这一行代码都不陌生，其作用是执行 Flink 程序，相当于是一个总开关。很难想象，那么复杂的 Flink 架构，那么复杂的 Flink 程序仅仅需要这简单的一个函数就能启动，其背后究竟是怎样的过程？
flink-1.19.0-bin-scala-2.12.tgz flink-1.16.3-bin-scala-2.12.tgz
最新发布
05-21
标题和描述中提到的"flink-1.19.0-bin-scala-2.12.tgz"和"flink-1.16.3-bin-scala-2.12.tgz"是Apache Flink的两个不同版本的二进制发行版。Flink是一个开源的流处理和批处理框架，它提供了低延迟、高吞吐量的数据...
flink-1.13.6_cdc
07-07
2. "flink-sql-connector-elasticsearch7_2.12-1.13.6.jar"：这是Flink SQL Elasticsearch 7连接器的JAR文件，基于Scala 2.12构建，与Flink 1.13.6兼容。此连接器允许用户将处理后的数据流直接写入Elasticsearch 7.x...
flink-1.16.2下载安装包，flink-1.16.2-bin-scala-2.12.zip
02-29
- **解压**：首先，需要将`flink-1.16.2-bin-scala_2.12.zip`文件解压缩到本地目录。 - **环境变量设置**：配置`FLINK_HOME`环境变量指向解压后的目录，并将`bin`目录添加到PATH环境变量中。 - **启动与停止**：...
Flink 资源包 flink-1.15.0-bin-scala_2.12.tgz flink-connector-elasti
07-01
flink-sql-connector-mysql-cdc-2.2.1.jar flink-connector-elasticsearch7-1.15.0.jar flink-1.15.0-bin-scala_2.12.tgz
flink-1.14.0-bin-scala_2.11.tgz
07-18
2. `conf` 目录：配置文件所在，包括 `flink-conf.yaml`，用户可以在这里定制 Flink 集群的配置参数。 3. `lib` 目录：包含所有依赖的 JAR 包，用于运行 Flink 作业。 4. `docs` 目录：包含 Flink 的官方文档，帮助...
09_Flink Streaming execute
codemosi的专栏，点击我可以跳到目录一栏
06-09 4899
通过env.execute();启动任务。env有四个实现类。LocalStreamEnvironment，是在本地jvm使用多线程模拟一个flink集群。四个实现类都是通过getStreamGraph来获取DAG图对象StreamGraph。 StreamGraph，保存着点边关系，和需要的上下文对象。可以重新api编程的语义。持有一个JobGraph对象，用来提交给集群。由Client，Jo
Flink
热门推荐
修行的博客
08-14 1万+
Flink 一、简介 Flink核心是一个流式的数据流执行引擎，其针对数据流的分布式计算提供了数据分布、数据通信以及容错机制等功能。基于流执行引擎，Flink提供了诸多更高抽象层的API以便用户编写分布式任务： ​ DataSet API， 对静态数据进行批处理操作，将静态数据抽象成分布式的数据集，用户可以方便地使用Flink提供的各种操作符对分布式数据集进行处理，支持Java、Scala和Pyt...
Flink原理分析--Flink任务执行总体流程
zg_hover的专栏
11-26 3367
Flink任务执行总体流程 本文描述一个Flink任务执行的总体流程的前半部分，执行环境的选择。 Flink任务的一个例子 public class SocketWindowWordCount { public static void main(String[] args) throws Exception { // the port to connect to final int port; try { final Par
Flink知识点
m0_60600640的博客
06-13 282
实时流处理引擎 storm: 来一条处理一条 时效性强 吞吐量差 适合延迟低业务比较小的时候 sparkStreaming: 微批处理 高吞吐 容错性高 时效性差 适合之前的业务都是用spark生态写的 并且秒级的时效性完全可以满足我们的需求 flink: 要求高时效性 高吞吐量的时候可以选择flink Flink几种图的变化 Stream Graph Job Graph
Flink表转流一例+何时应该使用execute()
微电子学与固体电子学-俞驰
01-21 1203
我们常常会遇到是否应该写execute()的问题 batch的print()中已经加入了execute executeSql()里面已经加入了 execute 所以上述两种情况下，代码使用者不需要再在代码末尾加入execute() 那么为什么下面这种使用executeSql以后为啥还需要在代码末尾加入execute()呢 这是因为这个例子是 表转流， 虽然表操作时的executeSql里面已经具备了execute()功能 但是这个只是激活表环境，没有流环境， 所以需要再次execute
Flink中Table Api和SQL（二）
JiaXingNashishua的博客
10-02 3513
被称为“动态表”（Dynamic Tables）。动态表是Flink在Table API和SQL中的核心概念，它为流数据处理提供了表和SQL支持。我们所熟悉的表一般用来做批处理，面向的是固定的数据集，可以认为是“静态表”；而。
第五篇|Flink Table API & SQL编程指南(1)
wr_java的博客
04-02 564
Apache Flink提供了两种顶层的关系型API，分别为Table API和SQL，Flink通过Table API&SQL实现了批流统一。其中Table API是用于Scala和Java的语言集成查询API，它允许以非常直观的方式组合关系运算符（例如select，where和join）的查询。Flink SQL基于实现了标准的SQL，用户可以使用标准的SQL处理数据集。
JavaFlink原理、实战、源码分析（二）原理部分
qq_36250202的博客
04-13 1014
JavaFlink原理、实战源码分析(一)https://blog.csdn.net/qq_36250202/article/details/112978869 第六章 Flink 中的 Window 主要内容 • window 概念 • window 类型 • window API 6.1 Window 6.1.1 Window 概述 streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是一种切割.
【API篇】一、Flink执行环境API
llg___的博客
10-13 286
写完输出（sink）操作并不代表程序已经结束，因为当main()方法被调用时，其实只是定义了作业的每个执行操作，然后添加到数据流图中，这时并没有真正处理数据，因为数据可能还没来。Flink是由事件驱动的，只有等到数据到来，才会触发真正的计算，这也被称为。Flink的程序可以在各种上下文环境中运行，比如本地JVM中执行，也可以提交到远程集群中运行，分别对应着不同的Flink的运行环境，获取这个执行环境，也就是StreamExecutionEnvironment类的对象。前者用的更多，不推荐硬编码。
flink-sql-connector 和flink-connector 区别
05-17
Flink-SQL-Connector 和 Flink-Connector 都是 Apache Flink 的连接器，但它们的主要区别在于用途和功能。 Flink-SQL-Connector 是为了支持 Flink SQL 而开发的一组连接器，它们包括 JDBC、Elasticsearch、Kafka、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值