一、背景
在数据治理时，经常会遇到个性化统计分析的场景：基于数据的某些属性进行组合筛选，只有符合条件的数据才进行统计分析。
传统的实现方式是：业务人员提供筛选条件，数据开发人员在ETL任务直接开发。这种方式主要有两个痛点：
- 需求上线周期长
开发人员须对ETL任务进行开发调试、发布上线，按天、周、月排期都有可能。 - 统计口径不直观
筛选条件都在ETL任务中，业务人员无法直观判断数据是否符合预期，往往在数据量波动比较明显的时候才会发现异常。
为了解决这些问题，数据治理平台提供了给数据打标签的功能：业务人员在数据治理平台上快速批量对数据打上个性化标签，数据开发人员只须筛选打上特定标签的数据，而无须直接对数据进行过滤筛选。通过这种方式，可以解决需求上线周期长、统计口径不直观的问题。
- 数据开发人员只须一次性开发ETL任务，基于标签进行数据筛选即可，具体的数据筛选交由业务人员在数据治理平台上操作。
- 业务人员在数据治理平台上面可以直观查看须统计的数据，可视化管理数据统计口径。
随着数据量的不断增长，单靠业务人员人工管理标签的工作会变得越来越繁琐：给10条数据打标签业务人员还可以接受，但要给成千上万条数据打标签时，正常人都会抗拒这种操作了。
所以基于规则自动给数据打标签的需求，自然就会提上议程。当业务人员需要的筛选条件简单时，数据治理平台可以快速开发功能进行支持，但随着业务的发展，筛选条件会变得越来越复杂。
为了支持这些条件，平台功能会变得越来越臃肿，而且还需要投入开发人力排期开发，无法快速满足日新月异的业务需求。
因此，经过调研之后，决定引入规则引擎Aviator，平台基于规则引擎提供可视化配置功能，由业务人员进行自定义配置，平台根据业务配置自动匹配符合条件的数据，打上对应的标签。
本文不涉及规则引擎的调研过程，相关规则引擎的优劣对比不在本文讨论范围。本文主要介绍规则引擎Aviator的基础语法，以及在数据治理中的使用实践。
二、规则引擎Aviator
2.1 简介
Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎，主要用于各种表达式的动态求值。
官方地址：https://github.com/killme2008/aviatorscript
用户手册：https://www.yuque.com/boyan-avfmj/aviatorscript/cpow90
2.2 关键函数介绍
这里主要介绍关键函数：
字符串函数
| 函数名称 | 说明 |
|---|---|
| string.contains(s1,s2) | 判断 s1 是否包含 s2,返回 Boolean |
Sequence 函数（集合处理）
| 函数名称 | 说明 |
|---|---|
| seq.set(p1, p2, p3, …) | 创建一个 java.util.HashSet 实例，添加参数到这个集合并返回。 |
| seq.contains_key(map, key) | 当 map 中存在 key 的时候（可能为 null），返回 true。对于数组和链表，key 可以是 index，当 index 在有效范围[0…len-1]，返回 true，否则返回 false |
| include(seq,element) | 判断 element 是否在集合 seq 中,返回 boolean 值，对于 java.uitl.Set 是 O(1) 时间复杂度，其他为 O(n) |
| seq.every(seq, fun) | fun 接收集合的每个元素作为唯一参数，返回 true 或 false。当集合里的每个元素调用 fun 后都返回 true 的时候，整个调用结果为 true，否则为 false。 |
| seq.not_any(seq, fun) | fun 接收集合的每个元素作为唯一参数，返回 true 或 false。当集合里的每个元素调用 fun 后都返回 false 的时候，整个调用结果为 true，否则为 false。 |
| seq.some(seq, fun) | fun 接收集合的每个元素作为唯一参数，返回 true 或 false。当集合里的只要有一个元素调用 fun 后返回 true 的时候，整个调用结果立即为该元素，否则为 nil。 |
示例：
// 数据字段名与字段值的映射，字段值有可能为多个，所以统一为数组形式，方便处理
Map<String, List<String>> propNameValueMap = new HashMap<>(1);
tag.put("tagName", Arrays.asList("选项1", "选项4"));
// Aviator输入参数
Map<String, Object> env = new HashMap<>(1);
env.put("tag", propNameValueMap);
// Aviator表达式，判断Aviator输入参数中是否有指定属性
String checkPropExpression = "seq.contains_key( tag, 'tagName')";
// Aviator表达式，生成符合预期的选项值集合
String expectedValueExpression = "seq.set('选项1','选项2','选项3')";
// Aviator表达式，生成一个匿名函数，判断字段取值X是否在选项值集合中
String includeFunc = "lambda(x) -> include( seq.set('选项1','选项2','选项3'), x )";
// 数据字段值任意一个符合筛选条件即可：通过 seq.some 函数遍历字段取值，只要任意一个字段取值在选项值集合中即返回true
// 结果：true
System.out.println(AviatorEvaluator.execute("( seq.contains_key( tag, 'tagName') && seq.some( tag.tagNameCn, lambda(x) -> include( seq.set('选项1','选项2','选项3'), x ) end ) != nil )", env));
// 数据字段值全部符合筛选条件：通过 seq.every 函数，遍历字段取值，当且仅当所有字段取值都在选项值集合中才会返回true
// 结果：false
System.out.println(AviatorEvaluator.execute("( seq.contains_key( tag, 'tagName') && seq.every( tag.tagName, lambda(x) -> include( seq.set('选项1','选项2','选项3'), x ) end ) )", env));
// 数据字段值完全不符合筛选条件：通过 seq.not_any 函数，遍历字段取值，当且仅当所有字段取值都不在选项值集合中才会返回true
// 结果：false
System.out.println(AviatorEvaluator.execute("( seq.contains_key( tag, 'tagName') && seq.not_any( tag.tagName, lambda(x) -> include( seq.set('选项1','选项2','选项3'), x ) end ) )", env));
// Aviator表达式，生成一个匿名函数，判断数据字段值是否包含特定的选项值。注意：若选项值有多个，则字段值当中必须包含所有的选项值。
// 比如特定的选项值为两个：“人杰”、“鬼雄”，则字符串“生当作人杰，死亦为鬼雄”是符合要求的；若选项值变成三个“人杰”，“鬼雄”，“英雄”时，则字符串“生当作人杰，死亦为鬼雄”不再符合要求，因为少了“英雄”
String containFunc = "lambda(x) -> seq.every( seq.set('选项1'), lambda(v) -> string.contains(x, v) end )";
// 数据字段值全部包含特定选项值
// 结果：false。因为字段的第二个取值“选项2”不包含字符串“选项1”
System.out.println(AviatorEvaluator.execute("( seq.contains_key( tag, 'tagName') && seq.every( tag.tagName, lambda(x) -> seq.every( seq.set('选项1'), lambda(v) -> string.contains(x, v) end ) end ) )", env));
三、规则定义
3.1 数据匹配
目前业务侧暂只需要对数据进行匹配，不涉及数据计算。
因此基于常见的用户场景，数据治理平台抽象出两种运算符：比较运算符、范围运算符。
- 比较运算符
定义如何比较字段取值与预期值。平台目前提供了三种比较方式：等于，不等于，包含。
- 范围运算符
由于字段取值与预期值都可能是多个，统一以数组形式存储数据，通过比较运算符得到每个字段值与预期值的比较结果后，须通过范围运算符定义多个比较结果如何进行组合运算，得到最终结果。平台目前提供了三个运算符：任意符合，全部符合，完全不符合。
示例：
| 字段取值 | 比较运算符 | 范围运算符 | 预期值 | 匹配结果 | 说明 |
|---|---|---|---|---|---|
[选项1, 选项4] | 等于 | 任意符合 | [选项1, 选项2, 选项3] | true | 只要字段取值任意一个在预期值当中，即为true。选项1在预期值中，所以为true。 |
[选项1, 选项4] | 等于 | 全部符合 | [选项1, 选项2, 选项3] | false | 当且仅当字段取值全部在预期值当中，才为true。选项4不在预期值中，所以为false。 |
[选项1, 选项4] | 等于 | 完全不符合 | [选项1, 选项2, 选项3] | false | 当且仅当字段取值全部不在预期值当中，才为true。选项1在预期值中，所以为false。 |
[选项1, 选项4] | 不等于 | 任意符合 | [选项1, 选项2, 选项3] | true | 只要字段取值任意一个不在预期值当中，即为true。选项4不在预期值中，所以为true。 |
[选项1, 选项4] | 不等于 | 全部符合 | [选项1, 选项2, 选项3] | false | 当且仅当字段取值全部不在预期值当中，才为true。选项1在预期值中，所以为false。 |
[选项1, 选项4] | 不等于 | 完全不符合 | [选项1, 选项2, 选项3] | false | 当且仅当字段取值全部都在预期值当中，才为true。选项4不在预期值中，所以为false。 |
["生当作人杰，死亦为鬼雄", "英雄难过美人关"] | 包含 | 任意符合 | [人杰, 鬼雄] | true | 只要字段取值任意一个包含所有的预期值，即为true。第一个字段取值包含了所有预期值，所以为true。 |
["生当作人杰，死亦为鬼雄", "英雄难过美人关"] | 包含 | 全部符合 | [人杰, 鬼雄] | false | 当且仅当所有的字段取值都包含所有的预期值，即为true。第二个字段取值不包含预期值，所以为false。 |
["生当作人杰，死亦为鬼雄", "英雄难过美人关"] | 包含 | 完全不符合 | [人杰, 鬼雄] | false | 当且仅当所有字段取值都不包含所有的预期值，即为true。第一个字段取值包含了所有预期值，所以为false。 |
3.2 业务逻辑
数据匹配只能针对单个字段，业务往往需要针对多个字段进行组合排列，根据多个字段的匹配结果进行取舍。
因此数据治理平台提供了逻辑运算符，对多个字段的匹配结果进行与或运算。
- 逻辑运算符
定义如何将多个字段的匹配结果进行与或运算，得到最终匹配结果。平台提供了两个运算符：与，或。
3.3 规则参数
基于数据匹配与业务逻辑，数据治理平台抽象出以下数据结构，方便业务进行个性化配置：
/**
* 标签规则条件，指定各表达式之间的逻辑关系
*
* @author chriscchen
* @createtime 2022-07-30
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
@JsonInclude(Include.NON_EMPTY)
@JsonIgnoreProperties(ignoreUnknown = true)
public class TagRuleCondition {
/**
* 逻辑运算符，定义如何将规则条件与规则表达式进行与或运算 {@link LogicOperator}
*/
private String logic;
/**
* 嵌套的规则条件。当需要对多个字段进行组合排列时，须嵌套规则条件。
*/
private List<TagRuleCondition> conditions;
/**
* 规则表达式，可直接对字段进行数据匹配
*/
private List<TagRuleExpression> expressions;
}
/**
* 标签规则表达式
*
* @author chriscchen
* @createtime 2022-07-30
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
@JsonInclude(Include.NON_EMPTY)
@JsonIgnoreProperties(ignoreUnknown = true)
public class TagRuleExpression {
/**
* 字段名
*/
private String name;
/**
* 比较运算符 {@link CompareOperator}
*/
private String comparator;
/**
* 范围运算符 {@link ScaleOperator}
*/
private String scale;
/**
* 预期值
*/
private List<Object> value;
}
示例：
假设有2条数据如下：
| 名称 | 状态 | 分类 | 厂商 |
|---|---|---|---|
| 飞天 | 销售中 | 酱香型 | 茅台 |
| 五粮液 | 销售中 | 浓香型 | 五粮液 |
需要筛选状态为销售中，并且分类为酱香型的数据，生成的数据结构如下：
{
"logic": "AND",
"expressions": [
{
"name": "状态",
"comparator": "=",
"scale": "any",
"value": [
"销售中"
]
},
{
"name": "分类",
"comparator": "=",
"scale": "any",
"value": [
"酱香型"
]
}
]
}
3.4 表达式转换
基于3.3节的数据结构，参考2.2节的示例，生成Aviator表达式
/**
* 根据用户配置的规则条件，生成Aviator的表达式
*
* @param condition 用户配置的规则条件
* @param keyPrefix 有嵌套属性时，需要加上属性前缀
* @return Aviator的表达式
*/
private static String convertToAviatorExpression(TagRuleCondition condition, String keyPrefix)
throws AbstractDataMapException {
if (condition == null) {
throw new CommonParamUnacceptableException("标签的规则条件不能为空");
}
if (StringUtils.isBlank(condition.getLogic())) {
throw new CommonParamMissedException("缺少逻辑运算符，请检查参数：logic");
}
List<String> aviatorExpressions = new ArrayList<>();
// 嵌套的规则条件。当需要对多个字段进行组合排列时，须嵌套规则条件
if (CollectionUtils.isNotEmpty(condition.getConditions())) {
for (TagRuleCondition subCondition : condition.getConditions()) {
aviatorExpressions.add(convertToAviatorExpression(subCondition, keyPrefix));
}
}
// 规则表达式，可直接对字段进行数据匹配
if (CollectionUtils.isNotEmpty(condition.getExpressions())) {
for (TagRuleExpression expression : condition.getExpressions()) {
String valueSet = generateValueSetExpression(expression);
// 检查属性是否存在
String check = "seq.contains_key( " + keyPrefix + expression.getType()
+ ", '" + expression.getName() + "')";
// 属性字段名
String propValue = keyPrefix + expression.getType() + "." + expression.getName();
generateTagExpression(aviatorExpressions, expression, valueSet, check, propValue);
}
}
switch (condition.getLogic()) {
case LogicOperator.AND:
return StringUtils.join(aviatorExpressions, " && ");
case LogicOperator.OR:
return StringUtils.join(aviatorExpressions, " || ");
default:
throw new CommonParamUnacceptableException(
"未知逻辑运算符，请检查参数：" + condition.getLogic());
}
}
/**
* 基于用户配置的规则表达式，生成预期值表达式
*
* @param expression 用户配置的规则表达式
* @return 预期值表达式
*/
private static String generateValueSetExpression(TagRuleExpression expression) {
List<Object> value = expression.getValue();
String valueSet;
if (CollectionUtils.isEmpty(value)) {
valueSet = "seq.set()";
} else {
Object elem = value.get(0);
if (elem instanceof String) {
// 字符串加上引号
valueSet = "seq.set('" + StringUtils.join(value, "','") + "')";
} else {
// 其余类型直接拼接
valueSet = "seq.set(" + StringUtils.join(value, ",") + ")";
}
}
return valueSet;
}
/**
* 生成标签类型的Aviator表达式
*
* @param aviatorExpressions 生成的Aviator表达式，添加到此数组中
* @param expression 用户配置的规则表达式数据结构
* @param valueSet 提前生成的预期值集合表达式
* @param check 提前生成的检测属性存在的表达式
* @param propValue 属性字段名
* @throws AbstractDataMapException exception
*/
private static void generateTagExpression(List<String> aviatorExpressions,
TagRuleExpression expression, String valueSet, String check, String propValue)
throws AbstractDataMapException {
if (StringUtils.isBlank(expression.getComparator())) {
throw new CommonParamMissedException("缺少比较运算符，请检查参数：operation");
}
if (StringUtils.isBlank(expression.getScale())) {
throw new CommonParamMissedException("缺少范围运算符，请检查参数：scale");
}
switch (expression.getComparator()) {
case CompareOperator.E: {
generateTagEqualExpression(aviatorExpressions, expression, valueSet, check, propValue);
break;
}
case CompareOperator.NE: {
generateTagNotEqualExpression(aviatorExpressions, expression, valueSet, check, propValue);
break;
}
case CompareOperator.CONTAIN: {
generateTagContainExpression(aviatorExpressions, expression, valueSet, check, propValue);
break;
}
default: {
throw new CommonParamUnacceptableException(
"未知比较运算符，请检查参数：" + expression.getComparator());
}
}
}
/**
* 生成标签类型 “等于” 的Aviator表达式
*
* @param aviatorExpressions 生成的Aviator表达式，添加到此数组中
* @param expression 用户配置的规则表达式数据结构
* @param valueSet 提前生成的预期值集合表达式
* @param check 提前生成的检测属性存在的表达式
* @param propValue 属性字段名
* @throws AbstractDataMapException exception
*/
private static void generateTagEqualExpression(List<String> aviatorExpressions,
TagRuleExpression expression, String valueSet, String check, String propValue)
throws AbstractDataMapException {
switch (expression.getScale()) {
case ScaleOperator.ANY: {
aviatorExpressions.add("( " + check + " && seq.some( " + propValue
+ ", lambda(x) -> include( " + valueSet + ", x ) end ) != nil )");
break;
}
case ScaleOperator.ALL: {
aviatorExpressions.add("( " + check + " && seq.every( " + propValue
+ ", lambda(x) -> include( " + valueSet + ", x ) end ) )");
break;
}
case ScaleOperator.NONE: {
aviatorExpressions.add("( " + check + " && seq.not_any( " + propValue
+ ", lambda(x) -> include( " + valueSet + ", x ) end ) )");
break;
}
default:
throw new CommonParamUnacceptableException(
"未知范围运算符，请检查参数：" + expression.getScale());
}
}
/**
* 生成标签类型 “不等于” 的Aviator表达式
*
* @param aviatorExpressions 生成的Aviator表达式，添加到此数组中
* @param expression 用户配置的规则表达式数据结构
* @param valueSet 提前生成的预期值集合表达式
* @param check 提前生成的检测属性存在的表达式
* @param propValue 属性字段名
* @throws AbstractDataMapException exception
*/
private static void generateTagNotEqualExpression(List<String> aviatorExpressions,
TagRuleExpression expression, String valueSet, String check, String propValue)
throws AbstractDataMapException {
switch (expression.getScale()) {
case ScaleOperator.ANY: {
aviatorExpressions.add("( " + check + " && seq.some( " + propValue
+ ", lambda(x) -> include( " + valueSet + ", x ) == false end ) != nil )");
break;
}
case ScaleOperator.ALL: {
aviatorExpressions.add("( " + check + " && seq.not_any( " + propValue
+ ", lambda(x) -> include( " + valueSet + ", x ) end ) )");
break;
}
case ScaleOperator.NONE: {
aviatorExpressions.add("( " + check + " && seq.every( " + propValue
+ ", lambda(x) -> include( " + valueSet + ", x ) end ) )");
break;
}
default:
throw new CommonParamUnacceptableException(
"未知范围运算符，请检查参数：" + expression.getScale());
}
}
/**
* 生成标签类型 “包含” 的Aviator表达式
*
* @param aviatorExpressions 生成的Aviator表达式，添加到此数组中
* @param expression 用户配置的规则表达式数据结构
* @param valueSet 提前生成的预期值集合表达式
* @param check 提前生成的检测属性存在的表达式
* @param propValue 属性字段名
* @throws AbstractDataMapException exception
*/
private static void generateTagContainExpression(List<String> aviatorExpressions,
TagRuleExpression expression, String valueSet, String check, String propValue)
throws AbstractDataMapException {
switch (expression.getScale()) {
case ScaleOperator.ANY: {
aviatorExpressions.add("( " + check + " && seq.some( " + propValue
+ ", lambda(x) -> seq.every( " + valueSet
+ ", lambda(v) -> string.contains(x, v) end ) end ) != nil )");
break;
}
case ScaleOperator.ALL: {
aviatorExpressions.add("( " + check + " && seq.every( " + propValue
+ ", lambda(x) -> seq.every( " + valueSet
+ ", lambda(v) -> string.contains(x, v) end ) end ) )");
break;
}
case ScaleOperator.NONE: {
aviatorExpressions.add("( " + check + " && seq.not_any( " + propValue
+ ", lambda(x) -> seq.every( " + valueSet
+ ", lambda(v) -> string.contains(x, v) end ) end ) )");
break;
}
default:
throw new CommonParamUnacceptableException(
"未知范围运算符，请检查参数：" + expression.getScale());
}
}
3.5 数据转换
规则引擎Aviator需要将数据转换为Map<String, Object>类型，作为输入参数。
// 生成原始数据
Map<String, Object> rawData = new ObjectMapper().convertValue(record, new TypeReference<Map<String, Object>>() {});
// 字段名与字段取值的映射 { propName -> [ propValue ] }，字段取值统一以数组形式
Map<String, Object> nameValueMap = new HashMap<>(rawData.size()));
rawData.forEach((key, value) -> tagNameValueMap.put(key, Collections.singletonList(value)));
3.6 规则匹配
// 预编译表达式，提高效率
Expression aviatorExpression;
try {
aviatorExpression = AviatorEvaluator.compile("...");
} catch (Exception e) {
throw new CommonParamUnacceptableException("规则异常，请检查：" + e.getMessage(), e);
}
// 匹配数据
Boolean result = (Boolean) aviatorExpression.execute(nameValueMap);
四、总结
基于规则引擎Aviator开发的自定义规则功能，既能让业务直接进行个性化规则配置，快速对匹配的数据打标签，也极大解放了平台开发的人力，从重复乏味的定制化功能开发抽身出来，为业务实现更有价值的功能。
本文只介绍自定义规则功能中的核心处理模块，还须基于数据结构进行前端开发，支持可视化配置，不再一一展开。
扫一扫
873
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
