<dependency>
    <groupId>com.udojava</groupId>
    <artifactId>EvalEx</artifactId>
    <version>2.7</version>
</dependency>

public abstract class CustomAbstractFunction extends AbstractFunction {
    @Override
    public Expression.LazyNumber lazyEval(List<Expression.LazyNumber> lazyParams) {
        return super.lazyEval(lazyParams);
    }

    public String restoreOriginalString(Integer s) {
        return FormalAnalysis.restoreOriginalString(s);
    }

    protected CustomAbstractFunction(String name, int numParams) {
        super(name, numParams);
    }

    @Override
    public BigDecimal eval(List<BigDecimal> parameters) {
        List<String> param = new ArrayList<>();
        for (int i = 0; i < parameters.size(); i++) {

            //兼容VAL BEG 和 END
            if (StrUtil.isEmpty(restoreOriginalString(parameters.get(i).intValue()))) {
                param.add(i, parameters.get(i).toString());
            } else {
                String s = restoreOriginalString(parameters.get(i).intValue());
                param.add(i, s);
            }

        }
        return customEval(param);
    }

    /**
     * 自定义表达式取值（自动将参数转换为原始字符串）
     *
     * @param parameters 函数参数信息
     * @return 计算值
     */
    public BigDecimal customEval(List<String> parameters) {
        return null;
    }
}

@Component
public class VAR extends CustomAbstractFunction {
    public VAR() {
        super("VAR", 1);
    }
    @Override
    public BigDecimal customEval(List<String> parameters) {

        String p1 = parameters.get(0);

        //这里写你自己的函数计算逻辑
        
        return BigDecimal.ZERO;
    }
}

@Component
public class MaxOperator extends AbstractOperator {
    public MaxOperator() {
        super(">>", 30, true);
    }

    @Override
    public BigDecimal eval(BigDecimal v1, BigDecimal v2) {
        return v1.max(v2);
    }
}

@Component
public class FormalAnalysis {

    /**
     * key->id,value->字符串参数
     * 公式中不能包含字符串
     */
    public static final ThreadLocal<Map<Integer, String>> mapping = ThreadLocal.withInitial(HashMap::new);

    /**
     * 测量点映射id
     */
    private static final ThreadLocal<Integer> placeholderCounter = ThreadLocal.withInitial(() -> 0);

    /**
     * 计算公式所需额外参数信息
     */
    public static final ThreadLocal<Map<String, Object>> param = ThreadLocal.withInitial(HashMap::new);

    /**
     * 错误信息
     */
    public static final ThreadLocal<List<String>> warnContent = ThreadLocal.withInitial(ArrayList::new);

    /**
     * 自动注册自定义函数
     */
    @Resource
    private ApplicationContext applicationContext;


    /**
     * 公式解析计算
     *
     * @param formula 公式
     * @param param   取值所需要的参数
     */
    public BigDecimal analysisCal(String formula, Map<String, Object> param) {
        BigDecimal eval = null;
        try {
            FormalAnalysis.param.set(param);

            formula = preprocessExpression(formula);
            // 创建表达式
            Expression expression = new Expression(formula);


            //添加自定义函数
            Map<String, AbstractFunction> fun = applicationContext.getBeansOfType(AbstractFunction.class);
            for (AbstractFunction abstractFunction : fun.values()) {
                expression.addFunction(abstractFunction);
            }
            //添加自定义操作符
            Map<String, AbstractOperator> oper = applicationContext.getBeansOfType(AbstractOperator.class);
            for (AbstractOperator abstractFunction : oper.values()) {
                expression.addOperator(abstractFunction);
            }

            // 计算公式
            eval = expression.eval();
            if (CollUtil.isNotEmpty(warnContent.get())) {
                throw new RuntimeException(StringUtils.join(warnContent.get().stream().distinct().collect(Collectors.toList()), System.lineSeparator()));
            }
        } catch (ArithmeticException e) {//除零异常
            if (CollUtil.isNotEmpty(warnContent.get())) {
                throw new RuntimeException(StringUtils.join(warnContent.get().stream().distinct().collect(Collectors.toList()), System.lineSeparator()));
            }
            eval = BigDecimal.ZERO;
        } finally {
            // 计算结束，清空当前线程的局部变量
            FormalAnalysis.mapping.remove();
            FormalAnalysis.placeholderCounter.remove();
            FormalAnalysis.warnContent.remove();
            FormalAnalysis.param.remove();
        }
        return eval.setScale(4, RoundingMode.HALF_UP);
    }



    /**
     * 预处理公式，将引号包裹的字符串替换为占位符
     */
    private static String preprocessExpression(String formula) {

        formula = formula.replace(ValParamEnum.BEG.getName(), ValParamEnum.BEG.getId().toString());
        formula = formula.replace(ValParamEnum.END.getName(), ValParamEnum.END.getId().toString());

        Pattern pattern = Pattern.compile("'([^']*)'");
        Matcher matcher = pattern.matcher(formula);
        StringBuffer sb = new StringBuffer();

        // 每找到一个匹配项，就生成一个占位符，并将原始字符串存入映射
        while (matcher.find()) {
            String originalString = matcher.group(1);
            placeholderCounter.set(placeholderCounter.get() + 1);
            mapping.get().put(placeholderCounter.get(), originalString);
            matcher.appendReplacement(sb, placeholderCounter.get() + "");
        }
        matcher.appendTail(sb);
        System.out.println(sb);
        return sb.toString();
    }

    /**
     * 在函数调用时，将占位符恢复为原始字符串
     */
    public static String restoreOriginalString(Integer placeholder) {
        return mapping.get().get(placeholder);
    }
}

@RestController
@RequestMapping("formula")
@Api(tags = "公式测试")
public class FormalTestController {

    @Resource
    FormalAnalysis formalAnalysis;

    @GetMapping
    @ApiOperation("test")
    public ApiResponse test() {
        String formal = "VAR('001d')+VAR('test1')";
        BigDecimal bigDecimal = formalAnalysis.analysisCal(formal, new HashMap<>());
        System.out.println(bigDecimal);
        return ApiResponse.succeed(bigDecimal);
    }
}