大数据风控项目实战 Drools规则引擎_drools在风控领域的应用

可以借鉴的干货

1,统一存储服务，包含：多种存储库连接封装和服务封装   在统一存储服务
2.获取配置的环境    类：EnvVariable
1
2

一、风控项目介绍

对一个复杂支付系统提供统一、全面、高效的风险控制服务

特定：
	1、数据全
	2、响应快
1
2
3
4
5

二、风控项目系统架构与技术

系统架构：
	实时风控：  规则前处理、统一规则引擎、规则后处理
	非实时风控： 数据收集入库、流式计算引擎、批量计算引擎
	统一存储服务：数据存储
	BFF:非核心模块,一些基础配置信息,比如设置日交易额最大为500

系统环境需要安装的组件；
	mysql + hbase + redis 
	kafka + flink
	maven私服Nexus（主要存储.drl文件，供Drools读取加载规则）

用到的技术：
	实时风控模块：SpringBoot + Netty + Drools规则引擎
    非实时风控模块：Flink
1
2
3
4
5
6
7
8
9
10
11
12
13
14

三、规则设计与规则引擎

1、规则设计

5种典型规则

1、简单型规则：直接读取请求报文进行规则判断
	规则示例：AQ001：对于交易渠道为XXX的所有交易，如果交易手机号和银行签约的手机号一致，则不做任何规则限制

2、数据画像型规则：需要在请求报文基础上添加一些风控因子进行补充判断
	规则示例：LG001:外部导入一批黑名单数据，黑名单用户禁止登录

3、累计型数据规则：需要对用户以往的交易进行进行累计计算的规则
	规则示例：LJ001:设定用户的日交易额为500，超过日交易额的用户，禁止当日所有的交易

4、批量计算型规则：需要对用户以往的交易行为进行批量统计的规则
	规则示例：LJ002:同一个手机号，三日内支付次数超过10次，支付总金额不超过100元，禁止支付12小时

5、复杂事件型规则：需要对用户以往行为组合甄别的规则
   规则示例：LG002:同一个用户，在一天内，连续登录失败5次，则锁定账号，3天内禁止登录
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、规则引擎

a、什么是规则引擎？为什么要用规则引擎？

简单来看，规则引擎就是将一段字符串当作一段逻辑运行

使用规则引擎，能够将数据的准备和处理过程分离解耦
	简单的规则引擎：Aviator表达式引擎
1
2
3
4

b、Drools规则引擎？

官网
中文网

1、drools基础使用

1.pom引入四个依赖
2.resources下写test.drl规则文件
3.java类调用规则文件启动规则引擎
1
2
3

//1、pom依赖
<dependencies>
        <!--drools-->
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>6.5.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>6.5.0.Final</version>
        </dependency>
        <!--kie knowledge is everything-->
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-api</artifactId>
            <version>6.5.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-ci</artifactId>
            <version>6.5.0.Final</version>
        </dependency>
        <dependency>
            <!--lombok-->
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//2、test.drl规则文件

/**
	package xxx.xxx.xxx        所在包名，需要与主运行类一致KnowledgeBase
	import xxx.xxx.xxx         跟java类似，规则中引入的类 Student
	globals xxx.xxx.xxx        全局对象，用于处理多个配置文件中都需要定义的相同对象
	function                  定义一些处理函数，基本跟java类似
	queries                    定义一些查询方法
	rule                       规则
 

 rule就是三大块中得规则体，以rule开头，以end结尾，每个规则文件可以包含多个rule。规则体分为三个部分，LHS RHS 属性三大部分
    LHS, LeftHand Side， 指的是条件部分 
    RHS, RightHnad Size，指的是then后面的部分
*/

//包名
package com.test
import com.test.Student

rule "rule1"
 salience 1   //优先级  越大越早执行（2比1早执行）
    when
        $student:Student(age>10)     //这里叫 LHS
    then
        System.out.println("age>10岁的人：" + $student.getName());  //这里叫 RHS
    end


rule "rule2"
 salience 2   //优先级
    when
        $student:Student(gender=="男",age>10)  //这里就是 LHS
    then
        System.out.println("性别为男，age>10岁的人：" + $student.getName());
    end



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

//3、主运行类调用规则文件启动规则引擎

import org.drools.core.io.impl.ClassPathResource;
import org.kie.api.io.ResourceType;
import org.kie.internal.KnowledgeBase;
import org.kie.internal.KnowledgeBaseFactory;
import org.kie.internal.builder.KnowledgeBuilder;
import org.kie.internal.builder.KnowledgeBuilderFactory;
import org.kie.internal.definition.KnowledgePackage;
import org.kie.internal.runtime.StatefulKnowledgeSession;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class TestDrools2 {
    public static void main(String[] args) {
        //1、获取规则配置文件
        KnowledgeBuilder knowledgeBuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
        knowledgeBuilder.add(new ClassPathResource("test.drl"), ResourceType.DRL);
        Collection<KnowledgePackage> collection = knowledgeBuilder.getKnowledgePackages();
        KnowledgeBase knowledgeBase = KnowledgeBaseFactory.newKnowledgeBase();
        knowledgeBase.addKnowledgePackages(collection);
        //2、获取引擎
        StatefulKnowledgeSession statefulKnowledgeSession = knowledgeBase.newStatefulKnowledgeSession();
        //3、引擎根据规则运行
        List<Student> students = getStudent();
        for (Student student : students) {
            statefulKnowledgeSession.insert(student);
        }
        statefulKnowledgeSession.fireAllRules();
        statefulKnowledgeSession.dispose();
        System.out.println("结束...");

    }

    private static List<Student> getStudent() {
        List<Student> students = new ArrayList<Student>();
        students.add(new Student("张三", 13, "男", new BigDecimal(13)));
        students.add(new Student("李四", 14, "男", new BigDecimal(14)));
        students.add(new Student("王五", 15, "男", new BigDecimal(15)));
        students.add(new Student("赵六", 16, "女", new BigDecimal(16)));
        return students;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

2、drools高级使用 （规则文件test.drl从maven私服读取)

从maven私服加载规则文件
StatefulSession与StatelessfulSession的使用以及区别。
基于Kie组件动态更新Maven仓库中的规则文件。
1
2
3

四、统一存储服务

数据量小，访问也不会太频繁的元数据                   mysql：事务控制比较好
数据量小，业务价值比较高的数据(计算出来的数据)         redis
数据量大，业务价值相对比较低的数据，大而全             hbase、clickHouse、es


1、数据层封装(对各种连接的封装)：
	drisk-common-service项目———connector包
		与各种数据源的交互如：DataBase、Redis、Kafka、Hbase、HTTP
	
	
     
     
2、统一服务封装
	drisk-common-service项目——services包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

五、网络协议层封装（netty）

drisk-realtime-server

 启动类也顺带启动netty服务
1
2
3

六、实时风控引擎整体流程

drisk-realtime-server

在这里插入代码片
1
2
3

七、Drools

Drools官网 https://www.drools.org/

最后、看完这个项目，延伸思考

1、如果不想用netty，如何构建微服务体系？
	 构建message对象，直接丢给engine调用engine的方法，在网络协议层封装里面
	 
2、如果不想用Drools，如何引入新的规则引擎
3、如何保证规则与数据是同步的
1
2
3
4
5