一、需求场景
Flink 流式计算中，常需以原始数据流为基础，关联外部维表补充属性，满足业务分析需求。
示例：订单数据流中仅包含收货人所在省的 ID，需关联外部维表（存储省 ID 与省名称的映射关系），补充省名称属性，完善订单数据维度。
实际业务中，维表数据通常存储在 MySQL、HBase、Redis 等外部系统，且存在定时更新需求，需根据业务时效性要求选择合适的关联方案。
常用维表关联方案主要分为以下4类，基本覆盖所有业务场景：
-
实时查询维表
-
预加载全量数据
-
LRU 缓存
-
其他衍生方案
二、实时查询维表
2.1 核心原理
实时查询维表是指在 Flink 算子中直接访问外部数据库（如 MySQL），采用同步调用方式，确保获取的维表数据是最新的。核心逻辑是在 Flink 算子（如 Map 算子）中建立外部系统连接，每条数据流触发一次外部查询，完成关联。
2.2 优缺点
-
优点：数据实时性最高，确保关联的维表数据是最新状态；
-
缺点：
-
高并发场景下，会对外部系统造成巨大访问压力，QPS 需求极高（峰值可达十万到几十万），作业瓶颈转移至外部系统；
-
同步调用易导致线程阻塞、Task 等待数据返回，影响整体任务吞吐量；
-
外部系统异常（如连接失败、线程池满）会直接影响 Flink 任务稳定性。
-
2.3 代码实现（订单关联城市名称）
以订单数据为例，根据下单用户的城市 ID，关联 MySQL 维表获取城市名称，核心代码如下：
2.3.1 订单实体类
public class Order {
private Integer cityId;
private String userName;
private String items;
private String cityName; // 关联维表后补充的属性
// 无参构造
public Order() {}
// 带参构造（关联后使用）
public Order(Integer cityId, String userName, String items, String cityName) {
this.cityId = cityId;
this.userName = userName;
this.items = items;
this.cityName = cityName;
}
// getter/setter 方法
public Integer getCityId() {
return cityId;
}
public void setCityId(Integer cityId) {
this.cityId = cityId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getItems() {
return items;
}
public void setItems(String items) {
this.items = items;
}
public String getCityName() {
return cityName;
}
public void setCityName(String cityName) {
this.cityName = cityName;
}
@Override
public String toString() {
return "Order{" +
"cityId=" + cityId +
", userName='" + userName + '\'' +
", items='" + items + '\'' +
", cityName='" + cityName + '\'' +
'}';
}
}
2.3.2 实时查询维表算子
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.configuration.Configuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSONObject;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class DimSync extends RichMapFunction<String, Order> {
private static final Logger LOGGER = LoggerFactory.getLogger(DimSync.class);
private Connection conn = null; // 外部数据库连接
/**
* 初始化方法：Task启动时执行，创建数据库连接
*/
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
// 建立MySQL连接（需引入MySQL驱动依赖）
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/dim?characterEncoding=UTF-8",
"admin",
"admin"
);
}
/**
* 核心处理方法：每条数据触发一次维表查询
*/
@Override
public Order map(String in) throws Exception {
// 解析输入的JSON格式订单数据
JSONObject jsonObject = JSONObject.parseObject(in);
Integer cityId = jsonObject.getInteger("city_id");
String userName = jsonObject.getString("user_name");
String items = jsonObject.getString("items");
// 根据city_id查询MySQL维表，获取city_name
PreparedStatement pst = conn.prepareStatement("select city_name from info where city_id = ?");
pst.setInt(1, cityId);
ResultSet resultSet = pst.executeQuery();
String cityName = null;
while (resultSet.next()){
cityName = resultSet.getString(1);
}
pst.close(); // 关闭PreparedStatement，避免资源泄露
// 返回关联后的订单数据
return new Order(cityId, userName, items, cityName);
}
/**
* 关闭方法：Task结束时执行，释放数据库连接
*/
@Override
public void close() throws Exception {
super.close();
if (conn != null && !conn.isClosed()) {
conn.close(); // 释放连接，避免打满MySQL连接数
}
}
}
2.4 注意事项
-
适用场景：仅适用于小数据量维表查询，避免高并发场景下压垮外部系统；
-
连接管理：需妥善处理外部系统连接，建议使用线程池管理连接，避免单条数据创建一个连接；
-
资源释放：必须在
close\(\)方法中释放数据库连接、PreparedStatement 等资源，防止连接泄露导致外部系统连接数耗尽，进而引发任务失败。
三、预加载全量数据
3.1 核心原理
为解决实时查询维表带来的外部系统频繁访问、连接压力大的问题，预加载全量数据采用“一次性加载+定时更新”的思路：
-
Flink 任务启动时，将外部维表的全量数据加载到内存中；
-
数据流处理时，直接在内存中进行关联，无需访问外部数据库；
-
通过定时任务拉取维表最新数据，更新内存中的缓存，解决维表数据更新无法感知的问题。
3.2 优缺点
-
优点：仅需一次性访问外部系统，大幅降低外部系统压力，关联效率极高（内存查询）；
-
缺点：
-
内存消耗大：全量维表数据缓存于内存，不适用于数据量较大的维表；
-
数据延迟：定时更新机制导致维表数据存在延迟，无法实时获取最新数据；
-
维表更新感知不及时：若维表数据更新频繁，定时更新间隔难以平衡延迟与性能。
-
3.3 代码实现（定时拉取城市维表）
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.configuration.Configuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSONObject;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class WholeLoad extends RichMapFunction<String, Order> {
private static final Logger LOGGER = LoggerFactory.getLogger(WholeLoad.class);
private ScheduledExecutorService executor; // 定时任务线程池
private Map<String, String> cache; // 内存缓存，存储city_id与city_name的映射
/**
* 初始化方法：启动定时任务，定时拉取维表数据
*/
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
// 初始化缓存（可使用HashMap、ConcurrentHashMap等线程安全集合）
cache = new ConcurrentHashMap<>();
// 初始化定时任务线程池，每隔5分钟拉取一次维表数据
executor = Executors.newSingleThreadScheduledExecutor();
executor.scheduleAtFixedRate(
this::load, // 定时执行的方法（拉取维表数据）
5, // 延迟5秒后开始第一次执行
5, // 每次执行间隔5分钟
TimeUnit.MINUTES
);
// 首次启动时主动拉取一次数据
load();
}
/**
* 核心处理方法：从内存缓存中查询维表数据，完成关联
*/
@Override
public Order map(String value) throws Exception {
JSONObject jsonObject = JSONObject.parseObject(value);
Integer cityId = jsonObject.getInteger("city_id");
String userName = jsonObject.getString("user_name");
String items = jsonObject.getString("items");
// 从内存缓存中获取city_name（无需访问外部数据库）
String cityName = cache.get(String.valueOf(cityId));
return new Order(cityId, userName, items, cityName);
}
/**
* 维表数据拉取方法：从MySQL拉取全量维表数据，更新内存缓存
*/
public void load() throws Exception {
Class.forName("com.mysql.jdbc.Driver"); // 加载MySQL驱动
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/dim?characterEncoding=UTF-8",
"admin",
"admin"
);
PreparedStatement statement = con.prepareStatement("select city_id,city_name from info");
ResultSet rs = statement.executeQuery();
// 清空原有缓存，更新为最新数据（避免数据冗余）
cache.clear();
while (rs.next()) {
String cityId = rs.getString("city_id");
String cityName = rs.getString("city_name");
cache.put(cityId, cityName);
}
// 释放资源
rs.close();
statement.close();
con.close();
LOGGER.info("维表数据拉取完成，缓存大小：{}", cache.size());
}
/**
* 关闭方法：停止定时任务，释放资源
*/
@Override
public void close() throws Exception {
super.close();
if (executor != null && !executor.isShutdown()) {
executor.shutdown(); // 停止定时任务线程池
}
}
}
3.4 注意事项
-
适用场景：维表数据量小、实时性要求不高，且数据更新频率较低的场景；
-
缓存选择：需使用线程安全的集合（如 ConcurrentHashMap），避免多线程操作缓存出现数据异常；
-
定时间隔：根据维表更新频率设置合理的定时拉取间隔，平衡数据延迟与系统性能；
-
资源释放：停止任务时需关闭定时任务线程池，避免线程泄露。
四、LRU 缓存
4.1 核心原理
LRU（Least Recently Used，最近最少使用）是一种缓存淘汰算法，核心逻辑是：当缓存容量达到上限时，淘汰最近最少使用的冷数据，保留查询频率高的热数据。
Flink 中使用 LRU 缓存关联维表的思路：
-
利用 Flink 的
RichAsyncFunction（异步 IO）读取外部维表（如 HBase）数据到 LRU 缓存； -
关联时优先查询缓存，缓存命中则直接返回结果；
-
缓存未命中时，通过异步客户端查询外部维表，将结果插入缓存后返回，同时触发 LRU 淘汰机制（若缓存满）。
补充：异步 IO（RichAsyncFunction）的核心作用是解决与外部系统交互时，网络延迟成为系统瓶颈的问题，通过并发异步请求，避免同步等待导致的线程阻塞，提升任务吞吐量。
4.2 优缺点
-
优点：
-
缓存热数据，减少外部系统访问次数，降低网络延迟和外部系统压力；
-
异步 IO 支持并发请求，提升任务吞吐量；
-
缓存容量可控，通过淘汰冷数据，降低内存消耗。
-
-
缺点：
-
数据存在延迟：缓存数据有过期时间，维表数据更新后无法实时同步；
-
实现复杂度高于前两种方案，需配置缓存参数、异步客户端。
-
4.3 依赖与代码实现
4.3.1 依赖引入（HBase 异步客户端）
<!-- HBase 异步客户端依赖 -->
<dependency>
<groupId>org.hbase</groupId>
<artifactId>asynchbase</artifactId>
<version>1.8.2</version>
</dependency>
<!-- Guava 缓存依赖（用于实现LRU缓存） -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1-jre</version>
</dependency>
4.3.2 LRU 缓存与异步关联代码
import org.apache.flink.api.common.functions.RichAsyncFunction;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.util.Collector;
import org.hbase.async.GetRequest;
import org.hbase.async.HBaseClient;
import org.hbase.async.KeyValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSONObject;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class LRU extends RichAsyncFunction<String, Order> {
private static final Logger LOGGER = LoggerFactory.getLogger(LRU.class);
private static final String HBASE_TABLE = "info"; // HBase维表名称
private Cache<String, String> lruCache; // LRU缓存
private HBaseClient hbaseClient; // HBase异步客户端
/**
* 初始化方法：创建HBase客户端和LRU缓存
*/
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
// 1. 初始化HBase异步客户端（指定HBase地址和端口）
hbaseClient = new HBaseClient("127.0.0.1", "7071");
// 2. 初始化LRU缓存
lruCache = CacheBuilder.newBuilder()
.maximumSize(10000) // 缓存最大容量（10000条）
.expireAfterWrite(60, TimeUnit.SECONDS) // 缓存过期时间（1分钟）
.build(); // 默认使用LRU淘汰算法
}
/**
* 异步处理方法：异步查询缓存/维表，完成关联
*/
@Override
public void asyncInvoke(String input, Collector<Order> resultFuture) throws Exception {
// 解析输入的JSON格式订单数据
JSONObject jsonObject = JSONObject.parseObject(input);
Integer cityId = jsonObject.getInteger("city_id");
String userName = jsonObject.getString("user_name");
String items = jsonObject.getString("items");
String cityIdStr = String.valueOf(cityId);
// 1. 先查询LRU缓存
String cacheCityName = lruCache.getIfPresent(cityIdStr);
if (cacheCityName != null) {
// 缓存命中，直接返回关联结果
Order order = new Order();
order.setCityId(cityId);
order.setItems(items);
order.setUserName(userName);
order.setCityName(cacheCityName);
resultFuture.collect(order);
return;
}
// 2. 缓存未命中，异步查询HBase维表
hbaseClient.get(new GetRequest(HBASE_TABLE, cityIdStr))
.addCallback((List<KeyValue> arg) -> {
// 回调函数：HBase查询完成后执行
for (KeyValue kv : arg) {
String cityName = new String(kv.value());
// 构建关联后的订单数据
Order order = new Order();
order.setCityId(cityId);
order.setItems(items);
order.setUserName(userName);
order.setCityName(cityName);
// 发送结果
resultFuture.collect(order);
// 将查询结果存入LRU缓存，供后续使用
lruCache.put(cityIdStr, cityName);
}
return null;
});
}
/**
* 关闭方法：释放客户端和缓存资源
*/
@Override
public void close() throws Exception {
super.close();
if (hbaseClient != null) {
hbaseClient.shutdown(); // 关闭HBase异步客户端
}
if (lruCache != null) {
lruCache.invalidateAll(); // 清空缓存
}
}
}
4.4 注意事项
-
异步 IO 使用：必须搭配异步客户端（如 HBase 异步客户端），若无异步客户端，可自行创建线程池模拟异步请求，避免同步等待；
-
缓存配置：根据业务场景合理设置缓存容量和过期时间，平衡内存消耗与数据延迟；
-
异常处理：需添加回调异常处理逻辑，避免 HBase 查询失败导致任务阻塞；
-
适用场景：维表数据量大、存在明显冷热数据区分，且实时性要求中等的场景。
五、其他衍生方案
除上述三种核心方案外，可根据业务需求衍生出多种维表关联方式，主要包括：
-
维表广播：将维表数据封装为广播流，与原始数据流进行广播连接，适用于维表数据量小、更新频率低的场景，可避免重复查询；
-
自定义异步线程池：通过创建自定义线程池，模拟异步请求，解决无异步客户端的外部系统关联问题；
-
Flink SQL 扩展：扩展 Flink SQL 的维表关联功能，直接使用 SQL Join 语法关联外部维表（如 MySQL、HBase），简化开发流程，适用于 SQL 化开发场景。
六、方案选型建议
维表关联方案的选型需结合业务场景，核心关注三个维度：维表数据量、实时性要求、外部系统性能，具体建议如下：
-
实时性要求极高、维表数据量小 → 实时查询维表；
-
实时性要求低、维表数据量小 → 预加载全量数据；
-
实时性要求中等、维表数据量大、存在冷热数据 → LRU 缓存（搭配异步 IO）；
-
SQL 化开发、维表数据量适中 → Flink SQL 扩展维表关联；
-
维表数据量小、更新频率低 → 维表广播。
总体而言，各类方案可相互结合衍生新的解决方案，核心是从业务本身出发，平衡数据实时性、系统性能和开发复杂度。
2629
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
