Flink CDC2(1)，真的太香了

最新推荐文章于 2024-04-13 06:34:01 发布

2401_84160361

最新推荐文章于 2024-04-13 06:34:01 发布

阅读量960

点赞数 12

分类专栏： 2024年程序员学习文章标签： flink 大数据

本文链接：https://blog.csdn.net/2401_84160361/article/details/137486317

版权

2024年程序员学习专栏收录该内容

114 篇文章 1 订阅

订阅专栏

.startupOptions(StartupOptions.initial())
.includeSchemaChanges(true)
// 发现新表，加入同步任务，需要在tableList中配置
.scanNewlyAddedTableEnabled(true)
.deserializer(new JsonDebeziumDeserializationSchema(false, customConverterConfigs)).build()

val streamSource: DataStream[JSONObject] = env.fromSource(mysqlSource, WatermarkStrategy.noWatermarks(), “MySQL Source”)
.map(line => JSON.parseObject(line)).setParallelism(4)

val DDLSqlStream: DataStream[JSONObject] = streamSource.filter(line => !line.containsKey(“op”)).uid(“ddlSqlStream”)
val DMLStream: DataStream[JSONObject] = streamSource.filter(line => line.containsKey(“op”)).uid(“dmlStream”)
/**

首次全量同步时时间窗口内几乎为一个表数据，此时下面操作会数据倾斜
在binLogETLOne 中对表加随机数后缀使其均匀分布
聚合操作之后再将tableName转换为实际表
*/
val DMLDataStream = FlinkCDCSyncETL.binLogETLOne(DMLStream)
val keyByDMLDataStream:DataStream[(String, String, String, JSONArray)] = DMLDataStream.keyBy(keys => (keys._1, keys._2, keys._3))
.timeWindow(Time.milliseconds(props.window_time_milliseconds))
.reduce((itemFirst, itemSecond) => (itemFirst._1, itemFirst._2, itemFirst._3,combineJsonArray(itemFirst._4,itemSecond._4)))
.map(line=>(line._1,line._2,line._3.split(“-”)(0),line._4))
.name(“分组聚合”).uid(“keyBy”)

keyByDMLDataStream.addSink(new SinkDoris(dorisStreamLoad)).name(“数据写入Doris”).uid(“SinkDoris”).setParallelism(4)

val DDLKafkaSink=getKafkaSink(“schema_change”)
DDLSqlStream.map(jsObj => jsObj.toJSONString()).sinkTo(DDLKafkaSink).name(“同步DDL入Kafka”).uid(“SinkDDLKafka”)

val kafkaSink=getKafkaSink(syncTopic)
keyByDMLDataStream.map(line=>(line._2,line.3,1)).filter(!._2.endsWith(“_sql”))
.keyBy(keys => (keys._1, keys._2))
.window(TumblingProcessingTimeWindows.of(Time.seconds(1))).sum(2)
.map(line =>{
val json = new JSONObject()
json.put(“member_id”, line._1)
json.put(“table”, line._2)
json.toJSONString()
}).sinkTo(kafkaSink).name(“同步数据库表入Kafka”).uid(“syncDataTableToKafka”)

env.execute(jobName)

}

def combineJsonArray(jsr1:JSONArray,jsr2:JSONArray): JSONArray ={
jsr1.addAll(jsr2)
jsr1
}

}

2.FlinkCDCSyncETL.scala

package com.zbkj.util

import com.alibaba.fastjson2.{JSON, JSONArray, JSONObject}
import org.apache.flink.api.scala.createTypeInformation
import org.apache.flink.streaming.api.scala.DataStream

import java.util.Random

object FlinkCDCSyncETL {

def binLogETLOne(dataStreamSource: DataStream[JSONObject]): DataStream[(String, String, String, JSONArray)] = {
/**

根据不同日志类型匹配load doris方式
*/
val tupleData: DataStream[(String, String, String, JSONArray)] = dataStreamSource.map(line => {
var data: JSONObject = new JSONObject()
var jsr: JSONArray = new JSONArray()
var mergeType = “APPEND”
val source = line.getJSONObject(“source”)
val db = source.getString(“db”)
val table = source.getString(“table”)
val op=line.getString(“op”)
if (“d” == op) {
data = line.getJSONObject(“before”)
mergeType = “DELETE”
} else if (“u” == op) {
data = line.getJSONObject(“after”)
mergeType = “APPEND”
} else if (“c” == op) {
data = line.getJSONObject(“after”)
} else if (“r” == op) {
data = line.getJSONObject(“after”)
mergeType = “APPEND”
}
jsr.add(data)
Tuple4(mergeType, db, table+ “-” + new Random().nextInt(4), jsr)
})
tupleData
}

}

3.DorisStreamLoad2.scala

package com.zbkj.util

import org.apache.doris.flink.exception.StreamLoadException
import org.apache.doris.flink.sink.HttpPutBuilder
import org.apache.http.client.methods.CloseableHttpResponse
import org.apache.http.entity.StringEntity
import org.apache.http.impl.client.{DefaultRedirectStrategy, HttpClientBuilder, HttpClients}
import org.apache.http.util.EntityUtils
import org.slf4j.{Logger, LoggerFactory}

import java.util.{Properties, UUID}

class DorisStreamLoad2(props: PropertiesUtil) extends Serializable {
private val logger: Logger = LoggerFactory.getLogger(classOf[DorisStreamLoad2])

private lazy val httpClientBuilder: HttpClientBuilder = HttpClients.custom.setRedirectStrategy(new DefaultRedirectStrategy() {
override protected def isRedirectable(method: String): Boolean = {
// If the connection target is FE, you need to deal with 307 redirect。
true
}
})

def loadJson(jsonData: String, mergeType: String, db: String, table: String): Unit = try {
val loadUrlPattern = “http://%s/api/%s/%s/_stream_load?”
val entity = new StringEntity(jsonData, “UTF-8”)
val streamLoadProp = new Properties()
streamLoadProp.setProperty(“merge_type”, mergeType)
streamLoadProp.setProperty(“format”, “json”)
streamLoadProp.setProperty(“column_separator”, “,”)
streamLoadProp.setProperty(“line_delimiter”, “,”)
streamLoadProp.setProperty(“strip_outer_array”, “true”)
streamLoadProp.setProperty(“exec_mem_limit”, “6442450944”)
streamLoadProp.setProperty(“strict_mode”, “true”)
val httpClient = httpClientBuilder.build
val loadUrlStr = String.format(loadUrlPattern, props.doris_load_host, db, table)
try {
val builder = new HttpPutBuilder()
val label = UUID.randomUUID.toString
builder.setUrl(loadUrlStr)
.baseAuth(props.doris_user, props.doris_password)
.addCommonHeader()
.setLabel(label)
.setEntity(entity)
.addProperties(streamLoadProp)
handlePreCommitResponse(httpClient.execute(builder.build()))
}

def handlePreCommitResponse(response: CloseableHttpResponse): Unit = {
val statusCode: Int = response.getStatusLine.getStatusCode
if (statusCode == 200 && response.getEntity != null) {
val loadResult: String = EntityUtils.toString(response.getEntity)
logger.info(“load Result {}”, loadResult)
} else {
throw new StreamLoadException("stream load error: " + response.getStatusLine.toString)
}

}

}
}

4.SinkDoris.scala

package com.zbkj.util

import com.alibaba.fastjson2.JSONArray
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction

class SinkDoris(dorisStreamLoad:DorisStreamLoad2) extends RichSinkFunction[(String, String, String, JSONArray)] {

override def open(parameters: Configuration): Unit = {}
/**