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

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

在车金融业务场景中，金融方案以资方为大维度。资方准入规则，进一步对进件的客户信息、车辆信息、贷款意向进行了场景条件控制，因此，资金方准入规则对于金融产品来讲，也是必不可少了，它构成了金融产品规则引擎的一部分。

秋夜无霜

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

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

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

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

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

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

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

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

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

温馨提示：全文共计2500余字，乃上班地铁途中码字编写，素材代码则是周末抽出时间整理，实属不易，感谢关注。起草于2020年11月26日，终稿于2020年11月29日。

文章目录

一、导读

上一篇，我们从金融产品规则引擎讲述了规则引擎的前后置规则发展史，这一篇我们将重点讲述资方准入规则的发展历程以及技术方案设计。

二、“黑暗”时期

最初金融产品内部并没有资方以及准入规则的，恰当是，车金融各个业务系统为了实现对于资方的业务逻辑控制，所采取的的方案是通过判断金融方案名称中是否包含某资方字样。常规来讲，倘若金融方案名称命名严格按照某种规范，还能说过去。但是一旦出现命名不按照常规出牌，那业务系统肯定出bug，事实上讲，最初也曾经出现因为名称导致的故障，这也反应最初的设计不合理性而最终导致悲剧发生。

此刻的你，是否曾经遇到这种设计挣扎，为了一时的简单设计或者考虑欠佳，从此留下了诟病，这种诟病进而在需求迭代或者人员更迭中，不经意间catch到一个bug。这也告诫我们，作为程序员，需要敬畏手中的代码编写权利，多思考，少写bug，相信有一天你会感慨，多亏曾经的自己志明抉择。

三、发展时期

2018年下半年，车金融业务线APP进行了第一次重构，这次对于金融产品系统来讲，产品提出了资金方以及资方准入规则的需求设计。相信它来的为时不晚，为拯救车金融“黎民百姓”带来了曙光。

此时，金融产品中心已完成了一次重构，拆分出金融产品平台(car-product)和金融产品服务(car-heil)，这也为APP重构奠定基础，促进了业务流程对于审核效率以及改善交互体验的提升。

需求设计上，对于金融产品系统来讲，增加了资金方管理、资方准入规则配置，然而，对于主导金融产品技术设计的我，为设计良好的技术方案下了一番心思。

四、需求分析

资方准入规则，是从资方纬度进行配置的，可以配置若干条规则。每条规则又包含若干项，譬如对于主贷人，包含年龄、户籍、薪资等；对于车辆来讲，车类，如果是二手车，包括车龄、里程；对于贷款意向，包括首付比，贷款金额，贷款总额，实际销售价等。

资方准入规则

对于APP上来讲，资方准入规则需要把每一项命中规则的文案列举出来，比如，主贷人信息：年龄不符合（20～60）岁。当我分析需求时，在技术方案设计时，我分析梳理考虑的有以下几点：

  • 每一项属于不同的大类，譬如主贷人，车辆，贷款信息，肯定返回的项必须携带具体哪个分类，以更友好精确地提示APP用户，这是比较重要的。
  • 每一项通过进一步分类，可以分类两种类型区间类和范围类，比如区间类，首付比（30％～100％）；比如范围类，车类（LCV、乘用车）。
  • 这两种类型进一步提取，可以分类数值类和字符类。
  • 这些规则条件倘若按照属性-属性值的关系维护到一张子表中，那么对于主贷人信息中的户籍可不就是这么简单，它的存储跟这些并不是同类，这意味着需要再划分一个子表。
  • 这些规则分类项，我维护是通过Java枚举维护，但是数据库存储的是枚举索引，对于APP接口返回肯定是枚举值。
  • 对于准入规则输入项，输入参数传值有的并非枚举索引，而是索引值。

准入规则配置

五、核心设计

通过梳理分析，在代码实现上，我觉得可以引入设计模式，更好的完成代码设计，同时又能提高代码扩展性，支撑后续的需求场景变更。

我把主贷人信息(ProposerAccessHandler)，车辆信息(CarInfoAccessHandler)，贷款意向信息(LoanAccessHandler)划分为三个子类处理各自规则配置项，这三个子类完成各自规则子项的检验，子类的关系通过一个责任链串起来。同时，把规则条件进一步进行了抽象（AbstractStrategy），并通过一个枚举类实现字段的映射配置MapperConfig，具体详见如下核心代码。

总体核心交互时序图

1.准入规则处理器（AbstractAccessHandler）

准入规则配置

如上三个处理器。

AbstractAccessHandler

/**
 * @description: 准入处理器
 * @Date : 2018/7/7 下午7:45
 * @Author : 石冬冬-Seig Heil
 */
public abstract class AbstractAccessHandler {

    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
    /**
     * 处理器名称
     */
    protected String handlerName;
    /**
     * 上下文
     */
    protected FundAccessContext context;
    /**
     * 下一个节点
     */
    protected AbstractAccessHandler next;

    public AbstractAccessHandler(String handlerName, AbstractAccessHandler next) {
        this.handlerName = handlerName;
        this.next = next;
    }

    /**
     * 调用方法
     * @param context
     */
    public final void execute(FundAccessContext context){
        this.prepare(context);
        this.call();
        this.after();
    }

    /**
     * 处理请求
     */
    public abstract void call();

    /**
     * 初始化
     * @param context
     */
    public final void prepare(FundAccessContext context){
        this.context = context;
    }

    /**
     * 后置处理
     */
    public final void after(){
        if(null != next){
            next.execute(this.context);
        }
    }

    /**
     * 是否有下一个节点
     * @return
     */
    public boolean hasNext() {
        return null != next;
    }

    /**
     * 准入处理
     */
    protected final void access(MapperConfig.MapperEnumInterface[] values){
        try {
            FundAccessDTO accessDTO = context.getAccessDTO();
            Map<String,Object> beanMap = BeanMapper.objectToMap(accessDTO);
            //主贷人其他字段准入校验
            for(MapperConfig.MapperEnumInterface accessEnum : values){
                final boolean hasSkipCondition = null != accessEnum.skipCondition() && !"".equals(accessEnum.skipCondition());
                if(hasSkipCondition) {
                    AviatorContext ctx = AviatorContext.builder().expression(accessEnum.skipCondition()).env(beanMap).build();
                    if (AviatorExecutor.executeBoolean(ctx)){
                        continue;
                    }
                }
                String fileName = accessEnum.filed();
                boolean emptyValue = null == beanMap.get(fileName) || "".equals(beanMap.get(fileName));
                if(accessEnum.filter() || emptyValue){
                    continue;
                }
                StrategyContext strategyContext = new StrategyContext(context);
                AbstractStrategy strategy = SimpleStrategyFactory.create(strategyContext,accessEnum);
                strategy.access();
                if(!strategyContext.isAccess()){
                    context.getMessages().add(strategyContext.getTips());
                }
            }
            context.setAccess(context.getMessages().size()==0);
        } catch (Exception e) {
            logger.error("{}处理异常",handlerName,e);
        }
    }
    protected final String formatMessage2Collection(String message, Collection<String> collection){
        return MessageFormat.format(message,collection.stream().map(Object::toString).collect(Collectors.joining(",")));
    }
}

CarInfoAccessHandler

/**
 * @description: 车辆信息准入Handler
 * @Date : 2018/7/8 上午10:39
 * @Author : 石冬冬-Seig Heil
 */
public class CarInfoAccessHandler extends AbstractAccessHandler {

    public CarInfoAccessHandler(String handlerName, AbstractAccessHandler next) {
        super(handlerName, next);
    }

    @Override
    public void call() {
        try {
            super.access(MapperConfig.CarAccessEnum.values());
        } catch (Exception e) {
            logger.error("{}处理异常",handlerName,e);
        }
    }
}

2.准入规则责任链（AbstractAccessExecutor）

AbstractAccessExecutor

/**
 * @description:
 * @Date : 2018/7/7 下午7:16
 * @Author : 石冬冬-Seig Heil(dondongshi5@creditease.cn)
 */
public abstract class AbstractAccessExecutor implements ChainExecutor{
    /**
     * 上下文
     */
    protected FundAccessContext context;
    /**
     * 处理器集合
     */
    protected List<AbstractAccessHandler> handlerList;

    /**
     * 构造器
     * @param context
     */
    public AbstractAccessExecutor(FundAccessContext context) {
        this.context = context;
    }

    /**
     * 初始化
     */
    protected void prepare(){
        buildChain();
    }

    @Override
    public void execute() {
        this.prepare();
        handlerList.forEach(current -> {
            if(current.hasNext()){
                current.execute(context);
            }
        });
    }
}

FundAccessExecutor

/**
 * @description: 资金准入执行器
 * @Date : 2018/7/8 上午11:36
 * @Author : 石冬冬-Seig Heil
 */
public class FundAccessExecutor extends AbstractAccessExecutor {
    /**
     * 构造器
     *
     * @param context
     */
    public FundAccessExecutor(FundAccessContext context) {
        super(context);
    }

    @Override
    public void buildChain() {
        this.handlerList = new ArrayList<>(3);
        this.handlerList.add(
                new ProposerAccessHandler("主贷人准入",new CarInfoAccessHandler("车辆准入",new LoanAccessHandler("车贷准入",null))));
    }
}

3.规则条件策略（AbstractStrategy）

规则条件策略UML类图

AbstractStrategy

/**
 * @description: 抽象策略类
 * @Date : 2018/7/11 下午12:01
 * @Author : 石冬冬-Seig Heil
 */
public abstract class AbstractStrategy {
    protected final String EMPTY = "";
    protected final String ZERO_STR = "0";
    /**
     * 规则枚举
     */
    protected MapperConfig.MapperEnumInterface accessEnum;
    /**
     * 策略上线文对象
     */
    protected StrategyContext strategyContext;
    /**
     * 要校验的数据对象Map容器
     */
    protected Map<String,Object> beanMap;
    /**
     * 数据规则对象Map容器
     */
    protected Map<String,Object> propMap;
    /**
     * 存储数据字典Map容器
     */
    protected Map<String,Map<String, String>> dictMap;
    /**
     * 规则数据业务实体对象
     */
    protected FundRuleDataBo dataBo;
    /**
     * 字段名称
     */
    protected String filedName;
    /**
     * 校验消息
     */
    protected String tips;
    /**
     * 是否准入通过
     */
    protected boolean access;

    public AbstractStrategy(MapperConfig.MapperEnumInterface accessEnum, StrategyContext strategyContext) {
        this.accessEnum = accessEnum;
        this.strategyContext = strategyContext;
    }

    /**
     * 抽象方法，需要子类实现
     */
    protected abstract void accept();

    /**
     * 初始化
     */
    protected final void init(){
        FundAccessContext accessContext = strategyContext.getAccessContext();
        this.beanMap = BeanMapper.objectToMap(accessContext.getAccessDTO());
        this.dataBo = accessContext.getFundRuleDataBo();
        this.propMap = dataBo.getPropMap();
        this.dictMap = dataBo.getDictMap();
        filedName = accessEnum.filed();
    }

    /**
     * 外部调用方法
     */
    public final void access(){
        init();
        accept();
        after();
    }

    /**
     * 后置处理
     */
    public final void after(){
        this.strategyContext.setAccess(access);
        this.strategyContext.setTips(tips);
    }

    protected final String formatMessage(String message,Object...values){
        return MessageFormat.format(message,values);
    }
    protected final String formatMessage2Collection(String message, Collection<Object> collection){
        return MessageFormat.format(message,collection.stream().map(Object::toString).collect(Collectors.joining(",")));
    }
}

AbstractRangeStrategy

/**
 * @description: 抽象 区间类 策略类
 * @Date : 2018/7/11 下午12:14
 * @Author : 石冬冬-Seig Heil
 */
public abstract class AbstractRangeStrategy extends AbstractStrategy implements RangeValue<Map<String,Object>,Number> {

    protected final String MIN = "Min";
    protected final String MAX = "Max";

    public AbstractRangeStrategy(MapperConfig.MapperEnumInterface accessEnum, StrategyContext strategyContext) {
        super( accessEnum, strategyContext);
    }

    @Override
    protected void accept() {
        String message = accessEnum.message();
        BigDecimal srcValue = new BigDecimal(Objects.toString(beanMap.get(filedName),ZERO_STR));
        BigDecimal min = (BigDecimal)min(propMap);
        BigDecimal max = (BigDecimal)max(propMap);
        srcValue = new BigDecimal(Objects.toString(beanMap.get(filedName),ZERO_STR));
        access = srcValue.compareTo(min) >= 0 && max.compareTo(srcValue) >= 0;
        if(!access){
            tips = formatMessage(message,min,max);
        }
    }
}

AbstractScopeStrategy

/**
 * @description: 抽象 范围类 策略类
 * @Date : 2018/7/11 下午12:14
 * @Author : 石冬冬-Seig Heil
 */
public abstract class AbstractScopeStrategy extends AbstractStrategy implements ScopeValue<Map<String,Object>,Object> {

    public AbstractScopeStrategy(MapperConfig.MapperEnumInterface accessEnum, StrategyContext strategyContext) {
        super( accessEnum, strategyContext);
    }

    @Override
    protected void accept() {
        MapperConfig.EnumType enumType = accessEnum.enumType();
        String message = accessEnum.message();
        EnumValue[] enumValues = accessEnum.enums();
        String srcValue = Objects.toString(beanMap.get(filedName),EMPTY);
        List<Object> desValues = scope(propMap);
        access = desValues.contains(srcValue);
        if(access){
            return;
        }
        switch (enumType){
            case INDEX:
                message = formatMessage(message, EnumConvert.convertIndex2String(enumValues,desValues));
                break;
            case NAME:
                message = formatMessage(message, EnumConvert.convertIndex2String(enumValues,desValues));
                break;
            case DESC:
                message = formatMessage(message, EnumConvert.convertIndex2String((EnumDesc[]) enumValues,desValues, EnumDesc::getDesc));
                break;
            case DB:
                message = formatMessage(message, desValues.stream().map(d -> dictMap.get(filedName).get(d.toString())).collect(Collectors.joining(",")));
                break;
            default:
                message = formatMessage2Collection(message,desValues);
                break;
        }
        tips = message;
    }
}

DecimalRangeStrategy

/**
 * @description: 数字 区间类 策略类
 * @Date : 2018/7/11 下午12:14
 * @Author : 石冬冬-Seig Heil
 */
public class DecimalRangeStrategy extends AbstractRangeStrategy {

    public DecimalRangeStrategy(MapperConfig.MapperEnumInterface accessEnum, StrategyContext strategyContext) {
        super( accessEnum, strategyContext);
    }

    @Override
    public Number max(Map<String, Object> propMap) {
        return new BigDecimal(Objects.toString(propMap.get(filedName + MAX),ZERO_STR));
    }

    @Override
    public Number min(Map<String, Object> propMap) {
        return new BigDecimal(Objects.toString(propMap.get(filedName + MIN),ZERO_STR));
    }
}

StringScopeStrategy

/**
 * @description: 字符串 范围类 策略类
 * @Date : 2018/7/11 下午12:14
 * @Author : 石冬冬-Seig Heil
 */
public class StringScopeStrategy extends AbstractScopeStrategy {

    public StringScopeStrategy(MapperConfig.MapperEnumInterface accessEnum, StrategyContext strategyContext) {
        super( accessEnum, strategyContext);
    }

    @Override
    public List<Object> scope(Map<String, Object> propMap) {
        String desValue = Objects.toString(propMap.get(filedName),EMPTY);
        return StringTools.toList(desValue,Object.class);
    }
}

SimpleStrategyFactory

/**
 * @description: 策略简单工厂类
 * @Date : 2018/7/12 下午8:33
 * @Author : 石冬冬-Seig Heil(dondongshi5@creditease.cn)
 */
public final class SimpleStrategyFactory {
    /**
     * 创建方法
     * @param accessEnum
     * @return
     */
    public static AbstractStrategy create(StrategyContext strategyContext,MapperConfig.MapperEnumInterface accessEnum){
        AbstractStrategy strategy = null;
        MapperConfig.FiledType filedType = accessEnum.filedType();
        MapperConfig.ValueType valueType = accessEnum.valueType();
        if(MapperConfig.ValueType.STRING == valueType && MapperConfig.FiledType.SCOPE == filedType){
            strategy = new StringScopeStrategy(accessEnum,strategyContext);
        }
        if(MapperConfig.ValueType.DECIMAL == valueType && MapperConfig.FiledType.RANGE == filedType){
            strategy = new DecimalRangeStrategy(accessEnum,strategyContext);
        }
        return strategy;
    }

    private SimpleStrategyFactory(){}
}

4.规则字段配置(MapperConfig)

/**
 * @description: 规则字段映射枚举类
 * @Date : 2018/7/8 上午11:04
 * @Author : 石冬冬-Seig Heil
 */
public final class MapperConfig {
    /**
     * 主贷人准入
     * 年龄、从事行业、税后月收入、本人是否有驾照、户籍所在省份、户籍所在城市
     */
    public enum ProposerAccessEnum implements MapperEnumInterface{
        age(false,"age","主贷人准入:[年龄]不符合范围({0}~{1})",FiledType.RANGE,ValueType.DECIMAL,EnumType.NONE,null,null),
        nowIndustry(false,"nowIndustry","主贷人准入:[从事行业]不符合范围({0})",FiledType.SCOPE,ValueType.STRING,EnumType.NONE,null,null),
        provinceName(true,"provinceName","主贷人准入:[户籍所在省份]不符合({0})",FiledType.SCOPE,ValueType.STRING,EnumType.NONE,null,null),
        cityName(true,"cityName","主贷人准入:[户籍所在城市]不符合({0})",FiledType.SCOPE,ValueType.STRING,EnumType.NONE,null,null),
        //省略其他...
        ;
        private boolean filter;
        private String field;
        private String message;
        private FiledType filedType;
        private ValueType valueType;
        private EnumType enumType;
        private EnumValue[] enums;
        private String skipCondition;

        ProposerAccessEnum(boolean filter,String field, String message,FiledType filedType,ValueType valueType,EnumType enumType,EnumValue[] enums,String skipCondition) {
            this.filter = filter;
            this.field = field;
            this.message = message;
            this.filedType = filedType;
            this.valueType = valueType;
            this.enumType = enumType;
            this.enums = enums;
            this.skipCondition = skipCondition;
        }
        //省略 getter/setter
    }
    /**
     * 车辆信息
     * 是否二手车、车牌类型、车型、车龄(月)、里程
     */
    public enum CarAccessEnum implements MapperEnumInterface{
        carAge(false,"carAge","车辆准入:[二手车车龄]不符合({0}~{1})",FiledType.RANGE,ValueType.DECIMAL,EnumType.NONE,null,"isOld==0"),
        carAgeAddLoanPeriods(false,"carAgeAddLoanPeriods","车辆准入:[二手车车龄+贷款期限]不符合({0}~{1})",FiledType.RANGE,ValueType.DECIMAL,EnumType.NONE,null,"isOld==0"),
        carMiles(false,"carMiles","车辆准入:[二手车里程数]不符合({0}~{1})",FiledType.RANGE,ValueType.DECIMAL,EnumType.NONE,null,"isOld==0"),
        carType(false,"carType","车辆准入:[车型]不符合范围({0})",FiledType.SCOPE,ValueType.STRING,EnumType.NAME, ConstEnum.CarTypeEnum.values(),null),
        carLicenseType(false,"carLicenseType","车辆准入:[车牌类型]不符合范围({0})",FiledType.SCOPE,ValueType.STRING,EnumType.DB, null, null),
        //省略其他...
        ;
        //省略 fileds getter/setter
    }
    /**
     * 车贷信息
     * 还款期限、车贷金额、首付比
     */
    public enum LoanAccessEnum implements MapperEnumInterface{
        applyLoanPeriods(false,"applyLoanPeriods","车贷准入:[借款期限]不符合范围({0})",FiledType.SCOPE,ValueType.STRING,EnumType.INDEX, ConstEnum.LoanPeriodsEnum.values(),null),
        applyCarLoanAmount(false,"applyCarLoanAmount","车贷准入:[车辆借款金额]不符合({0}~{1})",FiledType.RANGE,ValueType.DECIMAL,EnumType.NONE,null,null),
         //省略其他...
        ;
        //省略 fileds getter/setter
    }

    /**
     * 枚举要实现的接口
     */
    public interface MapperEnumInterface{
        /**
         * 是否需要过滤，该字段不从pd_fund_rule_prop获取
         * @return
         */
        boolean filter();
        /**
         * 字段属性名称
         * @return
         */
        String filed();
        /**
         * 文案
         * @return
         */
        String message();
        /**
         * 字段类型
         * @return
         */
        FiledType filedType();
        /**
         * 字段值类型
         * @return
         */
        ValueType valueType();
        /**
         * 枚举取值类型
         * @return
         */
        EnumType enumType();
        /**
         * 对应枚举
         * @return
         */
        EnumValue[] enums();

        /**
         * 跳跃条件
         */
        String skipCondition();
    }

    /**
     * 枚举取值类型
     */
    public enum EnumType{
        INDEX, // 意味通过枚举维护，获取对应index属性
        NAME, // 意味通过枚举维护，获取对应name属性
        DESC, // 意味通过枚举维护，获取对应desc属性
        DB, // 意味着通过sy_arg_control 数据字典表维护，比如审批流程
        NONE // 意味着 非枚举字段，比如 贷款金额、年龄 这样的字段
    }

    /**
     * 字段类型枚举
     */
    public enum FiledType{
        SCOPE, //范围类，比如 车类、还款期限等
        RANGE //期间类，比如 年龄、贷款金额、税后月收入
    }

    /**
     * 字段值类型
     */
    public enum ValueType{
        STRING, // 字符串类型
        DECIMAL // 数字类型，包括 Integer,Long,BigDecimal等
    }
}

5.规则准入业务对象(FundRuleDataBo)

/**
 * @description: 资金方准入规则数据业务实体对象
 * @Date : 2018/7/7 下午6:34
 * @Author : 石冬冬-Seig Heil
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
public class FundRuleDataBo {
    /**
     * 规则属性实体对象
     */
    private Map<String,Object> propMap;
    /**
     * 户籍省份城市Map规则结构
     * <数据字典类型key，数据字典集合></>
     */
    private Map<String,Map<String, String>> dictMap;
    /**
     * 户籍省份城市Map规则结构
     * <省份，城市集合></>
     */
    private Map<String,List<String>> censusMap;
}

6.规则准入上下文对象(FundAccessContext)

/**
 * @description: 资金方规则准入上下文
 * @Date : 2018/7/5 下午3:48
 * @Author : 石冬冬-Seig Heil
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class FundAccessContext {
    /**
     * 准入是否通过
     */
    private boolean access;
    /**
     * 准入规则DTO对象
     */
    private FundAccessDTO accessDTO;
    /**
     * 资金方规则数据实体业务对象
     */
    private FundRuleDataBo fundRuleDataBo;
    /**
     * 校验信息
     */
    private List<String> messages = Lists.newArrayList();

    public FundAccessContext(boolean access, FundAccessDTO accessDTO, FundRuleDataBo fundRuleDataBo) {
        this.access = access;
        this.accessDTO = accessDTO;
        this.fundRuleDataBo = fundRuleDataBo;
    }
}

7.总结

  • MapperConfig：为新增或者调整规则条件字段提供了扩展性，同时对于修改返回app文案提供了统一管理配置。
  • AbstractAccessHandler：对分类处理规则提供了扩展性。

时序图

如上，是对外提供的api接口，到整个相关类的时序图。

六、尾语

坦白讲，这个资方准入规则是属于我代码设计值得称赞的一个模块，运用了（责任链、模板方法、策略、工厂）设计模式，保持灵活的扩展性和伸缩性，为后续需求迭代和开发维护奠定基础。

秋夜无霜

秋夜无霜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
车金融|金融产品规则引擎的前世今生（上篇）
秋夜无霜
11-28 386
金融产品规则引擎从重构到不断迭代优化，围绕着宗旨就是如何设计更灵活更有扩展性的方案，最终设计面向产品运营研发测试多角色多层次用户群体，因此平台更低的学习成本和易用性成为我们不断努力的目标，我们为实现这一目标在重构优化的历程中不断努力。 温馨提示：全文共计3800余字，乃上班地铁途中码字编写，实属不易，感谢关注。起草于2020年11月23日，终稿于2020年11月28日。 车金融前世今生专辑连载系列，关注微信公众号【秋夜无霜】 车金融|金融产品中心的前世今生 车金融|GPS审核系统的前世今生 车金融|基.
金融信贷业务-贷前整理
a1290123825的博客
02-28 1813
贷前开通授信是互联网金融信贷业务中是处于一个核心的基础的阶段，解决的最本质的问题就是不同的人和不同资金方的一个匹配定位；金融服务平台要对客户进行充分识别后，推送给不同风险偏好的资金方；平台对客户的识别能力直接影响到客户再资金通道的实际转化率； 当下各互联网公司因为在其相关业务领域（如电商、OTA、外卖等）内积累了大量的客户资源，已经拥有了大量客户特征、行为数据，所以在...
规则引擎简介
chy1984的博客
04-07 2218
目录概述优缺点应用场景引入方式常见的规则引擎   概述 规则引擎，全称 Business Rule Management System（BRMS）业务规则管理系统，主要思想是将业务决策|业务规则从应用程序中分离出来，使用预定义的语义模块编写业务决策|业务规则，在需要时进行配置、管理。 引入规则引擎后，业务规则不再以硬编码在业务处理代码中，而是完全独立于应用程序，存储在规则库|知识库（常见的比如drl文件、数据库）中。业务规则被加载到规则引擎中供应用系统调用，业务人员可以像管理数据一样对业务规则进行
规则引擎实战篇-------银行贷款业务处理1
qq1026605798的博客
08-28 3700
前面的文章一直在介绍规则引擎的各种常用功能，接下来我们将前面介绍的功能结合实际业务来使用。 具体业务场景如下： 某银行发放贷款原则如下：      1。对于贷款未超过限额的客户，允许立即贷款。      2。对于贷款超过限额的客户，若过去还款记录好且本次贷款在12万元以下，可作出贷款安排；否则拒绝贷款。     根据上面的要求我们绘制出如下决策表： 决策表优化后：
几个常见规则引擎的简单介绍和演示
weixin_30695195的博客
10-27 2750
Ilog JRules是最有名的商用BRMS； Drools是最活跃的开源规则引擎； Jess是Clips的java实现，就如JRuby之于Ruby，是AI系的代表； Visual Rules（旗正规则引擎）国内商业规则引擎品牌。 今天对比了一下这四个颇有代表性的规则引擎的规则语言。其中Ilog和visual rules是商业产品，没有机会实战。 1.一样的If--The...
【技术分享】规则引擎
王璐
11-06 2772
又是周末技术分享的日子，今天给我们分享的师哥曾经在互联网金融公司工作，所以分享了互联网金融领域使用广泛的——规则引擎。短短一个多小时的分享，我只记下来一部分相关的知识，所以写到博客里，待自己之后能够在今天的基础上更好的理解和认识规则引擎。   应用领域                            规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序
规则引擎预研
qq_32532853的博客
12-15 1338
我们要增加一个检查商户的输入商品介绍有没有不合规的单词的功能，淘宝也有类似的功能。这个规则是需要根据线上的用户输入不断更新的，这个逻辑放到代码里面是不合适的，需要查找一个规则引擎。 之前就了解过规则引擎，从网上搜了一下drools，看了它的优缺点，我觉得最主要的缺点是，1.学习成本高，有的人光学习部署他就花了3个月，规则语言学习起来和学习一门新的语言差不多了。2.规则生成的代码没有办法单步调试。
规则引擎实战篇-------银行贷款业务处理3
qq1026605798的博客
09-11 1285
上次我们简单地实现了银行贷款业务的功能，这次我们利用规则引擎来快速导出页面。 首先我们来看看对象库，设置好对象传入传出的关系后，我们导出页面 如图右键选择添加jsp页面 导出了本规则工程的jsp页面，为了方便，我重命名为1.jsp 选择页面后右键菜单，点击在浏览器中访问 页面是打开成功了，不过有点问题，它提示说yh.conf文件找不到，这是什么回事呢？
规则引擎是什么？最简单的解释
weixin_34121304的博客
11-16 906
在软件行业里面，规则引擎作为基础软件的一种，也是属于比较神秘的一种存在，这不是说出来大家都能了然的一款产品，甚至有很多的IT人，在听到这个词的时候，表现出来的也是一头雾水，“什么是规则引擎？”通常都会听到这样的问题。我记得在一次展会上，一个客户问规则引擎是什么？技术人员跟他聊了半个小时也没把他说明白。 我不是玩技术的，所以对于规则引擎的一些代码表现...
规则引擎在银行保险行业的对比报告
规则引擎
05-13 665
  引言   本文档为对旗正公司的规则产品在银行保险等金融领域的实际应用做出一个综合评估报告。根据实际的数据（商业生产数据）来为以下应用场景提供模型支撑，展现客观真实的报告结果，展现旗正规则产品的综合能力   应用场景   由于涉及商业机密，总体场景说明进行简化说明，取其中部分不连贯场景   场景层次说明          该场景是取自BPO客户的后台数据处理模块，共...
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 162
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
JAVA进阶补充
2301_80150315的博客
08-15 998
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Java基础之原反补码
u012135697的博客
08-14 540
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 885
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1125
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
【Spring框架】
m0_71941456的博客
08-18 825
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 454
【代码】springboot网上商品订单转手系统bootpf
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 445
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 1100
【代码】springboot旅游网站
总结常见报错信息
m0_68903702的博客
08-16 339
在@Controller注解中，返回的是字符串或者是字符串匹配的模板名称，即直接渲染视图，与html页面配合使用的，java后端的代码要结合html的情况进行渲染,使用model对象（或者modelandview）的数据将填充user视图中的相关属性，然后展示到浏览器；而在@RestController中，返回的应该是一个对象，即return一个user对象，这时，在没有页面的情况下，也能看到返回的是一个user对象对应的json字符串。情形一：若前端传入Json格式，后端使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值