递归实现类似计算器的公式计算处理工资，公积金，社保计算

 

 

前言

  公司一个业务需求需要计算员工的工资，社保。考虑到公司业务有很多需要用到公式计算，决定封装一个类可以实现类似于计算器输入公式计算出结果的效果。

思路

  社保，公积金计算的公式中有判断的逻辑，如果工资多少则缴纳的税百分比是多少，所以需要实现判断的逻辑；其次就是公式中的加减乘除了，还有优先级运算，这就是一个计算器了；除了这些还要考虑数据来源问题，每个人的那些数据拿来计算，所以就需要一个字段替换的逻辑。

需要实现

* 计算规则支持{} ：赋值替换运算符，需要赋值的字段如{age}=22，即将22 赋值给object对象中的age字段，对象object属性age有值
* 计算规则支持= ：将右侧计算值给左侧
* 计算规则支持() ：优先级计算，使用递归方式拆分运算，耗内存
* 计算规则支持+ ：+运算
* 计算规则支持- ：-运算
* 计算规则支持* ：*运算
* 计算规则支持/ ：/运算
* 计算规则支持? ：如果运算 如 A?B:C?D 如果A成立则返回B，如果A不成立C成立则返回D

分析

首先处理判断逻辑，将判断逻辑处理完后，剩下的就是计算了，所以首先将判断的部分分成三块，处理条件部分，将判断逻辑全部替换；然后处理括号，一层括号作为一个小的公式处理，每层括号就需要字符处理；剩下的好处理，乘除一级，优先处理，加减一级最后处理

贴上代码

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Pattern;

/**
 * @Author: jj
 * @Date: 2019/5/6 14:51
 * @Version 1.0
 */
public class RuleAnalysis {
	private static final Logger logger = LoggerFactory.getLogger(RuleAnalysis.class);
	/**
	 * object:计算的对象包含的计算规则中的需要字段
	 * 计算规则支持{} ：赋值替换运算符，需要赋值的字段如{age}=22，即将22 赋值给object对象中的age字段，对象object属性age有值
	 * 计算规则支持= ：将右侧计算值给左侧
	 * 计算规则支持() ：优先级计算，使用递归方式拆分运算，耗内存
	 * 计算规则支持+ ：+运算
	 * 计算规则支持- ：-运算
	 * 计算规则支持* ：*运算
	 * 计算规则支持/ ：/运算
	 * 计算规则支持? ：如果运算 如 A?B:C?D 如果A成立则返回B，如果A不成立C成立则返回D
	 */

	//计算运算符
	private static final String[] operator = {"(", "+", "-", "*", "/", "?", "["};
	//表达符
	private static final char[] splitOp = {'#', '+', '-', '*', '/', '?', '=', '<', '>'};


	public static Object analysisObject(Object object, List<Map> RULES) {
		//计算对象所有规则解析
		Iterator<Map> iterator = RULES.iterator();
		while (iterator.hasNext()) {
			Map<String, Object> next = iterator.next();
			String field = (String) next.get("field");
			String rules = (String) next.get("rules");
			String round = round(ruleAnalysis(rules, object), 4);
			logger.info("计算出来的值={}",round);
			toObject(field, object, round);
		}
		return object;
	}

	public static String ruleAnalysis(String rule, Object object) {
		if (containsOne(rule)) {
			return rule;
		}
		logger.info(rule);
		//规则解析方法，运用递归剥离规则，使用反射对规则赋值计算
		String rules = rule;
		if (rules.contains(operator[5])) {
			String[] split = rules.split(":");
			for (String str : split) {
				String condition = str.split("\\?")[0];
				String value = str.split("\\?")[1];
				if (isFounded(ruleAnalysis(condition, object), object)) {
					return ruleAnalysis(value, object);
				}
			}
		}
		if (rules.contains(operator[0])) {
			int sum = 0;
			StringBuilder builder = new StringBuilder();
			char[] chars = rules.toCharArray();
			for (int i = 0; i < chars.length; i++) {
				if (chars[i] == ')') {
					sum--;
				}
				if (sum >= 1) {
					builder.append(chars[i]);
				}
				if (chars[i] == '(') {
					sum++;
				}
				if (sum == 0 &&