车金融|金融产品规则引擎的前世今生（上篇）

最新推荐文章于 2023-01-11 20:06:20 发布
最新推荐文章于 2023-01-11 20:06:20 发布
阅读量386 收藏 1
点赞数
分类专栏： 重构之路 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shichen2010/article/details/110290703
版权

金融产品规则引擎从重构到不断迭代优化，围绕着宗旨就是如何设计更灵活更有扩展性的方案，最终设计面向产品运营研发测试多角色多层次用户群体，因此平台更低的学习成本和易用性成为我们不断努力的目标，我们为实现这一目标在重构优化的历程中不断努力。

温馨提示：全文共计3800余字，乃上班地铁途中码字编写，实属不易，感谢关注。起草于2020年11月23日，终稿于2020年11月28日。

秋夜无霜

车金融前世今生专辑连载系列，关注微信公众号【秋夜无霜】

车金融|金融产品中心的前世今生

车金融|GPS审核系统的前世今生

车金融|基础数据平台的前世今生

车金融|合同中心系统的前世今生

车金融|金融产品规则引擎的前世今生（上篇）

车金融|金融产品规则引擎的前世今生（中篇）

车金融|金融产品规则引擎的前世今生（下篇）

车金融|我在M公司的那两年

文章目录

一、导读

金融产品平台业务规则从大类划分可以分为金融方案费用规则、业务场景前后置规则、资金方准入规则三大类，这三大类规则构成车金融业务线金融产品的规则引擎核心设计。金融方案费用规则为金融产品提供更灵活更有扩展性的金融方案奠定基础，而业务场景前后置规则是为了解决特定场景的业务拒绝与反算推演，进而弥补金融方案费用规则的不足，这两者关系相辅相成，共同铸造金融产品规则引擎的核心。同时，资金方准入规则是金融方案从资方维度更进一步的规则抽象集合，是金融方案差异化的共性规则特征集，这三者为支撑公司业务发展奠定核心基础。

金融产品前置规则从最初的存储过程实现，然后改造成Java实现，最终在金融产品系统重新设计实现。后置规则是为了像前置规则那样提供给产品运营人员统一标准化的用户交互，从审核系统迁移到金融产品平台。本文主要介绍车金融业务线金融产品前后置规则引擎的发展历程，以及相关技术方案的实现，通过本文希望你可以收获启迪，以帮助此刻道路上的你获得灵感。

本文将讲述这三大类规则中的前后置规则，通过讲述历程发展以及介绍技术方案设计，为您呈现背后的核心细节。

二、存储过程的时代

入职初期，我所在的车金融业务线的信贷研发团队有13个处理不同业务场景的存储过程，其中一个存储过程提供RR规则（前置规则）业务处理，存储过程基于服务器cron定时去调度执行调用，筛选符合状态的订单然后批量跑批处理，通过若干条规则验证后，执行通过或拒绝处理。

后来我负责金融产品，参与一个资方业务需求，需要调整前置规则。此刻我清晰地记得，我们把调整后的存储过程脚本在测试环境验证后，上线时回归验证发现执行跑批任务处理异常。鉴于当时的客观条件，对于MYSQL存储过程异常我们后端研发无法跟踪排查，我们不得退而求其次在后置规则增加处理，毕竟后置规则是在Java服务端实现，就这样勉强上线也能满足业务需求。

后来，老板也认识到存储过程的种种弊端，认为这样的技术栈对于后续业务发展肯定是站不住脚的，因此研发团队必须要客服一切困难在短期进行技术重构的。

鉴于老板赋予的使命，我带着团队从此开始13个存储过程的陆续技术改造，通过Java语言重新实现（搭建一个SpringBoot应用lyqc-sieg），然后一个个陆续研发测试上线，从而彻底消灭了存储过程，开启了金融产品团队重构的新的一大里程碑。

存储过程改造后的系统应用交互流程

三、实时处理的必要性

2018年下半年，车金融业务从整体流程在进行相关优化效能的提升，考虑到订单准入审批时效，期望准入环节就可以知道是否通过，由于当日进件翌日跑批才能出结果，进而要求我们这个前置规则是否可以由定时任务跑批，改造成实时调用并立即返回准入结果。

由于最初和前置规则一起的跑批还有另外两个（重复性检验和渠道状态审批），这三个跑批是有顺序性和关联性，倘若其中一个跑批不通过的话，另外一个就不能进行跑批，这种时序性依赖使得我们想要优化，对于时间性能优化达到一个瓶颈点。

后来我们跟老板以及产品多次沟通此事宜，发现把其中一个耗时最长的存储过程（重复性检验）可以业务流程后置，无需准入环节执行跑批。这样以来，剩下的两个存储过程通过接口业务逻辑合并，通过消息机制通知，可以实现即时处理，同时保留定时任务，对于消息丢失场景或者业务逻辑处理异常时可以再次定时跑批。

为提升审批时效的技术优化方案

四、规则配置化的趋势

这次技术优化，进一步提高了业务流程审批时效，但是前置规则技术架构设计依然有优化空间。由于业务逻辑处理对订单相关数据的依赖性，使得我们每次业务需求涉及到前置规则调整，依然需要修改现有业务逻辑代码。

2018年下半年，老板也多次提及我们金融产品团队，前置规则是否可以实现配置化，交付给产品运营同学使用，不需要每次需求迭代必须修改代码就可以完成需求上线呢？

我们通过技术调研，发现是可以尝试做到的。我们需要进一步明确规则引擎的系统职责，对于业务线各业务系统的场景使用，它只关注于场景规则特征定义以及接口输入参数定义。业务方根据场景选择根据我们规则引擎规范定义输入参数，然后调用规则引擎服务执行规则检验并返回结果。在技术方案设计中，我们把前置规则检验接口所需参数，参数编码，参数类型等一系列元数据定义，然后接口传入所需合法类型参数，通过这样的数据流程定义，就可以实现前置规则的配置化和上线免发布。

技术方案设计中，我们基于Google Aviator这个开源的计算引擎包扩展了一系列自定义函数，以支撑我们的业务场景需要。譬如，多个数字求和，本身这个包对于累计求和的相关数字没有传值，则会运行异常。因此我们进行了扩展兼容，参数没有传值时，我们视为零处理。

对于金融行业，数字在进位方式和取整当时同样业务场景颇多，我们也扩展自定义了相关函数，辅助我们的产品运营同学使用。

在考虑到产品运营同学的使用及学习成本时，在金融产品平台优化了功能交互，降低他们的学习成本，避免他们配置出错。

四、后置规则的必然迁移

后置规则最初在审核系统维护，最初的技术实现无非就是使用大量的if else条件语句控制，相对于最初的前置规则，优势在于毕竟是Java语言实现，出现问题也容易排查，需求变更更容易扩展。

自前置规则完成迁移到金融产品系平台进行运营化配置后，期间我们与产品运营同学多次沟通交流，对平台功能交互进行多次优化，使得他们逐渐熟练使用相关功能，他们期望后置规则也能像前置规则这样他们可以自主运营，需求一次次提需求，再研发上线，周期长，无法支撑业务政策的调整响应。

尽管后置规则吸收了前置规则的配置化技术方案设计思路，期间进行过一次技术重构，以进一步适应业务发展趋势。金融产品系统提供引擎包，提供给审核团队使用，这样的局面维持了相当一段时间。

后来，我们金融产品团队进一步考虑到，既然审核系统已经依赖了金融产品引擎包，为何不直接把后置规则的配置也移植到金融产品平台，审核系统只调用接口就行了。因此，我们经过沟通讨论，愿意帮助产品运营同学实现这一愿望，决定从审核系统迁移过来后置规则，同时复用前置规则的表结构以及引擎逻辑处理模块，最终实现后置规则对于产品同学的可视化与运营化。

审核系统后置规则的迁移接口交互方案

五、技术方案的核心设计

我们在实现前置规则配置化的设计时，由于这是属于我们技术团队自研设计，因此可以最可能发挥我们的创新优势，以彰显我们的思维脑洞。坦白讲，我比较喜欢自主创新项目，无拘无束，没有羁绊。

前置规则有三种执行策略：删除、取消、拒绝。事实上，我们重构后，仅仅只会用到拒绝这种业务场景策略。

前置规则的业务场景需求逻辑，简言之，就是订单主贷人信息或者车辆相关信息，在满足什么条件前置下，不满足什么规则特征条件，执行规则策略。然而，若干条规则，有时候命中不仅仅是一条，而是多条，但多条执行策略到底该返回哪一条，这时候其实需要规则优先级或权重，进而解决这种业务场景。

事实上讲，我们的业务场景也只有拒绝场景，其他场景无需前置规则处理，从业务流程讲风控规则会前置处理，所以我们只关注准入环节的业务逻辑检验。

这样以来，我们不用考虑优先级的概念，接口内部设计就是从数据库取出所有的规则集合，然后循环逐条检验，倘若不满足，直接跳出循环返回规则提示文案。如果满足，则继续下一条检验。倘若某一条，出现运行时异常，比如规则表达式语法解析错误，或者零作为除数等，这时候则忽略该异常，继续循环走下去。

我们接口内部设计时，在解析规则出现异常时，也提供了几种策略模式实现，这一点设计上，吸收了Java线程池的拒绝策略设计，以满足我们业务场景的扩展需求。

然而，尽管我们提供了若干策略机制，实际上却用不到，但是提供了扩展性。我们从接口设计上，遵循一个基本原则是，不会因为产品运营配置规则导致的运行时异常，在业务方调用时，影响调用结果，所以直接简单处理方案就是异常时忽略即可。

参数元数据定义

我们把参数元数据定义通过配置中心配置，示例如下：

[{
		"fieldName": "appCode",
		"fieldType": "String",
		"fieldDesc": "订单号",
		"mustExpression": "true",
		"belongGroup": [
			"baseInfo"
		]
	},
	{
		"fieldName": "carLoanAmount",
		"fieldType": "Number",
		"fieldDesc": "车贷金额",
		"mustExpression": "true",
		"belongGroup": []
	},
	{
		"fieldName": "loanRate",
		"fieldType": "Number",
		"fieldDesc": "贷款利率",
		"mustExpression": "true",
		"belongGroup": []
	},
	{
		"fieldName": "evaCarPriceChange",
		"fieldType": "Number",
		"fieldDesc": "二手车调整价",
		"mustExpression": "isOld != nil && string.contains(isOld,'1')",
		"belongGroup": []
	}
]

平台交互功能

规则配置管理

规则配置-属性配置
规则配置-属性参数列举

接口设计

对外api接口

@RestController
@RequestMapping("/position")
public class PositionController{

    @Resource
    private PositionFacadeProvider positionFacadeProvider;

    @ApiOperation("前置规则执行接口")
    @PostMapping("/processPrePosition")
    public Result<RuleCheckRe> processPrePosition(@RequestBody Map<String,Object> map){
        return this.positionFacadeProvider.processPrePosition(map);
    }

    @ApiOperation("后置规则执行接口")
    @PostMapping("/processPostPosition")
    public Result<RuleCheckRe> processPostPosition(@RequestBody Map<String,Object> map) {
        return this.positionFacadeProvider.processPostPosition(map);
    }
}

从上述我们可以看到，接口输入参数是一个Map，也就是一个JSON对象，key为参数，value为参数值，但是参数以及参数值必须遵守配置约束。

核心代码

前后置规则UML类图
前后置规则时序图

AbstractPositionRuleHandler

核心方法 ruleCheck

/**
 * 外部调用，执行器入口
 * @param context
 */
public void ruleCheck(PositionRuleContext context){
    try {
        // 1. 对象初始化
        init(context);
        // 2. 参数校验
        boolean paramCheck = paramCheck();
        if(!paramCheck) {
            return;
        }
        context.setAuth(true);
        // 3. 加载检查规则
        loadCheckRule();
        if(CollectionsTools.isEmpty(ruleList)) {
            ruleCheckRe.setMessage("没有需要校验的规则");
            return;
        }
        // 4. 规则校验
        PositionContext positionContext = PositionContext.builder().strategy(PositionStrategy.THROWS_EXCEPTION).env(params).ruleList(ruleList).ruleCheckRe(ruleCheckRe).classifyEnum(classifyEnum).build();
        AbstractRuleCheckExecutor executor = new PositionExecutor(positionContext);
        executor.execute();
    } catch (Exception e) {
        log.error("{} 执行器入口调用异常, context={}", LOG_TITLE, JSON.toJSONString(context), e);
        ruleCheckRe.setAccess(false);
        ruleCheckRe.setMessage(MessageFormat.format("{0}系统异常", LOG_TITLE));
        ruleCheckRe.setErrorRuleDesc(JSON.toJSONString(context));
        context.setMessage(LOG_TITLE + "执行异常");
    } finally {
        context.setRuleCheckRe(ruleCheckRe);
        saveLog();
    }
}

核心方法 checkParamsTypeLegal

/**
 * 判断所有入参类型是否合法
 * @param params
 * @param checkParamsEntity
 */
private boolean checkParamsTypeLegal(Map<String, Object> params, List<AutoPositionEntity> checkParamsEntity) {
    if(CollectionsTools.isEmpty(checkParamsEntity)){
        return true;
    }
    for(AutoPositionEntity entity : checkParamsEntity) {
        //获取校验规范类型
        PositionParamTypeEnum positionParamTypeEnum = PositionParamTypeEnum.getByName(entity.getFieldType());
        if(positionParamTypeEnum == null) {
            context.setMessage(LOG_TITLE + "参数配置有误，请联系技术支持");
            return false;
        }
        Object paramsValue = params.get(entity.getFieldName());
        AviatorContext ctx = AviatorContext.builder().expression(entity.getMustExpression()).env(params).build();
        try {
            boolean must = AviatorExecutor.executeBoolean(ctx);
            if(must && paramsValue == null) {
                context.setMessage(MessageFormat.format("请求参数：{0}，不能为空", entity.getFieldName()));
                return false;
            }
        } catch (Exception e) {
            context.setMessage(LOG_TITLE + "字段必传属性配置异常，请联系技术支持");
            log.error("{} , appCode:{}", LOG_TITLE, appCode, e);
            return false;
        }
        if(paramsValue != null) {
            String paramsType = paramsValue.getClass().getTypeName();
            boolean checkType = positionParamTypeEnum.check(paramsValue);
            if(!checkType) {
                context.setMessage(MessageFormat.format("{0} 请求参数不合法,参数名称：{1}, 入参类型：{2}, 校验类型：{3}", LOG_TITLE, entity.getFieldName(), paramsType, positionParamTypeEnum));
                return false;
            }
            // 需要转换一下，计算引擎如果是整数数值，会有向下取整问题，转换将会装换为小数形式，String 类型可以不做转换，此处为了统一
            params.put(entity.getFieldName(), positionParamTypeEnum.convert(paramsValue));
        }
    }
    return true;
}

AbstractRuleCheckExecutor

核心方法 call

/**
 * 调用处理
 */
protected void call() {
    AutoApprConstant.OpIdnEnum opIdnEnum;
    try {
        for (AutoApprRule ruleEntity : ruleList) {
            this.executeRule = false;
            this.ruleEntity = ruleEntity;
            List<AutoApprRuleProp> propList = ruleEntity.getProps();
            for (AutoApprRuleProp propEntity : propList) {
                try {
                    boolean currentMatch;
                    opIdnEnum = AutoApprConstant.OpIdnEnum.getByName(propEntity.getOpIdn());
                    if (Objects.equals(AutoApprConstant.PropFieldExtendEnum.EXPRESSION.getName(), propEntity.getPropCode())) {
                        currentMatch = access(propEntity.getPropValue());
                    } else {
                        AutoApprConstant.PropFieldTypeEnum valueTypeEnum = AutoApprConstant.PropFieldTypeEnum.getByIndex(propEntity.getPropValueType());
                        currentMatch = OpSymbols.builder().env(env).opIdnEnum(opIdnEnum).valueTypeEnum(valueTypeEnum)
                                .propCode(propEntity.getPropCode()).propValue(propEntity.getPropValue()).build().access();
                    }
                    if (!currentMatch) {
                        executeRule = false;
                        break;
                    } else {
                        executeRule = true;
                    }
                } catch (Exception e) {
                    errorRuleDesc.add(MessageFormat.format("规则[{0}]属性配置错误", ruleEntity.getRuleId()));
                    executeRule = false;
                    strategyHandle.handle(e, this, ruleEntity);
                    break;
                }
            }
            boolean complete = after();
            if(complete) {
                return;
            }
        }
        if(!ruleCheckRe.isAccess()) {
            ruleCheckRe.setCalculateResult(calculateResult);
            if(AutoApprConstant.BelongNameEnum.getByIndex(ruleCheckRe.getBelongType()) == AutoApprConstant.BelongNameEnum.COMPUTE && CollectionsTools.isEmpty(calculateResult)) {
                ruleCheckRe.setBelongType(AutoApprConstant.BelongNameEnum.CHECK.getIndex());
            }
        }
        ruleCheckRe.setErrorRuleDesc(errorRuleDesc.stream().collect(Collectors.joining(",")));
    } catch (PositionStrategyException e) {
        log.error("{} 异常, ruleIdList={} ", LOG_TITLE, JSON.toJSONString(errorRuleDesc), e);
        ruleCheckRe.setAccess(false);
        ruleCheckRe.setErrorRuleDesc(errorRuleDesc.stream().collect(Collectors.joining(",")));
        ruleCheckRe.setBelongType(AutoApprConstant.BelongNameEnum.CHECK.getIndex());
        ruleCheckRe.setMessage(e.getMessage());
    }
}

核心方法 after

/**
 * 后置处理
 */
protected boolean after() throws PositionStrategyException {
    AutoApprConstant.BelongNameEnum belongNameEnum = Optional.ofNullable(AutoApprConstant.BelongNameEnum.getByName(ruleEntity.getBelongName()))
            .orElseThrow(() -> new PositionStrategyException(MessageFormat.format("规则[{0}]类型配置错误，规则类型={1}", ruleEntity.getRuleId(), ruleEntity.getBelongName())));
    if (executeRule) {
        ruleCheckRe.setAccess(false);
        ruleCheckRe.setRuleId(ruleEntity.getRuleId());
        ruleCheckRe.setBelongType(belongNameEnum.getIndex());
        switch (belongNameEnum) {
            case CHECK:
                ruleCheckRe.setMessage(ruleEntity.getMsgTemplate());
                return true;
            case COMPUTE:
                calculateResult = Optional.ofNullable(calculateResult).orElse(Maps.newHashMapWithExpectedSize(10));
                AutoApprFormulaBo autoApprFormulaBo = AutoApprFormulaBo.builder().ruleId(ruleEntity.getRuleId())
                        .type(AutoApprFormulaTypeEnum.BACK_CALCULATION.getIndex()).params(env).messageTemplate(ruleEntity.getMsgTemplate()).classifyEnum(classifyEnum).build();
                List<RuleCalculateRe> calculateReList = autoApprFormulaComponent.calculateResult(autoApprFormulaBo);
                if(CollectionsTools.isNotEmpty(calculateReList)) {
                    for(RuleCalculateRe calculateRe : calculateReList){
                        RuleCalculateRe ruleCalculateRe = calculateResult.get(calculateRe.getFieldName());
                        BigDecimal calculateReValue = calculateRe.getValue();
                        if(ruleCalculateRe == null || calculateReValue.compareTo(ruleCalculateRe.getValue()) < 0) {
                            ruleCheckRe.setMessage(ruleEntity.getMsgTemplate());
                            calculateResult.put(calculateRe.getFieldName(), calculateRe);
                        }
                    }
                } else {
                    if(StringTools.isEmpty(ruleCheckRe.getMessage())) {
                        ruleCheckRe.setMessage(ruleEntity.getMsgTemplate());
                    }
                    errorRuleDesc.add(MessageFormat.format("规则[{0}]缺少反算配置", ruleEntity.getRuleId()));
                }
                return false;
            default:
                throw new PositionStrategyException(MessageFormat.format("规则[{0}]类型配置错误，规则类型={1}", ruleEntity.getRuleId(), belongNameEnum.getName()));
        }
    }
    return false;
}

PositionStrategyHandle

UML类图

PositionStrategyHandle

public interface PositionStrategyHandle {
    /**
     * 处理
     * @param throwable 异常
     * @param executor 执行器对象
     * @param ruleEntity 规则实体对象
     */
    void handle(Throwable throwable, AbstractRuleCheckExecutor executor, AutoApprRule ruleEntity) throws PositionStrategyException;
}

ThrowsExceptionStrategyHandle

/**
 * @description: 多个规则执行时，如果当前规则执行出现运行时异常，则抛出该异常
 * @Date : 2018/12/12 下午2:11
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public class ThrowsExceptionStrategyHandle implements PositionStrategyHandle {
    final String pattern = "规则[{0}]内部错误，规则名称={1}";
    @Override
    public void handle(Throwable throwable, AbstractRuleCheckExecutor executor, AutoApprRule ruleEntity) throws PositionStrategyException {
        String message = MessageFormat.format(pattern, ruleEntity.getRuleId(), ruleEntity.getRuleName());
        log.error("{0},ruleEntity={1}", message, JSON.toJSON(ruleEntity), throwable);
        throw new PositionStrategyException(message, throwable);
    }
}

StrictExecuteStrategyHandle

/**
 * @description: 严谨执行所有规则
 * @Date : 2018/12/12 下午2:11
 * @Author : 石冬冬-Seig Heil
 */
public class StrictExecuteStrategyHandle extends ThrowsExceptionStrategyHandle implements PositionStrategyHandle {
    @Override
    public void handle(Throwable throwable, AbstractRuleCheckExecutor executor, AutoApprRule ruleEntity) throws PositionStrategyException {
        super.handle(throwable,executor,ruleEntity);
    }
}

IgnoreExceptionStrategyHandle

/**
 * @description: 多个规则执行时，如果当前规则执行出现运行时异常，则忽略继续执行
 * @Date : 2018/12/12 下午2:11
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public class IgnoreExceptionStrategyHandle implements PositionStrategyHandle {
    @Override
    public void handle(Throwable throwable, AbstractRuleCheckExecutor executor, AutoApprRule ruleEntity) {
        log.warn("规则支持执行警告，规则将忽略继续执行,ruleEntity={0}", JSON.toJSON(ruleEntity),throwable);
    }
}

PositionStrategyHandleFactory

/**
 * @description: 置入规则策略处理接口工厂类
 * @Date : 2018/12/11 下午4:08
 * @Author : 石冬冬-Seig Heil
 */
public final class PositionStrategyHandleFactory {
    /**
     * 工厂方法
     * @param strategy
     * @return
     */
    public static PositionStrategyHandle create(PositionStrategy strategy){
        switch (strategy){
            case STRICT_EXECUTE:
                return new StrictExecuteStrategyHandle();
            case IGNORE_EXCEPTION:
                return new IgnoreExceptionStrategyHandle();
            case THROWS_EXCEPTION:
                return new ThrowsExceptionStrategyHandle();
            default:
                throw new IllegalArgumentException("UNKNOWN strategy="+strategy.toString());
        }
    }
}

六、后置规则的反算机制

后来随着业务场景的发展，为了改善用户交互上的体验度，我们又研发设计出反算机制。

反算坦白讲，是为了解决，倘若若干输入参数如果命中一条配置，我们期望不是返回提示信息，而是引导用户调整相关输入项的大小，以达到最终满足业务场景规则，其宗旨就是让你的业务流程友好的走下去。

反算配置交互案例

七、尾语

经过几次重构后，实现前置规则与后置规则在金融产品平台的配置化。我们不仅解放了研发人员，他们不用再面向存储过程或SQL开发；更方便了产品人员，他们可以快速支持业务调整。我们实现金融产品的前后置规则配置化，可视化，这是一个质的变化。

金融产品团队相关业务系统整体架构图

秋夜无霜

秋夜无霜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何设计一套规则引擎系统
nineyang的博客
05-09 2185
很早之前就想写一篇关于「规则引擎」的文章，但是一直苦于没有时间。刚好最近给团队小伙伴梳理了我设计的引擎的使用和原理，正好借此机会在此写下我们的心得。 「规则引擎」系统一般而言，在风控中使用较多，但是经过调研，我们发现，其实在业务系统中，对于规则引擎系统的渴求度更大，甚至于，我在脉脉上都看到好几个人在咨询业务规则引擎系统应该如何设计和接入。 首先来聊一下痛点。为什么对于规则引擎系统的渴求度这么大？ 缺点 业务条件繁杂 试想一下，或者说正是你所经历的，在我们的业务逻辑中，有很多很多很多的业务条件判断，而这些业务
规则引擎产品特点
wangmengqz的专栏
08-26 5372
完整规则管理系统     规则引擎以规则库为基础，规则编辑器为规则录入窗口，规则引擎为动力，辅以规则协同管理、远程项目与服务管理、集群规则同步等功能模块。帮助企业打造一套完整的商业规则定制与管理平台。 执行速度快    规则引擎产品有三种执行方式：基于Rete算法推理式、顺序执行、静态顺序执行。基于Rete算法推理式是绝大多数产品采用的一种方式。此种方式基于Rete算法进行模式匹
物联网规则引擎设计
xw2sy的博客
12-14 2064
监听器 定义数据源获取方法，通过监听条件对输入消息进行过滤，输出符合条件的消息。 过滤条件 对监听到消息之外的数据进行判断是否要执行下一步。 动作定义 对满足条件的数据进行处理。
flink规则引擎设计思路
最新发布
帆了个帆的专栏
01-11 3276
在我们的规则引擎里，数据主体通常作为关联数据的主键id，所以在数据预处理阶段，我们需要尽可能的将数据主体梳理全，并补充到数据中。这里就需要介绍下”维度数据“模块。
车金融|金融产品规则引擎的前世今生（中篇）
秋夜无霜
11-29 372
在车金融业务场景中，金融方案以资方为大维度。资方准入规则，进一步对进件的客户信息、车辆信息、贷款意向进行了场景条件控制，因此，资金方准入规则对于金融产品来讲，也是必不可少了，它构成了金融产品规则引擎的一部分。 车金融前世今生专辑连载系列，关注微信公众号【秋夜无霜】 车金融|金融产品中心的前世今生 车金融|GPS审核系统的前世今生 车金融|基础数据平台的前世今生 车金融|合同中心系统的前世今生 车金融|金融产品规则引擎的前世今生（上篇）(撰稿中，敬请期待) 车金融|金融产品规则引擎的前世今生（中篇）(撰.
规则引擎的发展研究
chidan8471的博客
12-12 591
基于规则引擎技术逐渐成为各类风控系统的建设的首选方案。规则引擎是一种嵌入在应用程序中的组件，从基于专家系统中的推理引擎发展而来。它的核心思想是将复杂多变的规则从业务流程中解放出来，以规则脚本的形式存放在文件中或者数据库，引擎工作时动态的加载规则，使用规则引擎的应用实现了业务规则...
RocketMQ事务消息实现原理分析
程序员小潘
09-13 2091
1. 前言 RocketMQ采用2PC的思想，实现了Producer发送「事务消息」。事务消息的提交分为两个阶段，阶段一，Producer发送半事务(Half)消息到Broker，Broker存储消息，然后响应消息写入结果，此时消息对Consumer是不可见的。阶段二，Producer根据消息发送结果做对应的处理，如果消息发送成功，则开始执行本地事务，并提交事务状态给Broker，事务状态有三种，对应的Broker动作为： COMMIT_MESSAGE：事务提交，消息对Consumer可见。 ROLLBA
复杂风控场景下，如何打造一款高效的规则引擎
美团技术团队
05-14 9877
总第393篇2020年 第16篇|本文转载自【美团安全应急响应中心】公众号，欢迎大家关注。在互联网时代，安全已经成为企业的命脉。美团信息安全团队需要采用各种措施和手段来保障业务安全，从...
事务消息
93张先生
02-03 971
总览 RocketMQ事务消息（Transactional Message）是指应用本地事务和发送消息操作可以被定义到全局事务中，要么同时成功，要么同时失败。RocketMQ的事务消息提供类似 X/Open XA 的分布事务功能，通过事务消息能达到分布式事务的最终一致。 RocketMQ 事务消息设计则主要是为了解决 Producer 端的消息发送与本地事务执行的原子性问题，RocketMQ 的设计中 broker 与 producer 端的双向通信能力，使得 broker 天生可以作为一个事务协调者存在；
规则引擎实战篇-------银行贷款业务处理1
qq1026605798的博客
08-28 3700
前面的文章一直在介绍规则引擎的各种常用功能，接下来我们将前面介绍的功能结合实际业务来使用。 具体业务场景如下： 某银行发放贷款原则如下：      1。对于贷款未超过限额的客户，允许立即贷款。      2。对于贷款超过限额的客户，若过去还款记录好且本次贷款在12万元以下，可作出贷款安排；否则拒绝贷款。     根据上面的要求我们绘制出如下决策表： 决策表优化后：
规则引擎简介
chy1984的博客
04-07 2218
目录概述优缺点应用场景引入方式常见的规则引擎   概述 规则引擎，全称 Business Rule Management System（BRMS）业务规则管理系统，主要思想是将业务决策|业务规则从应用程序中分离出来，使用预定义的语义模块编写业务决策|业务规则，在需要时进行配置、管理。 引入规则引擎后，业务规则不再以硬编码在业务处理代码中，而是完全独立于应用程序，存储在规则库|知识库（常见的比如drl文件、数据库）中。业务规则被加载到规则引擎中供应用系统调用，业务人员可以像管理数据一样对业务规则进行
规则引擎预研
qq_32532853的博客
12-15 1338
我们要增加一个检查商户的输入商品介绍有没有不合规的单词的功能，淘宝也有类似的功能。这个规则是需要根据线上的用户输入不断更新的，这个逻辑放到代码里面是不合适的，需要查找一个规则引擎。 之前就了解过规则引擎，从网上搜了一下drools，看了它的优缺点，我觉得最主要的缺点是，1.学习成本高，有的人光学习部署他就花了3个月，规则语言学习起来和学习一门新的语言差不多了。2.规则生成的代码没有办法单步调试。
【技术分享】规则引擎
王璐
11-06 2772
又是周末技术分享的日子，今天给我们分享的师哥曾经在互联网金融公司工作，所以分享了互联网金融领域使用广泛的——规则引擎。短短一个多小时的分享，我只记下来一部分相关的知识，所以写到博客里，待自己之后能够在今天的基础上更好的理解和认识规则引擎。   应用领域                            规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序
几个常见规则引擎的简单介绍和演示
weixin_30695195的博客
10-27 2750
Ilog JRules是最有名的商用BRMS； Drools是最活跃的开源规则引擎； Jess是Clips的java实现，就如JRuby之于Ruby，是AI系的代表； Visual Rules（旗正规则引擎）国内商业规则引擎品牌。 今天对比了一下这四个颇有代表性的规则引擎的规则语言。其中Ilog和visual rules是商业产品，没有机会实战。 1.一样的If--The...
规则引擎的应用及发展
weixin_34192816的博客
10-18 152
前言 最传统的软件是揉杂在一起的，1970年代为了更好的方便开发，程序员将数据库份离出来，方便信息的存储。1980年代，应用层分离出展示层，使得产品更加优化，人性化，而1990年代后，使用规则引擎将业务规则分离单独管理，使得业务系统能够更加灵活变动，响应速度更加快速，旗正商业规则管理平台正式业务规则的管理专家 规则引擎由推理引擎发展而来，是一种嵌入在应用...
python 使用@run_on_executor 创建线程，后台执行并check（2）
热门推荐
freewebsys的专栏
11-23 1万+
1，后台执行第二个方法本文的原文连接是: http://blog.csdn.net/freewebsys/article/details/78617643 未经博主允许不得转载。 博主地址是：http://blog.csdn.net/freewebsys之前写过一个博客。 http://blog.csdn.net/freewebsys/article/details/78607822 使用
在流程和节点中引入规则引擎
规则引擎
05-27 2204
规则引擎的功能和特点是在不改变流程,不重新部署工程的情况下,动态的配置策略信息,修改策略逻辑.达到动态的业务配置目的。 举一个简单的例子.一个销售机构销售一种商品,当该商品的数量小于100的时候不需要运输部门负责运输,则不需要通知运输部门。但是当大于100的时候则需要运输部门负责运输，但有的时候这个100的数量是可变的，有的时候是150，有的时候甚至是200。但是这个数量如果写在了Code里，就
规则引擎之 行业工程应用
fmclx的专栏
09-30 779
规则引擎之 工程应用 规则引擎+ ： 规则引擎在各行业、各领域的实际应用，发挥人工智能的威力。 规则引擎需求 （网摘） 规则引擎需求 捕捉和沟通复杂的业务规则 Benjamin A. Lieberman, Ph.D., 首席架构师, BioLogic Software Consulting, LLC 简介： 业务软件系统通常要处理复杂的重复
【设计模式活用】之金融产品中心之设计模式的应用案例
秋夜无霜
11-19 1470
本文阐述如何运用设计模式在代码设计中的应用，通过案例说明介绍。本文涉及的业务需求场景有：计算引擎、资金方准入、产品规则准入、产品费用项重置。通过案例引用的设计模式包括：模板方法模式、责任链模式、策略模式、工厂方法模式、中介者模式、观察者模式。 1、设计原则的应用意义 2、揭秘计算引擎的设计理念 目前金融产品的核心是面向车贷放款前车贷总金额的公式，因此其根本也就是围绕着车贷费用项的计算，这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值