这款轻量级规则引擎,真香!!

规则引擎(JVS-rules):从应用到场景的全面解析 JVS-RULES规则引擎是一款可视化的业务规则设计器,它的核心功能在于可集成多种数据源,包括多种类型数据库和API,将数据进行界面可视化的加工处理后,形成策略节点所需要的各种变量,然后通过规则的可视化编排,形成各种决策场景,让业务系统可以快速简单的调用,在线实时获得业务决策结果。 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

31981d71ba9628331291eb977cd876db.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号等等功能:

  • Boot 地址:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 地址:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

来源:三分恶


之前看到同事用了一款轻量级的规则引擎脚本AviatorScript ,我也跟着用了起来,真的挺香,能少写很多代码。这期就给大家介绍一下这款规则引擎。

简介

AviatorScript 是一门高性能、轻量级寄宿于 JVM (包括 Android 平台)之上的脚本语言。

它起源于2010年,作者对当时已有的一些产品不是很满意,所以自己撸了一个,它是Groovy的一个定制化的子集。

ae21886927165c5235e04723ce0bc4fc.png

相比较一些传统的规则引擎,比如Drools、Jess、JRules,它更加轻量级,而且性能更好,同时能力开放,扩展很方便。

我们来看(吹)看(吹)AviatorScript的特点:

  1. 它支持数字、字符串、正则表达式、布尔值等基本类型,并且可以使用所有 Java 运算符进行运算。

  2. 还有一个内置的东西叫做 bigint 和 decimal,可以处理超大整数和高精度运算。而且我们还可以通过运算符重载让它们使用普通的算术运算符 +-*/。

  3. 语法非常齐全,可以用它来写多行数据、条件语句、循环语句,还能处理词法作用域和异常处理等等。

  4. 如果我们喜欢函数式编程,还有一个叫做 Sequence 抽象的东西,可以让你更方便地处理集合。

  5. 还有一个轻量化的模块系统,方便我们组织代码。

  6. 如果我们需要调用 Java 方法,也没问题,可以用多种方式方便地调用 Java 方法,还有一个完整的脚本 API可以让你从 Java 调用脚本。

  7. 性能也是超出想象的好,如果使用 ASM 模式,它会直接将脚本翻译成 JVM 字节码,解释模式还可以在 Android 等非标准 Java 平台上运行。

AviatorScript可以用在各种场景,比如规则判断和规则引擎、公式计算、动态脚本控制,甚至集合数据 ELT 等等。可以说相当全能了。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

快速开始

AviatorScript 是一门寄生在 JVM (Hosted on the JVM)上的语言,类似 clojure/scala/kotlin 等等,我们从写个Hello World开始。

  • 创建一个SpringBoot项目,引入依赖,这里选择的是最新版本

<dependency>
            <groupId>com.googlecode.aviator</groupId>
            <artifactId>aviator</artifactId>
            <version>5.3.3</version>
        </dependency>

PS:可以看到aviator的groupId有一个googlecode,但是它和Google可没什么关系,这是因为早期aviator托管在Google的一个开源项目托管平台Google Code。

  • 在项目的resource目录下创建一个目录script,在script目录下创建脚本hello.av

println("Hello, AviatorScript!");
  • 编写一个单元测试,运行脚本

@Test
    void testHello() throws Exception {
        //获取路径
        ClassPathResource resource = new ClassPathResource("script/hello.av");
        String scriptPath = resource.getPath();
        //编译
        Expression exp = AviatorEvaluator.getInstance().compileScript(scriptPath);
        //执行
        exp.execute();
    }

最后执行一下,就可以看到输出:

Hello, AviatorScript!
  • 我们也可以直接把脚本定义成字符串,用compile()来进行编译

@Test
    void testHelloStr() throws Exception {
        //定义脚本
        String script="println(\"Hello, AviatorScript!\");";
        //编译
        Expression exp = AviatorEvaluator.getInstance().compile(script);
        //执行
        exp.execute();
    }

AviatorScript有一个Idea插件,支持直接编译运行Aviator脚本,比较方便。

2eb9d5d25cd778d4cd893f0d5550ec66.pngAviator插件

但不足之处,这个插件已经不怎么维护了,只兼容到了Idea2021版本。

e478a5be809bdd2ff7f9b202f2715c76.pngIdea插件

AviatorScript脚本的运行,分为两步,编译和执行。

2c13a93014fdc47b9e2cace09f384aef.png编译执行

编译支持编译脚本文件和脚本文本,分别使用compileScript和compile方法。

编译产生的  Expression 对象,最终都是调用 execute() 方法执行。

这里有个重要能力,execute 方法可以接受一个变量列表组成的 map,来注入执行的上下文:

String expression = "a-(b-c) > 100";
        Expression compiledExp = AviatorEvaluator.compile(expression);
        //上下文
        double a=100.3,b=45,c= -199.100;
        Map<String, Object> context=new HashMap<>();
        context.put("a",a);
        context.put("b",b);
        context.put("c",c);
        //通过注入的上下文执行
        Boolean result = (Boolean) compiledExp.execute(context);
        System.out.println(result);

我们实现一些规则的判断就是基于这个能力,把一些参数下上下文传进去,然后进行逻辑判断。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

基本语法

我们在来看看AviatorScript的基本语法,它的语法相当简洁,比较接近于数学表达式的形式。

基本类型及运算

AviatorScript 支持常见的类型,如数字、布尔值、字符串等等,同时将大整数、BigDecimal、正则表达式也作为一种基本类型来支持。

数字

AviatorScript 支持数字类型,包括整数和浮点数,以及高精度计算(BigDecimal)。数字类型可以进行各种算术运算。

整数和算术运算

整数类型,对应Java中的long类型,可以表示范围为 -9223372036854774808 ~ 9223372036854774807 的整数。整数可以使用十进制或十六进制表示。

let a = 99;
let b = 0xFF;
let c = -99;

println(a + b); // 270
println(a / b); // 0
println(a - b + c); // -156
println(a + b * c); // -9801
println(a - (b - c)); // 198
println(a / b * b + a % b); // 99

整数可以进行加减乘除和取模运算。需要注意的是,整数相除的结果仍然是整数,遵循整数运算规则。可以使用括号来指定运算的优先级。

浮点数

浮点数类型对应Java中的double类型,表示双精度 64 位浮点数。浮点数可以使用十进制或科学计数法表示。

let a = 1.34159265;
let b = 0.33333;
let c = 1e-2;

println(a + b); // 1.67492265
println(a - b); // 1.00826265
println(a * b); // 0.4471865500145
println(a / b); // 4.0257402772554
println(a + c); // 1.35159265

浮点数可以进行加减乘除运算,结果仍然为浮点数。

高精度计算(Decimal)

高精度计算使用 BigDecimal 类型,可以进行精确的数值计算,适用于货币运算或者物理公式运算的场景。可以通过在数字后面添加 "M" 后缀来表示 BigDecimal 类型。

let a = 1.34M;
let b = 0.333M;
let c = 2e-3M;

println(a + b); // 1.673M
println(a - b); // 1.007M
println(a * b); // 0.44622M
println(a / b); // 4.022022022M
println(a + c); // 1.342M

BigDecimal 类型可以进行加减乘除运算,结果仍然为 BigDecimal 类型。默认的运算精度是 MathContext.DECIMAL128,可以通过修改引擎配置项 Options.MATH_CONTEXT 来改变。

数字类型转换

数字类型在运算时会自动进行类型转换:

  • 单一类型参与的运算,结果仍然为该类型。

  • 多种类型参与的运算,按照 long -> bigint -> decimal -> double 的顺序自动提升,结果为提升后的类型。

可以使用 long(x) 函数将数字强制转换为 long 类型,使用 double(x) 函数将数字强制转换为 double 类型。

let a = 1;
let b = 2;

println("a/b is " + a/b); // 0
println("a/double(b) is " + a/double(b)); // 0.5

a 和 b 都是 long 类型,它们相除的结果仍然是整数。使用 double(b) 将 b 转换为 double 类型后,相除的结果为浮点数。

字符串

字符串类型由单引号或双引号括起来的连续字符组成。可以使用 println 函数来打印字符串。

let a = "hello world";
println(a); // hello world

字符串的长度可以通过 string.length 函数获取。

let a = "hello world";
println(string.length(a)); // 11

字符串可以通过 + 运算符进行拼接。

let a = "hello world";
let b = "AviatorScript";
println(a + ", " + b + "!" + 5); // hello world, AviatorScript!5

字符串还包括其他函数,如截取字符串 substring,都在 string 这个 namespace 下,具体见函数库列表。

布尔类型和逻辑运算

布尔类型用于表示真和假,它只有两个值 true 和 false 分别表示真值和假值。

比较运算如大于、小于可以产生布尔值:

println("3 > 1 is " + (3 > 1));  // 3 > 1 is true
println("3 >= 1 is " + (3 >= 1));  // 3 >= 1 is true
println("3 >= 3 is " + (3 >= 3));  // 3 >= 3 is true
println("3 < 1 is " + (3 < 1));  // 3 < 1 is false
println("3 <= 1 is " + (3 <= 1));  // 3 <= 1 is false
println("3 <= 3 is " + (3 <= 3));  // 3 <= 3 is true
println("3 == 1 is " + (3 == 1));  // 3 == 1 is false
println("3 != 1 is " + (3 != 1));  // 3 != 1 is true

上面演示了所有的逻辑运算符:

  • > 大于

  • >= 大于等于

  • < 小于

  • <= 小于等于

  • == 等于

  • != 不等于

基本语法

AviatorScript也支持条件语句和循环语句。

条件语句

AviatorScript 中的条件语句和其他语言没有太大区别:

  • if

if(true) {
   println("in if body");
}
  • if-else

if(false){
   println("in if body");
} else {
   println("in else body");
}
  • if-elsif-else

let a = rand(1100);

if(a > 1000) {
  println("a is greater than 1000.");
} elsif (a > 100) {
  println("a is greater than 100.");
} elsif (a > 10) {
   println("a is greater than 10.");
} else {
   println("a is less than 10 ");
}
循环语句

AviatorScript提供了两种循环语句:for和while。

for循环:遍历集合

for ... in 语句通常用于遍历一个集合,例如下面是遍历 0 到 9 的数字

for i in range(0, 10) {
  println(i);
}

在这里,range(start, end) 函数用于创建一个整数集合,包括起始值 start,但不包括结束值 end。在循环迭代过程中,变量 i 绑定到集合中的每个元素,并执行大括号 {...} 中的代码块。

range 函数还可以接受第三个参数,表示递增的步长大小(默认步长为 1)。例如,我们可以打印出0到9之间的偶数:

for i in range(0, 10, 2) {
  println(i);
}

for .. in 可以用于任何集合结构,比如数组、 java.util.List 、 java.util.Map 等等。

while循环

while 循环本质上是将条件语句与循环结合在一起。当条件为真时,不断执行一段代码块,直到条件变为假。

例如,下面的示例中,变量 sum 从 1 开始,不断累加自身,直到超过 1000 才停止,然后进行打印输出:

let sum = 1;

while sum < 1000 {
  sum = sum + sum;
}

println(sum);

循环可以用这三个关键字结束——continue/break/return :

  • continue用于跳过当前迭代,继续下一次迭代。

  • break用于跳出整个循环。

  • return用于中断整个脚本(或函数)的执行并返回。

函数

我们再来看看AviatorScript一个非常重要的特性——函数。

函数
函数定义和调用

AviatorScript中使用fn语法来定义函数:

fn add(x, y) {
  return x + y;
}

three = add(1, 2);
println(three);  // 输出:3

s = add('hello', ' world');
println(s);  // 输出:hello world

我们这里通过fn关键字来定义了一个函数,函数名为add,它接受两个参数x和y,并返回它们的和。

需要注意的是,AviatorScript是动态类型系统,不需要定义参数和返回值的类型,它会根据实际传入和返回的值进行自动类型转换。因此,我们可以使用字符串来调用add函数。

函数的返回值可以通过return语句来指定,也可以省略不写。在函数体内,如果没有明确的return语句,最后一个表达式的值将被作为返回值。

自定义函数

再来给大家介绍一个AviatorScript里非常好的特性,支持自定义函数,这给AviatorScript带来了非常强的扩展性。

可以通过 java 代码实现并往引擎中注入自定义函数,在 AviatorScript 中就可以使用,事实上所有的内置函数也是通过同样的方式实现的:

public class TestAviator {

    public static void main(String[] args) {
        //通通创建一个AviatorEvaluator的实例
        AviatorEvaluatorInstance instance = AviatorEvaluator.getInstance();
        //注册函数
        instance.addFunction(new AddFunction());
        //执行ab脚本,脚本里调用自定义函数
        Double result= (Double) instance.execute("add(1, 2)");
        //输出结果
        System.out.println(result);
    }
}

/**
 * 实现AbstractFunction接口,就可以自定义函数
 */
class AddFunction extends AbstractFunction {

    /**
     * 函数调用
     * @param env 当前执行的上下文
     * @param arg1 第一个参数
     * @param arg2 第二个参数
     * @return 函数返回值
     */
    @Override
    public AviatorObject call(Map<String, Object> env,
                              AviatorObject arg1, AviatorObject arg2) {
        Number left = FunctionUtils.getNumberValue(arg1, env);
        Number right = FunctionUtils.getNumberValue(arg2, env);
        //将两个参数进行相加
        return new AviatorDouble(left.doubleValue() + right.doubleValue());
    }

    /**
     * 函数的名称
     * @return 函数名
     */
    public String getName() {
        return "add";
    }
}

我们看到:

  • 继承AbstractFunction类,就可以自定义一个函数

  • 重写call方法,就可以定义函数的逻辑,可以通过FunctionUtils获取脚本传递的参数

  • 通过getName可以设置函数的名称

  • 通过addFunction添加一个自定义函数类的实例,就可以注册函数

  • 最后就可以在Aviator的脚本里编译执行我们自定义的函数

好了,关于AviatorScript的语法我们就不过多介绍了,大家可以直接查看官方文档[1],可读性相当不错。

接下来我们就来看看AviatorScript的实际应用,看看它到底怎么提升项目的灵活性。

实战案例

标题带了规则引擎,在我们的项目里也主要是拿AviatorScript作为规则引擎使用——我们可以把AviatorScript的脚本维护在配置中心或者数据库,进行动态地维护,这样一来,一些规则的修改,就不用大动干戈地去修改代码,这样就更加方便和灵活了。

64370ba7efb08389fe5da1a63b518dfb.pngAviator应用

客户端版本控制

在日常的开发中,我们很多时候可能面临这样的情况,兼容客户端的版本,尤其是Android和iPhone,有些功能是低版本不支持的,或者说有些功能到了高版本就废弃掉,这时候如果硬编码去兼容就很麻烦,那么就可以考虑使用规则脚本的方式。

  • 自定义版本比较函数:AviatorScript没有内置版本比较函数,但是可以利用它的自定义函数特性,自己定义一个版本比较函数

class VersionFunction extends AbstractFunction {

        @Override
        public String getName() {
            return "compareVersion";
        }

        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
            // 获取版本
            String version1 = FunctionUtils.getStringValue(arg1, env);
            String version2 = FunctionUtils.getStringValue(arg2, env);
            int n = version1.length(), m = version2.length();
            int i = 0, j = 0;
            while (i < n || j < m) {
                int x = 0;
                for (; i < n && version1.charAt(i) != '.'; ++i) {
                    x = x * 10 + version1.charAt(i) - '0';
                }
                ++i; // 跳过点号
                int y = 0;
                for (; j < m && version2.charAt(j) != '.'; ++j) {
                    y = y * 10 + version2.charAt(j) - '0';
                }
                ++j; // 跳过点号
                if (x != y) {
                    return x > y ? new AviatorBigInt(1) : new AviatorBigInt(-1);
                }
            }
            return new AviatorBigInt(0);
        }
    }
  • 注册自定义函数:为了方便使用各种自定义函数,我们一般定义一个单例的AviatorEvaluatorInstance,把它注册成Bean

@Bean
    public AviatorEvaluatorInstance aviatorEvaluatorInstance() {
        AviatorEvaluatorInstance instance = AviatorEvaluator.getInstance();
        // 默认开启缓存
        instance.setCachedExpressionByDefault(true);
        // 使用LRU缓存,最大值为100个。
        instance.useLRUExpressionCache(100);
        // 注册内置函数,版本比较函数。
        instance.addFunction(new VersionFunction());
    }
  • 在代码里传递上下文:接下来,就可以在业务代码里将一些参数放进执行上下文,然然后进行编译执行,注意编译的时候最好要开启缓存,这样效率会高很多

/**
     * 
     * @param device 设备
     * @param version 版本
     * @param rule 规则脚本
     * @return
     */
    public boolean filter(String device,String version,String rule){
        // 执行参数
        Map<String, Object> env = new HashMap<>();
        env.put("device", device);
        //编译脚本
        Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
        //执行脚本
        boolean isMatch = (boolean) expression.execute(env);
        return isMatch;
    }
  • 编写脚本:接下来就可以编写和维护对应的规则脚本,这些规则脚本通常放在在配置中心或者数据库,方便进行动态变更

if(device==bil){
    return false;
}

## 控制android的版本
if (device=="Android" && compareVersion(version,"1.38.1")<0){
    return false;
}

return true;

这样一来,假如某天,客户端Bug或者产品原因,需要修改客户端和客户端的版本控制,直接修改脚本就好了。

甚至我们可以在env里放进更多参数,比如uid,可以实现简单的黑白名单。

我们的自定义函数除了这种简单的比较版本,我们还可以放一些复杂的逻辑,比如判断是否新用户等等。

营销活动规则

假如现在我们的运营希望进行一场营销活动,对用户进行一定的支付优惠,最开始的一版活动规则:

  • 满1000减200,满500减100

这个好写,一顿if-else就完事了。

但是没过几天,又改了活动规则:

  • 首单用户统一减20

好,啪啪改代码。

又过去几天,活动规则又改了:

  • 随机优惠不同金额

为了一些多变的营销规则,大动干戈,不停修改代码,耗时费力,那么不如用规则脚本实现:

  • 定义脚本

if (amount>=100){
    return 200;
}elsif(amount>=500){
    return 100;
}else{
    return 0;
}
  • 业务代码调用

public BigDecimal getDiscount(BigDecimal amount,String rule){
        // 执行规则并计算最终价格
        Map<String, Object> env = new HashMap<>();
        env.put("amount", amount);
        Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
        return  (BigDecimal) expression.execute();
    }

接下来,再发生营销规则变更,就可以少量开发(自定义函数,比如判断首单用户),并且可以组件化地维护营销规则。

订单风控规则

Aviator我在订单风控里应用也很香,风控的规则调整是相当频繁的,比如一个电商网站,常常要根据交易的争议率、交易表现等等,来收紧和放松风控规则,这就要求我们能对一风控规则进行快速地配置变更。

例如,根据订单金额、客户评级、收货地址等属性,自动判断是否有风险并触发相应的风控操作。

  • 规则脚本

if (amount>=1000 || rating <= 2){
    return "High";
}elsif(amount >= 500 || rating<=4){
    return "Mid";
}else{
    return "Low";
}
  • 代码调用:这里只是简单返回了一个风控等级,其实可以通过Map的方式返回多个参数。

public String riskLevel(BigDecimal amount,String rating,String rule){
        // 执行规则并计算最终价格
        Map<String, Object> env = new HashMap<>();
        env.put("amount", amount);
        env.put("rating", rating);
        Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
        return  (String) expression.execute();
    }

上面随手列出了几个简单的例子,AviatorScript 还可以用在一些审批流程、事件处理、数据质量管理等等场景……

在一些轻量级的需要规则引擎的场景下,AviatorScript 真的太香了,尤其是它的扩展性,支持通过Java自定义函数,我甚至可以在脚本里查询数据库、查询Redis、调用外部接口……这样就可以像搭积木一样搭建想要的功能。

总结

这一期给大家分享了一款轻量级的规则脚本语言AviatorScript,它的语法丰富,但是很轻量,并且支持非常灵活的扩展,在项目中使用可以有效提高业务的灵活性,降低开发的工作量。


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

defe1a1c3a5b04db83f9486fba5d037e.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

975a6e5eeb5a0812fff38fd65c96d6b9.png

1fb7a7ce157d34eeb57983c5fcbbab18.pnge746d203559e098cf78d79bf1ea343a5.png1caeb9c1cbe68b5a319a6a5d3e34675e.pngc7585b79a99374e5519d344d9a11c8ca.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
ruleEngine:可视化规则引擎 ruleEngine 可视化配置规则引擎 ui 框架 后端 采用spring cloud微服务架构 前端 vue npm install npm run dev skywalking apache-skywalking-apm-bin/bin/startup.sh 规则引擎 采用drool规则引擎 drool 将变量值放入hashmap,当作drool的输入fact 自定义dsl语法 [when][]lt = < [when][]le = <= [when][]ge = >= [when][]gt = > [when][]eq = == [when][]ne = != [when][]and = && [when][]or = || [when][]contains = contains [when][]notcontains = not contains [when]input {fie 立即下载

相关推荐

hge游戏引擎+angelscript游戏脚本(.as)的用法.zip

hge游戏引擎+angelscript游戏脚本(.as)的用法.zip

聊聊规则引擎的调研及实现全过程

目前相关的调研及前端部分的实施已经初步完成,相关实施按照过程及任务拆解已初步得到验证实施的可行性,这其中也考虑了比较多服务端因素,最终确定为react+java组合的形式,之所以没再坚持vue主因是该页相对比较独立,技术线统一其实没那么重要,优先以验证可行性及执行度为准则,另外一方面考量就是节点的属性编辑交互性较强,综合权衡之后还是决定背靠antd pro-compoment去加快这个实施过程。

cutsay的专栏 4588

地质工程师必备:Dips软件从数据导入到主结构面分析的完整流程解析

本文详细解析了地质工程师使用Dips软件进行主结构面分析的完整流程。从数据准备与导入、结构面分组与扇形区划分,到主结构面计算与工程解读,系统阐述了如何将野外节理数据转化为控制岩体稳定性的关键信息。重点介绍了利用等值线图识别优势组、计算统计主值及其置信椭圆,并强调了地质判断与工程应用结合的重要性。

table的专栏 342

验证码的破解思路!

研究了3天验证码破解!  尝试了好多种方法,都以失败告终!  不过最后还是在我不断的努力下!成功完成对验证码图片的数字化读取!  测试了一下,正确率在85%以上,还算不错!  总结一下自己的思路过程!  1.用PHP读取验证码图片上每个像素的色彩值!  2.将验证码边框上的色彩变为白色  3.用循环方法,去除背景上的色彩杂点,将数字部分的颜色改为000000  接着就是对图像的读取了!    (...

冯友华的专栏 744

深入解析Zynq Ultrascale+ RF Data Converter中的PLL配置与时钟管理

本文深入解析了Zynq Ultrascale+ RF Data Converter中PLL配置与时钟管理的核心原理与实践。文章将RFDC时钟系统比作交响乐团,详细阐述了PLL作为指挥的关键作用,以及系统时钟、Tile时钟、参考时钟与采样时钟的层级关系。重点剖析了PLL配置参数(如VCO频率、分频器设置)的计算方法与稳定性考量,并提供了从IP配置使能顺序到多Tile同步、DRP访问等常见问题的实战避坑指南与调试技巧,帮助工程师构建稳定的射频信号处理基石。

7up55的博客 452

Win10系统权限深度解析:如何安全地将C盘所有者从TrustedInstaller变更为Administrators

本文深入解析了Win10系统中C盘文件权限管理的核心机制,解释了为何管理员账户(Administrators)默认无法修改由TrustedInstaller保护的系统文件。文章在强调安全风险的前提下,详细提供了通过图形界面和命令行两种方式,将文件或文件夹所有权从TrustedInstaller安全变更为Administrators的实操步骤,并给出了关键的风险预警与权限恢复方法。

weixin_29305313的博客 550

URule规则引擎

前段时间,在做项目重构的时候,遇到很多地方需要做很多的条件判断。当然可以用很多的if-else判断去解决,但是当时也不清楚怎么回事,就像玩点别的。于是乎,就去调研了规则引擎。

【积累】,是一个长期持续的过程。 1331

利用Ghidra与SVD插件实现STM32固件深度逆向分析

本文详细介绍了如何利用Ghidra逆向工程框架结合SVD插件,实现对STM32固件(.bin文件)的深度逆向分析。通过加载描述芯片外设寄存器的SVD文件,Ghidra能将晦涩的硬件地址操作转换为可读的寄存器符号,极大提升了对嵌入式固件中通信协议、安全校验等关键逻辑的分析效率。文章涵盖了从Java环境搭建、工具配置到实战逆向解析的完整流程。

peach的博客 945

vue3+ts实现规则引擎

前端来实现规则化引擎对数据进行校验

qq_43180412的博客 654

Frida实战:SSL Pinning绕过技术全解析

本文详细解析了如何使用Frida工具绕过SSL Pinning技术,包括环境搭建、四种实战绕过方案及常见问题排查指南。通过具体代码示例和实战经验,帮助安全研究人员快速掌握SSL Pinning绕过技术,适用于金融类App的安全测试场景。

weixin_42530732的博客 188

Centos 7 Linux 安装单机 Hadoop(HDFS):下载、安装、配置、测试

本文详细介绍了在 CentOS 7 系统上安装与配置单机 Hadoop(HDFS)的完整流程,涵盖 JDK 环境准备、Hadoop 安装包下载与部署、核心配置文件(core-site.xml、hdfs-site.xml 等)修改、SSH 免密登录设置、HDFS 格式化及服务启动,并通过命令行与 Web 界面验证 HDFS 和 YARN 功能,适合 Hadoop 初学者快速搭建本地测试环境。

寒水馨 · 轻量级技术文档 · hanshuixin.org 3239

这款轻量级规则引擎,真香!

是一门高性能、轻量级寄宿于 JVM (包括 Android 平台)之上的脚本语言。它起源于2010年,作者对当时已有的一些产品不是很满意,所以自己撸了一个,它是Groovy的一个定制化的子集。相比较一些传统的规则引擎,比如DroolsJessJRules,它更加轻量级,而且性能更好,同时能力开放,扩展很方便。它支持数字、字符串、正则表达式、布尔值等基本类型,并且可以使用所有 Java 运算符进行运算。还有一个内置的东西叫做bigint和decimal,可以处理超大整数和高精度运算。

三分恶的博客 1100

AndroidKiller之APK 编译失败,无法继续下一步签名【BUG解决】【App反向解析】

文章目录项目场景:问题描述原因分析:解决方案:BUG解决 项目场景: AndroidKiller: 在反向解析APP包时报错:APK 编译失败,无法继续下一步签名。 网上很多方法都是无效的哈,我追究原因发现,这个bug的出现大部分情况都是因为Apktool的问题。 此方法:百分之百解决此bug! 错误如下: 问题描述 APK 编译失败,无法继续下一步签名! 原因分析: Apktool版本不适配的问题,现在的技术更新换代太快,我们安装AndroidKiller的时候,有时候不是官方渠道的话,他的版本是非常

一键难忘的博客 2万+

这 5 种规则引擎,真香!

核心痛点:业务规则高频变更与系统稳定性之间的矛盾// 传统硬编码方式(噩梦开始...)// 更多if-else嵌套...当规则变成:"非VIP用户满200减30,VIP用户满150减40,且周二全场额外95折"时,代码将陷入维护地狱!规则引擎通过分离规则逻辑解决这个问题:规则外置存储(数据库/文件)支持动态加载声明式规则语法独立执行环境下面给大家分享5种常用的规则引擎,希望对你会有所帮助。能用:替换if/else(新手村)用好:规则热更新+可视化(进阶)用精。

1897

按角色定制同一张 Fiori 画面:一篇讲透 SAP Fiori UI Adaptation for Roles 的版本、优先级、视图迁移与安全边界

摘要:SAP Fiori应用中常见的问题并非功能缺失,而是同一应用被不同岗位用于不同工作流时导致界面难以满足各方需求。SAP的"角色适配UI"机制允许在不修改后端逻辑或创建新应用的情况下,为不同角色定制界面呈现。该机制包含多套界面适配方案,按用户角色自动匹配显示,同时保持统一的应用入口。实施时需注意:适配方案与原始应用共享版本管理;需设置"默认界面层";多角色用户通过优先级机制确定显示方案;界面隐藏不等于权限控制,数据安全仍需后端保障。该方案能有效解决跨岗位的界面适配

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 151

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

这5种规则引擎,真香!

核心痛点:业务规则高频变更与系统稳定性之间的矛盾// 传统硬编码方式(噩梦开始...)// 更多if-else嵌套...当规则变成:"非VIP用户满200减30,VIP用户满150减40,且周二全场额外95折"时,代码将陷入维护地狱!规则引擎通过分离规则逻辑解决这个问题:规则外置存储(数据库/文件)支持动态加载声明式规则语法独立执行环境下面给大家分享5种常用的规则引擎,希望对你会有所帮助。能用:替换if/else(新手村)用好:规则热更新+可视化(进阶)用精。

sdgfafg_25的博客 851

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

告别if else!这款轻量级规则引擎框架,真香!

在日常的开发过程中,经常会遇到一些串行或者并行的业务流程问题,而业务之间不必存在相关性。在这样的场景下,使用策略和模板模式的结合可以很好的解决这个问题,但是使用编码的方式会使得文件太多,在业务的部分环节可以这样操作,在项目角度就无法一眼洞穿其中的环节和逻辑。在本文中,将引入规则引擎从全局角度来解决这个问题,这就是今天要介绍的主角liteflow。

IT_1024的博客 780

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

上一篇: 这套 Nginx 日志解决方案,真香!
下一篇: 小心!电脑截图里面掺了东西!
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值