规则引擎

什么是规则引擎

业务场景一般都是杂糅繁复的，于是代码很容易就互相嵌套、错综复杂、结构不清晰，同时维护成本高，可读性可拓展性差

规则引擎：整合了传入系统的Fact集合和规则集合，以推出结论。可以理解为当下一些状态集合（有限状态机）的情况下，去触发（推论出）一个或多个业务操作，可以表示为“在某些条件下，执行某些任务”

在拥有大量规则和Fact对象的业务系统中，可能会出现多个Fact输入都会导致同样的输出，这种情况通常称作规则冲突。规则引擎可以以下冲突解决方案来确定冲突规则的执行顺序：

正向链接：（基于“数据驱动”的形式），规则引擎利用可用的Fact推理规则来提取出更多的Fact对象，直到计算出最终目标，最终会有一个或多个规则被匹配，并执行。因此，始于事实，始于结论。

反向链接：（基于“目标驱动”的形式），从规则引擎假设的结论开始，如果不能够直接满足这些假设，则搜索可满足假设的子目标。规则引擎会循环执行这一过程，直到证明结论或没有更多可证明的子目标为止

规则引擎可以被视为复杂的if / then语句解释器。if部分表示处理条件；then部分表示执行的操作

举个栗子（json-rules-engine）

let a = 3;
if (a > 2) {
  console.log('a大于2');
} else {
  console.log('a小于等于2');
}
// 用规则引擎怎么写
// 描述 if (a > 2) console.log('a大于2')
const rule0 = {
// 描述 if (a > 2)
conditions: {
  all: [
    {
      fact: 'a',
      operator: 'gt',
      value: 2
    }
  ]
},
// 描述 console.log('a大于2')
event: {
  type: 'console',
  params: {
    message: 'a大于2'
  }
}
// 描述 if (a <= 2) console.log('a小于等于2')
const rule1 = {
// 描述 if (a <= 2)
conditions: {
  all: [
    {
      fact: 'a',
      operator: 'lt&equal',
      value: 2
    }
  ]
},
// 描述 console.log('a小于等于2')
event: {
  type: 'console',
  params: {
    message: 'a小于等于2'
  }
}

规则写好了，怎么添加上去呢？

import { Engine } from 'json-rules-engine';
const engine = new Engine();
engine.addRule(rule0);
engine.addRule(rule1);

除了添加规则，其实还能自定义一些FACT、操作符等

engine.addFact('account-type', function getAccountType(params, almanac) {
  // ...
})
engine.addOperator('startsWithLetter', (factValue, jsonValue) => {
  if (!factValue.length) return false
  return factValue[0].toLowerCase() === jsonValue.toLowerCase()
})

使用 engine.run() 将规则引擎驱动起来
可以通过 engine官方文档 查看更多用法

实用场景：权限控制

config.beforeEach((to, from, next) => {
  (async() => {
    try {
      // 获取当前用户信息
      const user = await getCurrUserInfo();

      if (to.path.startsWith('\/a')) {
        // 只有管理员可以打开 a 页面
        if (user.isAdmin()) {
          next();
        } else {
          next({ name: 'Denied', message: '您不是管理员无法打开此页面' });
        }
      } else if (to.path.startsWith('\/b')) {
        // 团队1、2、3 内成员可以打开 b 页面
        if (
          user.isMemberOf('团队1') ||
          user.isMemberOf('团队2') ||
          user.isMemberOf('团队3')
        ) {
          next();
        } else {
          next({ name: 'Denied', message: '您不是团队1、2、3中任意一个团队的成员，无法打开此页面' });
        }
      } else if (to.path.startsWith('\/c')) {
        // 团队C内成员，可以打开处于可用状态的 c 页面
        const c = await getInfoForWarPage();
        if (
          user.isMemberOf('团队C') &&
          c.isAble()
        ) {
          next();
        } else {
          next({ name: 'Denied', message: '您不是团队C的成员，或 c 页面当前禁用，无法打开该页面' });
        }
      } else {
        // 没有做权限控制的页面
        next({ name: 'Denied' });
      }
    } catch (err) {
      next({ name: 'Denied' });
    }
  })();
});

从上述代码可以看出其拓展性差，if 嵌套深，功能杂糅。现在可以根据引擎模板的思路改造一下：
FACT和规则集合：to.path.startsWith('\/a')、to.path.startsWith('\/b')、to.path.startsWith('\/c') 、user.isAdmin()、user.isMemberOf('团队1') || user.isMemberOf('团队2') || user.isMemberOf('团队3')、user.isMemberOf('团队C') && c.isAble()
推论：{ name: 'XXX', message: 'XXX' }（next()是vue-router的用法）

// oper/starts_with.js'
// 操作符 operate
export function operStartsWith(factValue, jsonValue) {
  return factValue.startsWith(jsonValue);
}

// fact/is_admin.js'
// 异步事实 fact 可以通过 [almanac官方文档](https://github.com/CacheControl/json-rules-engine/blob/master/docs/almanac.md) 查看更多用法
const user = await getCurrUserInfo();
export async function factIsAdmin(params, almanac) {
  const user = await almanac.factValue('user');
  return user.isAdmin();
}

// fact/is_member_of.js'
const user = await getCurrUserInfo();
export async function factIsMemberOf(params, almanac) {
  const teams = params.teams || [];
  const user= await almanac.factValue('user');
  return teams.some(team => user.isMemberOf(team));
}

// fact/is_c_able.js'
const user = await getCurrUserInfo();
export async function factIsCAble(params, almanac) {
  const c = await getInfoForCPage();
  return c.isAble();
}

// rule/a.js'
const ruleFoo0 = {
  conditions: {
    all: [
      {
        fact: 'path',
        operator: 'startsWith',
        value: '/a'
      },
      {
        fact: 'isAdmin',
        operator: 'equal',
        value: true
      }
    ]
  },
  event: {
    type: 'auth',
    params: {
      perm: true
    }
  }
}
const ruleFoo1 = {
  conditions: {
    all: [
      {
        fact: 'path',
        operator: 'startsWith',
        value: '/a'
      },
      {
        fact: 'isAdmin',
        operator: 'notEqual',
        value: true
      }
    ]
  },
  event: {
    type: 'auth',
    params: {
      perm: false,
      msg: '您不是管理员无法打开此页面'
    }
  }
}

// rule/b.js'

const ruleB0 = {
  conditions: {
    all: [
      {
        fact: 'path',
        operator: 'startsWith',
        value: '/b'
      },
      {
        fact: 'isMemberOf',
        params: {
          teams: [
            '团队1',
            '团队2',
            '团队3'
          ]
        },
        operator: 'equal',
        value: true
      }
    ]
  },
  event: {
    type: 'auth',
    params: {
      perm: true
    }
  }
}
const ruleB1 = {
  conditions: {
    all: [
      {
        fact: 'path',
        operator: 'startsWith',
        value: '/b'
      },
      {
        fact: 'isMemberOf',
        params: {
          teams: [
            '团队1',
            '团队2',
            '团队3'
          ]
        },
        operator: 'notEqual',
        value: true
      }
    ]
  },
  event: {
    type: 'auth',
    params: {
      perm: false,
      msg: '您不是团队1、2、3中任意一个团队的成员，无法打开此页面'
    }
  }
}

// rule/c.js'
const ruleC0 = {
  conditions: {
    all: [
      {
        fact: 'path',
        operator: 'startsWith',
        value: '/c'
      },
      {
        fact: 'isMemberOf',
        params: {
          teams: [
            '团队C'
          ]
        },
        operator: 'equal',
        value: true
      {
        fact: 'isCAble',
        operator: 'equal',
        value: true
      }
    ]
  },
  event: {
    type: 'auth',
    params: {
      perm: true
    }
  }
}
const ruleC1 = {
  conditions: {
    all: [
      {
        fact: 'path',
        operator: 'startsWith',
        value: '/c'
      },
      {
        fact: 'isMemberOf',
        params: {
          teams: [
            '团队C'
          ]
        },
        operator: 'notEqual',
        value: true
      },
      {
        fact: 'isCAble',
        operator: 'notEqual',
        value: true
      }
    ]
  },
  event: {
    type: 'auth',
    params: {
      perm: false,
      msg: '您不是团队C的成员，或 c 页面当前禁用，无法打开该页面'
    }
  }
}

// 入口
import operStartsWith from './oper/starts_with';
import factIsAdmin from './fact/is_admin';
import factIsMemberOf from './fact/is_member_of';
import factIsCAble from './fact/is_c_able';
import { ruleFoo0, ruleFoo1 } from './rule/a';
import { ruleBar0, ruleBar1 } from './rule/b';
import { ruleWar0, ruleWar1 } from './rule/c';

async function getPerm (to, from) {
  const engine = new Engine();

  engine.addOperator('startsWith', operStartsWith);
  engine.addFact('isAdmin', factIsAdmin);
  engine.addFact('isMemberOf', factIsMemberOf);
  engine.addFact('isCAble', factIsCAble );
  engine.addRule(ruleA0);
  engine.addRule(ruleA1);
  engine.addRule(ruleB0);
  engine.addRule(ruleB1);
  engine.addRule(ruleC0);
  engine.addRule(ruleC1);

  const user = await getCurrUserInfo();
  const ret = await engine.run({ user, path: to.path })

  if (ret.events.length) {
    return ret.events[0].params;
  } else {
    return { perm: false, msg: '没有做权限控制的页面禁止打开' }
  }
}

// router.config.js
import getPerm from './auth/index.js'; // 入口
config.beforeEach((to, from, next) => {
  try {
    const ret = await getPerm(to, from);

    if (ret.perm) {
      next();
    } else {
      next({
        name: 'Denied',
        params: {
          title: '访问受限',
          message: ret.msg || '请检查您的权限以确保可以打开此页面'
        }
      });
    }
  } catch (err) {
    console.error(err);
    next({
      name: 'Denied',
      params: {
        title: '访问受限',
        message: `发生未知错误 ${err.message}`
      }
    });
  }
});

之后新增路由只需要新增其对应的文件以及规则即可，后续如果后台支持的情况下，这些配置文件可直接入库（JSON格式），前端需要调整的地方不多，可延展性好，当然还有改进的点。。。

补充：priority 对于提升规则匹配的性能十分显著。
如果没有设置 priority，所有规则都相当于一个个微任务，并发执行。当设置了 priority，那么相同 priority 的规则会组合成一个新的队列，根据优先级执行。因此将重要的规则排在前面，就可以很好的优化性能

参考文档：json-rules-engine