1、需求分析
1.1、当日新增付费用户分析
按省份|用户性别|用户年龄段，统计当日新增付费用户首单平均消费及人数占比无论是省份名称、用户性别、用户年龄，订单表中都没有这些字段，需要订单（事实表）和维度表（省份、用户）进行关联，形成宽表后将数据写入到ES，通过Kibana进行分析以及图形展示。
1.2、整体实时计算框架
1.3、具体业务流程
1.4、实现方案
第一步：从MySQL数据库中采集业务数据到Kafka，并对数据进行分流处理（ODS层），分流数据处理之后，将数据写回Kafka。我们这里使用canal和Maxwell两种方式实现
第二步：每笔订单都要判断是否是该用户的首单判断是否首单的要点，在于该用户之前是否参与过消费（下单）。那么如何知道用户之前是否参与过消费，如果临时从所有消费记录中查询，是非常不现实的。那么只有将“用户是否消费过”这个状态进行保存并长期维护起来。在有需要的时候通过用户id进行关联查询。在实际生产中，这种用户状态是非常常见的比如“用户是否退过单”、“用户是否投过诉”、“用户是否是高净值用户”等等。我们要想保存状态，大家可能会想到在Redis中保存，Reids可以实现，但是这个状态可能包含历史数据，数据量比较大，而且历史数据保存在内存中，对内存压力也比较大。所以考虑到
- 这是一个保存周期较长的数据。
- 必须可修改状态值。
- 查询模式基本上是k-v模式的查询
所以综上这三点比较，状态适合保存在Hbase中
第3步：在查询订单的时候，订单与Hbase中省份和用户的维度表进行关联，才能获取省份名称、用户性别、用户年龄等对应字段，完成后面的统计。
2、数据采集——canal 实现
2.1、canal 入门
2.1.1、canal 是什么
阿里巴巴B2B公司，因为业务的特性，卖家主要集中在国内，买家主要集中在国外，所以衍生出了同步杭州和美国异地机房的需求，从2010年开始，阿里系公司开始逐步的尝试基于数据库的日志解析，获取增量变更进行同步，由此衍生出了增量订阅&消费的业务。canal是用java开发的基于数据库增量日志解析，提供增量数据订阅&消费的中间件。目前，canal主要支持了MySQL的binlog解析，解析完成后才利用canal client来处理获得的相关数据。（数据库同步需要阿里的otter中间件，基于canal）。
2.1.2、canal 使用场景
(1) 原始场景： 阿里otter中间件的一部分otter是阿里用于进行异地数据库之间的同步框架，canal是其中一部分。
(2) 常见场景1：更新缓存
(3) 常见场景2：抓取业务数据新增变化表，用于制作拉链表。
(4) 常见场景3：抓取业务表的新增变化数据，用于制作实时统计（此处就是这种场景）
2.1.3、canal 工作原理
(1) MySQL主从复制过程
- Master主库将变更记录，写到二进制日志(binary log)中
- Slave从库向mysql master发送dump协议，将master主库的binary log events拷贝到它的中继日志(relay log)；
- Slave从库读取并重做中继日志中的事件，将改变的数据同步到自己的数据库
(2) canal的工作原理
很简单，就是把自己伪装成slave，假装从master复制数据
2.1.4、Mysql binlog
什么是binlog？
MySQL的二进制日志可以说MySQL最重要的日志了，它记录了所有的DDL和DML(除了数据查询语句)语句，以事件形式记录，还包含语句所执行的消耗的时间，MySQL的二进制日志是事务安全型的。般来说开启二进制日志大概会有1%的性能损耗。二进制有两个最重要的使用场景:
- 其一：MySQL Replication在Master端开启binlog，Master把它的二进制日志传递给slaves来达到master-slave数据一致的目的。
- 其二：自然就是数据恢复了，通过使用mysqlbinlog工具来使恢复数据。
二进制日志包括两类文件：二进制日志索引文件（文件名后缀为.index）用于记录所有的二进制文件，二进制日志文件（文件名后缀为.00000*）记录数据库所有的DDL和DML(除了数据查询语句)语句事件。
如何开启 binlog？
找到MySQL配置文件的位置
[hui@hadoop201 ~]$ locate my.cnf
/etc/my.cnf
使用root 用户编辑该配置文件
在[mysqld] 区块，设置/添加 log-bin=mysql-bin
这个表示binlog日志的前缀是mysql-bin，以后生成的日志文件就是 mysql-bin.123456 的文件后面的数字按顺序生成，每次mysql重启或者到达单个文件大小的阈值时，新生一个文件，按顺序编号。
binlog的分类设置
mysql binlog的格式有三种，分别是STATEMENT,MIXED,ROW。在配置文件中可以选择配置 binlog_format= statement|mixed|row
n statement
语句级，binlog会记录每次一执行写操作的语句。
相对row模式节省空间，但是可能产生不一致性，比如
update tt set create_date=now()
如果用binlog日志进行恢复，由于执行时间不同可能产生的数据就不同。
优点： 节省空间
缺点： 有可能造成数据不一致。
n row
行级， binlog会记录每次操作后每行记录的变化。
优点：保持数据的绝对一致性。因为不管sql是什么，引用了什么函数，他只记录执行后的效果。
缺点：占用较大空间。
n mixed
statement的升级版，一定程度上解决了，因为一些情况而造成的statement模式不一致问题
默认还是statement，在某些情况下譬如：
当函数中包含 UUID() 时；
包含 AUTO_INCREMENT 字段的表被更新时；
执行 INSERT DELAYED 语句时；
用 UDF 时；
会按照 ROW的方式进行处理
优点：节省空间，同时兼顾了一定的一致性。
缺点：还有些极个别情况依旧会造成不一致，另外statement和mixed对于需要对binlog的监控的情况都不方便。
综合上面对比，Cannel想做监控分析，选择row格式比较合适
2.2、mysql 数据库准备
2.2.1、创建数据库
创建数据库
CREATE DATABASE `gmall0423` /*!40100 DEFAULT CHARACTER SET utf8 */
执行初始化建表脚本
2.2.2、修改 my.cnf
server-id= 1 log-bin=mysql-bin binlog_format=row binlog-do-db=gmall0423 #注意：binlog-do-db根据自己的情况进行修改，指定具体要同步的数据库 #若监控多个数据库，可以再写一行 binlog-do-db=db_name
sudo systemctl restart mysqld
创建canal 数据库并赋权
CREATE DATABASE `canal` /*!40100 DEFAULT CHARACTER SET utf8 */ mysql> SET GLOBAL validate_password_length=4; mysql> SET GLOBAL validate_password_policy=0; mysql> GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%' IDENTIFIED BY 'canal' ;
2.3、canal 安装
2.3.1、canal 架构
2.3.2、canal 安装&配置
注意：canal解压后是散的，我们在指定解压目录的时候需要将canal指定上
mkdir /opt/module/canal
tar -zxvf canal.deployer-1.1.4.tar.gz -C /opt/module/canal
配置
/opt/module/canal/conf [hui@hadoop201 conf]$ less canal.properties # tcp, kafka, RocketMQ #更改 canal的输出model，默认tcp，改为输出到kafka，tcp就是输出到canal客户端，通过编写Java代码处理 canal.serverMode = kafka #修改Kafka集群的地址 canal.mq.servers = hadoop201:9092,hadoop202:9092,hadoop203:9092
注意：如果创建多个实例通过前面canal架构，我们可以知道，一个canal服务中可以有多个instance，conf/下的每一个example即是一个实例，每个实例下面都有独立的配置文件。默认只有一个实例example，如果需要多个实例处理不同的MySQL数据的话，直接拷贝出多个example，并对其重新命名，命名和配置文件中指定的名称一致，然后修改canal.properties中的canal.destinations=实例1，实例2，实例3。
################################################# ######### destinations ############# ################################################# canal.destinations = example
修改instance.properties：这里只读取一个MySQL数据，所以只有一个实例，这个实例的配置文件在conf/example目录下
#mysql 地址 canal.instance.master.address=hadoop201:3306 # username/password canal.instance.dbUsername=canal canal.instance.dbPassword=canal # mq config #输出的topic canal.mq.topic=gmall0426_db_canal # dynamic topic route by schema or table regex #canal.mq.dynamicTopic=mytest1.user,mytest2\\..*,.*\\..* #canal.mq.partition=0 # hash partition config #注意：默认还是输出到指定Kafka主题的一个kafka分区，因为多个分区并行可能会打乱binlog的顺序 #如果要提高并行度，首先设置kafka的分区数>1,然后设置canal.mq.partitionHash属性 canal.mq.partitionsNum=4 canal.mq.partitionHash=*\\..*${pk}$
2.3.4、canal 测试
启动canal
[hui@hadoop201 example]$ /opt/module/canal/bin/stop.sh [hui@hadoop201 example]$ jps 1562 Jps 1548 CanalLauncher
启动zk,kafka 开启消费测试
bin/kafka-console-consumer.sh --bootstrap-server hadoop201:9092 --topic gmall0426_db_canal
启动数据库模拟生成数据，观察消费情况
[hui@hadoop201 rt_dblog]$ java -jar gmall2020-mock-db-2020-05-18.jar
消费到数据格式：
{ "data":[ { "id":"344", "activity_id":"2", "order_id":"3488", "create_time":"2022-04-23 04:45:53" } ], "database":"gmall0423", "es":1651783554000, "id":20, "isDdl":false, "mysqlType":{ "id":"bigint(20)", "activity_id":"bigint(20)", "order_id":"bigint(20)", "create_time":"datetime" }, "old":null, "pkNames":[ "id" ], "sql":"", "sqlType":{ "id":-5, "activity_id":-5, "order_id":-5, "create_time":93 }, "table":"activity_order", "ts":1651783563724, "type":"INSERT" }
2.4、canal 版本的 ods 层数据分流
2.4.1、数据格式
样例SQL
INSERT INTO user_info VALUES(16,'zhang3','13810001010'),(17,'zhang3','13810001010');
canal 接收的数据格式
{"data":[{"id":"16","user_name":"zhang3","tel":"13810001010"},{"id":"17","user_name":"zhang3","tel":"13810001010"}],"database":"gmall-2020-04","es":1589196502000,"id":4,"isDdl":false,"mysqlType":{"id":"bigint(20)","user_name":"varchar(20)","tel":"varchar(20)"},"old":null,"pkNames":["id"],"sql":"","sqlType":{"id":-5,"user_name":12,"tel":12},"table":"user_info","ts":1589196502433,"type":"INSERT"}
2.4.2、分流逻辑
canal会追踪整个数据库的变更，把所有的数据变化都发到一个topic中了，但是为了后续处理方便，应该把这些数据根据不同的表，分流到不同的主题中去。
kafka 发送工具类
import java.util.Properties
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}
/**
* 发送数据到 kafka
*/
object MyKafkaSink {
//加载配置文件
private val properties: Properties = MyPropertiesUtil.load("config.properties")
//获取kafka连接信息
val broker_list = properties.getProperty("kafka.broker.list")
var kafkaProducer: KafkaProducer[String, String] = null
//创建 producer
def createKafkaProducer: KafkaProducer[String, String] = {
val properties = new Properties
properties.put("bootstrap.servers", broker_list)
properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer")
properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer")
properties.put("enable.idempotence", (true: java.lang.Boolean))
var producer: KafkaProducer[String, String] = null
try
producer = new KafkaProducer[String, String](properties)
catch {
case e: Exception =>
e.printStackTrace()
}
producer
}
def send(topic: String, msg: String): Unit = {
if (kafkaProducer == null) kafkaProducer = createKafkaProducer
kafkaProducer.send(new ProducerRecord[String, String](topic, msg))
}
def send(topic: String, key: String, msg: String): Unit = {
if (kafkaProducer == null) kafkaProducer = createKafkaProducer
kafkaProducer.send(new ProducerRecord[String, String](topic, key, msg))
}
}
分流逻辑
package org.wdh01.gmall.realtime.ods
import com.alibaba.fastjson.{JSON, JSONArray, JSONObject}
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.TopicPartition
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{HasOffsetRanges, OffsetRange}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.wdh01.gmall.realtime.util.{MyKafkaSink, MyKafkaUtil, OffsetManagerUtil}
/**
* 从 kafka 读取数据，根据表名进行分流
*/
object BaseDBCanalApp {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf().setAppName("BaseDBCanalApp").setMaster("local[4]")
val ssc: StreamingContext = new StreamingContext(conf, Seconds(5))
var topic: String = "gmall0426_db_canal"
var groupid: String = "base_db_db_canal_group"
//从 redis 获取偏移量信息
var recordDstream: InputDStream[ConsumerRecord[String, String]] = null
val offsetMap: Map[TopicPartition, Long] = OffsetManagerUtil.getOffset(topic, groupid)
if (offsetMap != null && offsetMap.size > 0) {
//从偏移量位置开始小飞虫
recordDstream = MyKafkaUtil.getKafkaStream(topic, ssc, offsetMap, groupid)
} else {
//从起始位置开始小飞虫
recordDstream = MyKafkaUtil.getKafkaStream(topic, ssc, groupid)
}
var ranges: Array[OffsetRange] = Array.empty[OffsetRange]
//获取当前批次的偏移量信息
val offsetDStream: DStream[ConsumerRecord[String, String]] = recordDstream.transform {
rdd => {
ranges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
}
rdd
}
//对接收数据进行结构转换
val jsonObjDstream: DStream[JSONObject] = offsetDStream.map {
record => {
//json 格式字符串
val jsonStr: String = record.value()
val jsonObj: JSONObject = JSON.parseObject(jsonStr)
jsonObj
}
}
//分流 根据表名 发送到不同的 topic
jsonObjDstream.foreachRDD {
rdd => {
rdd.foreach {
jsonObj => {
//获取操作类型
val opType: String = jsonObj.getString("type")
if ("INSERT".equals(opType)) {
//获取表名
val tabName: String = jsonObj.getString("table")
//获取数据
val dataArray: JSONArray = jsonObj.getJSONArray("data")
//拼接要要发送的topic
val sednTopic: String = "ods_" + tabName
//遍历数组
import scala.collection.JavaConverters._
for (data <- dataArray.asScala) {
//根据表名分流
MyKafkaSink.send(sednTopic, data.toString)
}
}
}
}
//提交偏移量
OffsetManagerUtil.saveOffset(topic, groupid, ranges)
}
}
ssc.start()
ssc.awaitTermination()
}
}