Java 规则引擎封神指南：从底层原理到生产落地，零冗余全干货实战

<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-core</artifactId>
    <version>4.1.0</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.32</version>
    <scope>provided</scope>
</dependency>

package com.jam.demo.rule;

import lombok.extern.slf4j.Slf4j;
import org.jeasy.rules.annotation.Action;
import org.jeasy.rules.annotation.Condition;
import org.jeasy.rules.annotation.Fact;
import org.jeasy.rules.annotation.Rule;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 订单折扣规则
 * @author ken
 */
@Slf4j
@Rule(name = "order_discount_rule", description = "订单金额折扣规则", priority = 1)
publicclass OrderDiscountRule {

    /**
     * 规则条件：订单金额大于等于1000，打9折
     * @param orderAmount 订单金额
     * @return 是否满足条件
     */
    @Condition
    public boolean isDiscountAvailable(@Fact("orderAmount") BigDecimal orderAmount) {
        return orderAmount.compareTo(new BigDecimal("1000")) >= 0;
    }

    /**
     * 规则执行动作：计算折扣后金额
     * @param orderAmount 订单金额
     */
    @Action
    public void applyDiscount(@Fact("orderAmount") BigDecimal orderAmount) {
        BigDecimal discountAmount = orderAmount.multiply(new BigDecimal("0.9")).setScale(2, RoundingMode.HALF_UP);
        log.info("订单金额{}元，满足折扣条件，折扣后金额：{}元", orderAmount, discountAmount);
    }
}

package com.jam.demo.test;

import com.jam.demo.rule.OrderDiscountRule;
import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.api.RulesEngine;
import org.jeasy.rules.core.DefaultRulesEngine;

import java.math.BigDecimal;

/**
 * Easy Rules测试类
 * @author ken
 */
publicclass EasyRuleTest {

    public static void main(String[] args) {
        // 1. 创建规则引擎
        RulesEngine rulesEngine = new DefaultRulesEngine();
        // 2. 创建规则集合
        Rules rules = new Rules();
        rules.register(new OrderDiscountRule());
        // 3. 创建事实对象
        Facts facts = new Facts();
        facts.put("orderAmount", new BigDecimal("2000"));
        // 4. 执行规则
        rulesEngine.fire(rules, facts);
    }
}

INFO  com.jam.demo.rule.OrderDiscountRule - 订单金额2000元，满足折扣条件，折扣后金额：1800.00元

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.3</version>
        <relativePath/>
    </parent>
    <groupId>com.jam.demo</groupId>
    <artifactId>rule-engine-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rule-engine-demo</name>
    <description>Drools Rule Engine Demo</description>

    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <drools.version>8.44.0.Final</drools.version>
        <mybatis-plus.version>3.5.6</mybatis-plus.version>
        <springdoc.version>2.5.0</springdoc.version>
        <fastjson2.version>2.0.52</fastjson2.version>
        <guava.version>33.1.0-jre</guava.version>
        <lombok.version>1.18.32</lombok.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>${springdoc.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-bom</artifactId>
            <version>${drools.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-mvel</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-api</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-internal</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

CREATE DATABASEIFNOTEXISTS rule_db DEFAULTCHARACTERSET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE rule_db;

DROPTABLEIFEXISTS t_rule_info;
CREATETABLE t_rule_info (
    idBIGINTNOTNULL AUTO_INCREMENT COMMENT'主键ID',
    rule_key VARCHAR(64) NOTNULLCOMMENT'规则唯一标识',
    rule_name VARCHAR(128) NOTNULLCOMMENT'规则名称',
    rule_content TEXTNOTNULLCOMMENT'规则内容（drl脚本）',
    rule_type VARCHAR(32) NOTNULLCOMMENT'规则类型',
    statusTINYINTNOTNULLDEFAULT1COMMENT'状态：0-禁用 1-启用',
    versionINTNOTNULLDEFAULT1COMMENT'规则版本',
    create_time DATETIME NOTNULLDEFAULTCURRENT_TIMESTAMPCOMMENT'创建时间',
    update_time DATETIME NOTNULLDEFAULTCURRENT_TIMESTAMPONUPDATECURRENT_TIMESTAMPCOMMENT'更新时间',
    create_by VARCHAR(64) NOTNULLDEFAULT'system'COMMENT'创建人',
    update_by VARCHAR(64) NOTNULLDEFAULT'system'COMMENT'更新人',
    remark VARCHAR(512) DEFAULTNULLCOMMENT'备注',
    PRIMARY KEY (id),
    UNIQUEKEY uk_rule_key_version (rule_key, version),
    KEY idx_status (status)
) ENGINE=InnoDBDEFAULTCHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='规则信息表';

spring:
  application:
    name:rule-engine-demo
datasource:
    url:jdbc:mysql://127.0.0.1:3306/rule_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
    username:root
    password:root
    driver-class-name:com.mysql.cj.jdbc.Driver
jackson:
    date-format:yyyy-MM-ddHH:mm:ss
    time-zone:Asia/Shanghai

mybatis-plus:
mapper-locations:classpath*:/mapper/**/*.xml
type-aliases-package:com.jam.demo.entity
configuration:
    map-underscore-to-camel-case:true
    cache-enabled:false
    log-impl:org.apache.ibatis.logging.stdout.StdOutImpl

springdoc:
api-docs:
    enabled:true
    path:/v3/api-docs
swagger-ui:
    enabled:true
    path:/swagger-ui.html
    tags-sorter:alpha
    operations-sorter:alpha

server:
port:8080

package com.jam.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;

/**
 * 规则信息实体类
 * @author ken
 */
@Data
@TableName("t_rule_info")
@Schema(description = "规则信息实体")
publicclass RuleInfo {

    @TableId(type = IdType.AUTO)
    @Schema(description = "主键ID", example = "1")
    private Long id;

    @Schema(description = "规则唯一标识", example = "order_risk_rule")
    private String ruleKey;

    @Schema(description = "规则名称", example = "订单风控规则")
    private String ruleName;

    @Schema(description = "规则内容（drl脚本）", example = "rule \"xxx\" when then end")
    private String ruleContent;

    @Schema(description = "规则类型", example = "RISK")
    private String ruleType;

    @Schema(description = "状态：0-禁用 1-启用", example = "1")
    private Integer status;

    @Schema(description = "规则版本", example = "1")
    private Integer version;

    @Schema(description = "创建时间")
    private LocalDateTime createTime;

    @Schema(description = "更新时间")
    private LocalDateTime updateTime;

    @Schema(description = "创建人", example = "system")
    private String createBy;

    @Schema(description = "更新人", example = "system")
    private String updateBy;

    @Schema(description = "备注", example = "订单风控核心规则")
    private String remark;
}

package com.jam.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jam.demo.entity.RuleInfo;
import org.apache.ibatis.annotations.Mapper;

/**
 * 规则信息Mapper接口
 * @author ken
 */
@Mapper
public interface RuleInfoMapper extends BaseMapper<RuleInfo> {
}

package com.jam.demo.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.jam.demo.entity.RuleInfo;
import java.util.List;

/**
 * 规则信息服务接口
 * @author ken
 */
publicinterface RuleInfoService extends IService<RuleInfo> {

    /**
     * 查询所有启用的规则
     * @return 启用的规则列表
     */
    List<RuleInfo> listEnabledRules();

    /**
     * 根据规则key查询最新版本的启用规则
     * @param ruleKey 规则唯一标识
     * @return 规则信息
     */
    RuleInfo getLatestEnabledRuleByKey(String ruleKey);

    /**
     * 新增或更新规则
     * @param ruleInfo 规则信息
     * @return 是否成功
     */
    boolean saveOrUpdateRule(RuleInfo ruleInfo);
}

package com.jam.demo.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jam.demo.entity.RuleInfo;
import com.jam.demo.mapper.RuleInfoMapper;
import com.jam.demo.service.RuleInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * 规则信息服务实现类
 * @author ken
 */
@Slf4j
@Service
publicclass RuleInfoServiceImpl extends ServiceImpl<RuleInfoMapper, RuleInfo> implements RuleInfoService {

    privatefinal PlatformTransactionManager transactionManager;

    public RuleInfoServiceImpl(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    @Override
    public List<RuleInfo> listEnabledRules() {
        LambdaQueryWrapper<RuleInfo> queryWrapper = new LambdaQueryWrapper<RuleInfo>()
                .eq(RuleInfo::getStatus, 1);
        returnthis.list(queryWrapper);
    }

    @Override
    public RuleInfo getLatestEnabledRuleByKey(String ruleKey) {
        if (!StringUtils.hasText(ruleKey)) {
            log.warn("规则key为空，无法查询规则");
            returnnull;
        }
        LambdaQueryWrapper<RuleInfo> queryWrapper = new LambdaQueryWrapper<RuleInfo>()
                .eq(RuleInfo::getRuleKey, ruleKey)
                .eq(RuleInfo::getStatus, 1)
                .orderByDesc(RuleInfo::getVersion)
                .last("LIMIT 1");
        returnthis.getOne(queryWrapper);
    }

    @Override
    public boolean saveOrUpdateRule(RuleInfo ruleInfo) {
        if (ObjectUtils.isEmpty(ruleInfo)) {
            log.warn("规则信息为空，无法保存");
            returnfalse;
        }
        if (!StringUtils.hasText(ruleInfo.getRuleKey())) {
            log.warn("规则key为空，无法保存");
            returnfalse;
        }
        // 编程式事务管理
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setName("saveOrUpdateRuleTransaction");
        def.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            // 查询当前规则的最新版本号
            RuleInfo latestRule = getLatestEnabledRuleByKey(ruleInfo.getRuleKey());
            if (!ObjectUtils.isEmpty(latestRule)) {
                // 版本号+1，禁用旧版本规则
                ruleInfo.setVersion(latestRule.getVersion() + 1);
                latestRule.setStatus(0);
                this.updateById(latestRule);
            } else {
                ruleInfo.setVersion(1);
            }
            // 保存新版本规则
            boolean result = this.save(ruleInfo);
            transactionManager.commit(status);
            log.info("规则{}保存成功，版本号：{}", ruleInfo.getRuleKey(), ruleInfo.getVersion());
            return result;
        } catch (Exception e) {
            transactionManager.rollback(status);
            log.error("规则保存失败，回滚事务", e);
            returnfalse;
        }
    }
}

package com.jam.demo.config;

import com.jam.demo.entity.RuleInfo;
import com.jam.demo.service.RuleInfoService;
import lombok.extern.slf4j.Slf4j;
import org.drools.compiler.compiler.DroolsParserException;
import org.drools.compiler.kie.builder.impl.InternalKieModule;
import org.drools.compiler.kie.builder.impl.KieContainerImpl;
import org.drools.compiler.kie.builder.impl.KieFileSystemImpl;
import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.util.List;

/**
 * Drools规则引擎配置类
 * @author ken
 */
@Slf4j
@Configuration
publicclass DroolsConfig {

    privatefinal RuleInfoService ruleInfoService;

    public DroolsConfig(RuleInfoService ruleInfoService) {
        this.ruleInfoService = ruleInfoService;
    }

    /**
     * 初始化KieServices单例
     * @return KieServices实例
     */
    @Bean
    public KieServices kieServices() {
        return KieServices.Factory.get();
    }

    /**
     * 初始化KieFileSystem，加载数据库中的规则
     * @param kieServices KieServices实例
     * @return KieFileSystem实例
     * @throws DroolsParserException 规则解析异常
     * @throws IOException IO异常
     */
    @Bean
    public KieFileSystem kieFileSystem(KieServices kieServices) throws DroolsParserException, IOException {
        KieFileSystem kieFileSystem = new KieFileSystemImpl();
        // 加载所有启用的规则
        List<RuleInfo> ruleList = ruleInfoService.listEnabledRules();
        if (CollectionUtils.isEmpty(ruleList)) {
            log.warn("未查询到启用的规则，初始化空的KieFileSystem");
            return kieFileSystem;
        }
        // 遍历规则，写入KieFileSystem
        for (RuleInfo ruleInfo : ruleList) {
            String ruleKey = ruleInfo.getRuleKey();
            String ruleContent = ruleInfo.getRuleContent();
            if (!StringUtils.hasText(ruleContent)) {
                log.warn("规则{}内容为空，跳过加载", ruleKey);
                continue;
            }
            String path = String.format("rules/%s_%d.drl", ruleKey, ruleInfo.getVersion());
            kieFileSystem.write(path, ruleContent);
            log.info("规则{}加载成功，路径：{}", ruleKey, path);
        }
        return kieFileSystem;
    }

    /**
     * 初始化KieBuilder，构建规则模块
     * @param kieServices KieServices实例
     * @param kieFileSystem KieFileSystem实例
     * @return KieBuilder实例
     */
    @Bean
    public KieBuilder kieBuilder(KieServices kieServices, KieFileSystem kieFileSystem) {
        KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
        kieBuilder.buildAll();
        // 检查规则编译结果
        Results results = kieBuilder.getResults();
        if (results.hasMessages(Message.Level.ERROR)) {
            List<Message> errorMessages = results.getMessages(Message.Level.ERROR);
            log.error("规则编译失败，错误信息：{}", errorMessages);
            thrownew RuntimeException("规则编译失败：" + errorMessages);
        }
        log.info("规则编译成功，无错误");
        return kieBuilder;
    }

    /**
     * 初始化KieModule，规则模块
     * @param kieBuilder KieBuilder实例
     * @return KieModule实例
     */
    @Bean
    public KieModule kieModule(KieBuilder kieBuilder) {
        return kieBuilder.getKieModule();
    }

    /**
     * 初始化KieContainer，规则容器
     * @param kieServices KieServices实例
     * @param kieModule KieModule实例
     * @return KieContainer实例
     */
    @Bean
    public KieContainer kieContainer(KieServices kieServices, KieModule kieModule) {
        return kieServices.newKieContainer(kieModule.getReleaseId());
    }

    /**
     * 初始化KieSession，规则会话，用于执行规则
     * @param kieContainer KieContainer实例
     * @return KieSession实例
     */
    @Bean
    public KieSession kieSession(KieContainer kieContainer) {
        KieSession kieSession = kieContainer.newKieSession();
        log.info("KieSession初始化成功");
        return kieSession;
    }

    /**
     * 动态刷新规则，无需重启服务
     * @param kieServices KieServices实例
     * @param kieContainer KieContainer实例
     */
    public void refreshRules(KieServices kieServices, KieContainer kieContainer) {
        try {
            KieFileSystem kieFileSystem = kieFileSystem(kieServices);
            KieBuilder kieBuilder = kieBuilder(kieServices, kieFileSystem);
            KieModule kieModule = kieModule(kieBuilder);
            ((KieContainerImpl) kieContainer).updateToKieModule((InternalKieModule) kieModule);
            log.info("规则动态刷新成功");
        } catch (Exception e) {
            log.error("规则动态刷新失败", e);
            thrownew RuntimeException("规则动态刷新失败", e);
        }
    }
}

package com.jam.demo.fact;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 订单风控事实对象，用于规则引擎执行
 * @author ken
 */
@Data
@Schema(description = "订单风控事实对象")
publicclass OrderRiskFact {

    @Schema(description = "订单号", example = "ORD202602280001")
    private String orderNo;

    @Schema(description = "用户ID", example = "10001")
    private Long userId;

    @Schema(description = "用户等级：1-普通 2-VIP 3-超级VIP", example = "1")
    private Integer userLevel;

    @Schema(description = "订单金额", example = "5000.00")
    private BigDecimal orderAmount;

    @Schema(description = "收货地址是否为常用地址", example = "true")
    private Boolean isCommonAddress;

    @Schema(description = "用户近30天订单数", example = "5")
    private Integer orderCount30Days;

    @Schema(description = "用户历史拒付次数", example = "0")
    private Integer refusePayCount;

    @Schema(description = "风控结果：PASS-放行 REVIEW-人工审核 REJECT-拦截", example = "PASS")
    private String riskResult;

    @Schema(description = "风控描述", example = "订单正常，放行")
    private String riskDesc;

    @Schema(description = "订单创建时间")
    private LocalDateTime orderCreateTime;
}

package com.jam.demo.rules;
dialect "mvel"
import com.jam.demo.fact.OrderRiskFact
global org.slf4j.Logger log;

/**
 * 规则1：超级VIP用户，订单金额小于10000，直接放行
 */
rule "super_vip_pass_rule"
    salience 100
    when
        $fact: OrderRiskFact(userLevel == 3, orderAmount < 10000, refusePayCount == 0)
    then
        $fact.setRiskResult("PASS");
        $fact.setRiskDesc("超级VIP用户，订单正常，直接放行");
        log.info("订单{}触发超级VIP放行规则", $fact.getOrderNo());
end

/**
 * 规则2：VIP用户，订单金额小于5000，常用地址，直接放行
 */
rule "vip_pass_rule"
    salience 90
    when
        $fact: OrderRiskFact(userLevel == 2, orderAmount < 5000, isCommonAddress == true, refusePayCount == 0)
    then
        $fact.setRiskResult("PASS");
        $fact.setRiskDesc("VIP用户，订单正常，直接放行");
        log.info("订单{}触发VIP放行规则", $fact.getOrderNo());
end

/**
 * 规则3：普通用户，订单金额大于10000，直接拦截
 */
rule "normal_user_reject_rule"
    salience 80
    when
        $fact: OrderRiskFact(userLevel == 1, orderAmount >= 10000)
    then
        $fact.setRiskResult("REJECT");
        $fact.setRiskDesc("普通用户订单金额过高，系统自动拦截");
        log.warn("订单{}触发高金额拦截规则", $fact.getOrderNo());
end

/**
 * 规则4：用户有历史拒付记录，直接拦截
 */
rule "refuse_pay_reject_rule"
    salience 1000
    when
        $fact: OrderRiskFact(refusePayCount > 0)
    then
        $fact.setRiskResult("REJECT");
        $fact.setRiskDesc("用户有历史拒付记录，系统自动拦截");
        log.error("订单{}触发拒付记录拦截规则", $fact.getOrderNo());
end

/**
 * 规则5：非常用地址，近30天无订单，订单金额大于2000，人工审核
 */
rule "uncommon_address_review_rule"
    salience 70
    when
        $fact: OrderRiskFact(isCommonAddress == false, orderCount30Days == 0, orderAmount >= 2000)
    then
        $fact.setRiskResult("REVIEW");
        $fact.setRiskDesc("非常用地址且无近期订单，需人工审核");
        log.info("订单{}触发人工审核规则", $fact.getOrderNo());
end

/**
 * 规则6：默认规则，无匹配规则时放行
 */
rule "default_pass_rule"
    salience 0
    when
        $fact: OrderRiskFact(riskResult == null)
    then
        $fact.setRiskResult("PASS");
        $fact.setRiskDesc("无匹配风控规则，默认放行");
        log.info("订单{}触发默认放行规则", $fact.getOrderNo());
end

package com.jam.demo.service;

import com.jam.demo.fact.OrderRiskFact;

/**
 * 订单风控服务接口
 * @author ken
 */
public interface OrderRiskService {

    /**
     * 执行订单风控规则校验
     * @param fact 订单风控事实对象
     * @return 风控结果
     */
    OrderRiskFact executeRiskCheck(OrderRiskFact fact);
}

package com.jam.demo.service.impl;

import com.jam.demo.config.DroolsConfig;
import com.jam.demo.fact.OrderRiskFact;
import com.jam.demo.service.OrderRiskService;
import lombok.extern.slf4j.Slf4j;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

/**
 * 订单风控服务实现类
 * @author ken
 */
@Slf4j
@Service
publicclass OrderRiskServiceImpl implements OrderRiskService {

    privatefinal KieSession kieSession;
    privatefinal KieServices kieServices;
    privatefinal KieContainer kieContainer;
    privatefinal DroolsConfig droolsConfig;

    public OrderRiskServiceImpl(KieSession kieSession, KieServices kieServices, KieContainer kieContainer, DroolsConfig droolsConfig) {
        this.kieSession = kieSession;
        this.kieServices = kieServices;
        this.kieContainer = kieContainer;
        this.droolsConfig = droolsConfig;
    }

    @Override
    public OrderRiskFact executeRiskCheck(OrderRiskFact fact) {
        if (ObjectUtils.isEmpty(fact)) {
            log.warn("风控事实对象为空，无法执行规则");
            returnnull;
        }
        try {
            // 设置全局日志对象
            kieSession.setGlobal("log", log);
            // 插入事实对象
            kieSession.insert(fact);
            // 执行所有规则
            int ruleFiredCount = kieSession.fireAllRules();
            log.info("订单{}风控规则执行完成，触发规则数：{}", fact.getOrderNo(), ruleFiredCount);
            return fact;
        } catch (Exception e) {
            log.error("订单{}风控规则执行失败", fact.getOrderNo(), e);
            thrownew RuntimeException("风控规则执行失败", e);
        } finally {
            // 清空会话，避免事实对象残留
            kieSession.dispose();
        }
    }

    /**
     * 刷新规则
     */
    public void refreshRules() {
        droolsConfig.refreshRules(kieServices, kieContainer);
    }
}

package com.jam.demo.controller;

import com.jam.demo.fact.OrderRiskFact;
import com.jam.demo.service.OrderRiskService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.util.ObjectUtils;

/**
 * 订单风控控制器
 * @author ken
 */
@Slf4j
@RestController
@RequestMapping("/api/risk")
@Tag(name = "订单风控接口", description = "订单风控规则执行相关接口")
publicclass OrderRiskController {

    privatefinal OrderRiskService orderRiskService;

    public OrderRiskController(OrderRiskService orderRiskService) {
        this.orderRiskService = orderRiskService;
    }

    @PostMapping("/check")
    @Operation(summary = "执行订单风控校验", description = "传入订单信息，执行风控规则，返回风控结果")
    public ResponseEntity<OrderRiskFact> executeRiskCheck(@RequestBody OrderRiskFact fact) {
        if (ObjectUtils.isEmpty(fact)) {
            return ResponseEntity.badRequest().body(null);
        }
        OrderRiskFact result = orderRiskService.executeRiskCheck(fact);
        return ResponseEntity.ok(result);
    }
}

package com.jam.demo.controller;

import com.jam.demo.config.DroolsConfig;
import com.jam.demo.entity.RuleInfo;
import com.jam.demo.service.RuleInfoService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * 规则管理控制器
 * @author ken
 */
@Slf4j
@RestController
@RequestMapping("/api/rule")
@Tag(name = "规则管理接口", description = "规则信息管理、动态刷新相关接口")
publicclass RuleManageController {

    privatefinal RuleInfoService ruleInfoService;
    privatefinal DroolsConfig droolsConfig;
    privatefinal KieServices kieServices;
    privatefinal KieContainer kieContainer;

    public RuleManageController(RuleInfoService ruleInfoService, DroolsConfig droolsConfig, KieServices kieServices, KieContainer kieContainer) {
        this.ruleInfoService = ruleInfoService;
        this.droolsConfig = droolsConfig;
        this.kieServices = kieServices;
        this.kieContainer = kieContainer;
    }

    @GetMapping("/list/enabled")
    @Operation(summary = "查询所有启用的规则", description = "查询所有状态为启用的规则列表")
    public ResponseEntity<List<RuleInfo>> listEnabledRules() {
        List<RuleInfo> ruleList = ruleInfoService.listEnabledRules();
        return ResponseEntity.ok(ruleList);
    }

    @GetMapping("/get/{ruleKey}")
    @Operation(summary = "查询最新版本规则", description = "根据规则key查询最新版本的启用规则")
    public ResponseEntity<RuleInfo> getLatestRule(@PathVariable String ruleKey) {
        if (!StringUtils.hasText(ruleKey)) {
            return ResponseEntity.badRequest().body(null);
        }
        RuleInfo ruleInfo = ruleInfoService.getLatestEnabledRuleByKey(ruleKey);
        return ResponseEntity.ok(ruleInfo);
    }

    @PostMapping("/save")
    @Operation(summary = "新增或更新规则", description = "新增规则或更新规则版本，自动禁用旧版本")
    public ResponseEntity<Boolean> saveOrUpdateRule(@RequestBody RuleInfo ruleInfo) {
        if (ObjectUtils.isEmpty(ruleInfo)) {
            return ResponseEntity.badRequest().body(false);
        }
        boolean result = ruleInfoService.saveOrUpdateRule(ruleInfo);
        return ResponseEntity.ok(result);
    }

    @PostMapping("/refresh")
    @Operation(summary = "动态刷新规则", description = "重新加载数据库中的规则，无需重启服务")
    public ResponseEntity<Boolean> refreshRules() {
        try {
            droolsConfig.refreshRules(kieServices, kieContainer);
            return ResponseEntity.ok(true);
        } catch (Exception e) {
            log.error("规则刷新失败", e);
            return ResponseEntity.internalServerError().body(false);
        }
    }
}

package com.jam.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 规则引擎demo启动类
 * @author ken
 */
@SpringBootApplication
@MapperScan("com.jam.demo.mapper")
publicclass RuleEngineDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(RuleEngineDemoApplication.class, args);
    }
}

{
  "orderNo": "ORD202602280001",
"userId": 10001,
"userLevel": 1,
"orderAmount": 20000,
"isCommonAddress": true,
"orderCount30Days": 5,
"refusePayCount": 0,
"orderCreateTime": "2026-02-28T12:00:00"
}

{
  "orderNo": "ORD202602280001",
"userId": 10001,
"userLevel": 1,
"orderAmount": 20000,
"isCommonAddress": true,
"orderCount30Days": 5,
"refusePayCount": 0,
"riskResult": "REJECT",
"riskDesc": "普通用户订单金额过高，系统自动拦截",
"orderCreateTime": "2026-02-28T12:00:00"
}