JAVA可动态计算表达式的框架非常多，比如：spEL、Aviator、MVEL、EasyRules、jsEL等，这些框架的编码上手程度、功能侧重点及执行性能各有优劣，网上也有大把的学习资料及示例代码，我这里也不在赘述了，本文要介绍的是直接借助于JDK中自带的ScriptEngineManager，使用javascript Engine来动态计算表达式，编码简单及执行性能接近原生JAVA，完全满足目前我公司的产品系统需求（通过配置计算公式模板，然后将实际的值带入公式中，最后计算获得结果），当然在实际的单元测试中发现，由于本质是使用的javascript 语法进行表达式计算，若有小数，则会出现精度不准确的情况（网上也有人反馈及给出了相应的解决方案），为了解决该问题，同时又不增加开发人员的使用复杂度，故我对计算过程进行了封装，计算方法内部会自动识别出表达式中的变量及数字部份，然后所有参与计算的值均通过乘以10000转换为整数后进行计算，计算的结果再除以10000以还原真实的结果，具体封装的工具类代码如下：
public class JsExpressionCalcUtils {
private static ScriptEngine getJsEngine() {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
return scriptEngineManager.getEngineByName("javascript");
}
/**
* 普通计算，若有小数计算则可能会出现精度丢失问题，整数计算无问题
* @param jsExpr
* @param targetMap
* @return
* @throws ScriptException
*/
public static Double calculate(String jsExpr, Map<String, ? extends Number> targetMap) throws ScriptException {
ScriptEngine jsEngine = getJsEngine();
SimpleBindings bindings=new SimpleBindings();
bindings.putAll(targetMap);
return (Double) jsEngine.eval(jsExpr, bindings);
}
/**
* 精确计算，支持小数或整数的混合运算，不会存在精度问题
* @param jsExpr
* @param targetMap
* @return
* @throws ScriptException
*/
public static Double exactCalculate(String jsExpr, Map<String, ? extends Number> targetMap) throws ScriptException {
String[] numVars = jsExpr.split("[()*\\-+/]");
numVars = Arrays.stream(numVars).filter(StringUtils::isNotEmpty).toArray(String[]::new);
double fixedValue = 10000D;
StringBuilder stringBuilder = new StringBuilder();
for (String item : numVars) {
Number numValue = targetMap.get(item);
if (numValue == null) {
if (NumberUtils.isNumber(item)) {
jsExpr = jsExpr.replaceFirst("\\b" + item + "\\b", String.valueOf(Double.parseDouble(item) * fixedValue));
continue;
}
numValue = 0;
}
stringBuilder.append(String.format(",%s=%s",item, numValue.doubleValue() * fixedValue));
}
ScriptEngine jsEngine = getJsEngine();
String calcJsExpr = String.format("var %s;%s;", stringBuilder.substring(1), jsExpr);
double result = (double) jsEngine.eval(calcJsExpr);
System.out.println("calcJsExpr:" + calcJsExpr +",result:" + result);
return result / fixedValue;
}
}
如上代码所示，calculate方法是原生的js表达式计算，若有小数则可能会有精度问题,而exactCalculate方法是我进行封装转换为整数进行计算后再还原的方法，无论整数或小数进行计算都无精度问题，具体见如下单元测试的结果：
@Test
public void testJsExpr() throws ScriptException {
Map<String,Double> numMap=new HashMap<>();
numMap.put("a",0.3D);
numMap.put("b",0.1D);
numMap.put("c",0.2D);
//0.3-(0.1+0.2) 应该为 0.0，实际呢？
String expr="a-(b+c)";
Double result1= JsExpressionCalcUtils.calculate(expr,numMap);
System.out.println("result1:" + result1);
Double result2= JsExpressionCalcUtils.exactCalculate(expr,numMap);
System.out.println("result2:" + result2);
}
result1:-5.551115123125783E-17 ---这不符合预期结果
calcJsExpr:var a=3000.0,b=1000.0,c=2000.0;a-(b+c);,result:0.0
result2:0.0 ---符合预期结果
2021-01-19补充，经过实际多场景测试，发现上述JS表达式（取整再运算）并未达到实际效果，在除法运算时仍会产生小数导致不准确，故转而采用spEL表达式并进行改良后，以确保计算准确，代码如下：
private static Field typedValueField = null;
private static Field typedValueDescriptorField = null;
static {
typedValueField = ReflectionUtils.findField(TypedValue.class, "value");
typedValueDescriptorField = ReflectionUtils.findField(TypedValue.class, "typeDescriptor");
Assert.state(typedValueField != null && typedValueDescriptorField != null, "not found TypedValue field[value,typeDescriptor] !");
typedValueField.setAccessible(true);
typedValueDescriptorField.setAccessible(true);
}
/**
* 基于spring Expression【精确计算】算术表达式并获得结果，运算过程凡涉及数字均转换为BigDecimal类型，整个过程均以BigDecimal的高精度进行运算，确保精度正常（推荐使用）
*
* @param exprString
* @param targetMap
* @return
*/
public static Double exactCalculate(String exprString, Map<String, ?> targetMap) {
return exactCalculate(exprString, targetMap, false, null);
}
/**
* 基于spring Expression【精确计算】算术表达式并获得结果，运算过程凡涉及数字均转换为BigDecimal类型，整个过程均以BigDecimal的高精度进行运算，确保精度正常（推荐使用）
*
* @param exprString
* @param targetMap
* @return
*/
public static Double exactCalculate(String exprString, Map<String, ?> targetMap, boolean ignoreNonexistentKeys, Object defaultIfNull) {
ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
context.setOperatorOverloader(NumberOperatorOverloader.DEFAULT);
context.addPropertyAccessor(MapPropertyAccessor.DEFAULT.setOptions(ignoreNonexistentKeys, defaultIfNull));
//这里将目标入参MAP作为spring表达式的根对象，则表达式中可以直接使用属性即可
context.setRootObject(targetMap);
try {
SpelExpression spExpression = (SpelExpression) parser.parseExpression(exprString);
if (spExpression == null) {
throw new ApplicationException(Constants.DEFAULT_ERROR_CODE, "解析spring表达式失败:" + exprString);
}
if (spExpression.getAST() != null) {
numberLiteralToBigDecimal(spExpression.getAST());
}
BigDecimal result = spExpression.getValue(context, BigDecimal.class);
return result.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
} catch (Exception e) {
LOGGER.error("算术表达式语法执行错误:{},表达式:{},目标入参：{}", e.getMessage(), exprString, JsonUtils.deserializer(targetMap));
throw new ApplicationException(Constants.DEFAULT_ERROR_CODE, "算术表达式语法执行错误，原因：" + e.getMessage());
}
}
/**
* 内部辅助方法：将表达式解析后的树中包含有数值字面量的统一转换为BigDecimal，确保精度不丢失
*
* @param spelNode
*/
private static void numberLiteralToBigDecimal(SpelNode spelNode) {
if (spelNode == null) {
return;
}
if (spelNode instanceof Literal) {
TypedValue typedValue = ((Literal) spelNode).getLiteralValue();
if (typedValue != null && typedValue.getValue() instanceof Number) {
try {
//将表达式中数字字面量的值转换为BigDecimal,以便参与运算时精度不会丢失
typedValueField.set(typedValue, NumberUtils.createBigDecimal(typedValue.getValue().toString()));
typedValueDescriptorField.set(typedValue, null);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
if (spelNode.getChildCount() > 0) {
for (int i = 0; i < spelNode.getChildCount(); i++) {
numberLiteralToBigDecimal(spelNode.getChild(i));
}
}
}
/**
* 数字类型运算符重载操作类（目前实际并没有生效）
*/
private static class NumberOperatorOverloader implements OperatorOverloader {
private static final List<Operation> OVERRIDE_OPERATIONS = Arrays.asList(Operation.ADD, Operation.SUBTRACT, Operation.DIVIDE, Operation.MULTIPLY);
public static NumberOperatorOverloader DEFAULT = new NumberOperatorOverloader();
@Override
public boolean overridesOperation(Operation operation, Object o, Object o1) throws EvaluationException {
return OVERRIDE_OPERATIONS.contains(operation) && o instanceof Number && o1 instanceof Number;
}
@Override
public Object operate(Operation operation, Object o, Object o1) throws EvaluationException {
BigDecimal leftNumber = NumberUtils.createBigDecimal(o.toString());
BigDecimal rightNumber = NumberUtils.createBigDecimal(o1.toString());
switch (operation) {
case ADD: {
return leftNumber.add(rightNumber);
}
case SUBTRACT: {
return leftNumber.subtract(rightNumber);
}
case DIVIDE: {
return leftNumber.divide(rightNumber, RoundingMode.HALF_UP);
}
case MULTIPLY: {
return leftNumber.multiply(rightNumber);
}
default: {
return BigDecimal.ZERO;
}
}
}
}
/**
* MAP属性访问器，确保spring表达式中可以直接指明key，而无需使用['key']这种模式
*/
private static class MapPropertyAccessor implements PropertyAccessor {
public static final MapPropertyAccessor DEFAULT = new MapPropertyAccessor();
private boolean ignoreNonexistentKeys = false;
private Object defaultIfNull = null;
/**
* 设置选项
*
* @param ignoreNonexistentKeys 忽略不存在KEY
* @param defaultIfNull 如果没空时的默认值
*/
public MapPropertyAccessor setOptions(boolean ignoreNonexistentKeys, Object defaultIfNull) {
this.ignoreNonexistentKeys = ignoreNonexistentKeys;
this.defaultIfNull = defaultIfNull;
if (this.defaultIfNull != null && this.defaultIfNull instanceof Number) {
//如果指定的默认值不为空，且为数字类型，则直接转换为BigDecimal类型
this.defaultIfNull = NumberUtils.createBigDecimal(this.defaultIfNull.toString());
}
return this;
}
@Override
public Class<?>[] getSpecificTargetClasses() {
return new Class[]{Map.class};
}
@Override
public boolean canRead(EvaluationContext context, Object target, String name) throws AccessException {
return (target instanceof Map && (((Map<?, ?>) target).containsKey(name) || ignoreNonexistentKeys));
}
@Override
public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
Assert.state(target instanceof Map, "参数不是Map类型");
Map<?, ?> map = (Map<?, ?>) target;
if (!map.containsKey(name) && !ignoreNonexistentKeys) {
throw new AccessException("Map中未包含该key: " + name);
}
Object value = map.get(name);
if (value == null) {
value = defaultIfNull;
} else if (value instanceof Number) {
//为保证精度不丢失，若为数字类型就转换为BigDecimal类型
value = NumberUtils.createBigDecimal(value.toString());
}
return new TypedValue(value);
}
@Override
public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException {
return false;
}
@Override
public void write(EvaluationContext context, Object target, String name, Object newValue) throws AccessException {
}
}
核心就是将所有的涉及数字类型转为BigDecimal进行运算，sp EL内部操作符会对BigDecimal进行专门的运算处理，从而确保精度正常。
顺便说一下，.NET（C#）语言也是支持执行javascript表达式的哦，当然也可以实现上述的求值表达式工具类，实现思路相同，有兴趣的.NET开发人员可以试试；