Java JSON 解析和告警规则提取代码优化

import java.util.*;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class JsonRuleExtractor {

    private static String devicename;
    private static String entity_id;
    private static String operation;
    private static Double defaultValue;
    private static String mapstrnum;
    private static String[] Operation_Arr;
    private static Double[] Default_Value;

    // 使用泛型，提高代码可重用性和扩展性
    private static Map<String, ?> parseJSON2Map(Object json) {
        if (json instanceof JSONObject) {
            return parseJSONObject((JSONObject) json);
        } else if (json instanceof JSONArray) {
            return parseJSONArray((JSONArray) json);
        }
        return Collections.singletonMap(null, json);
    }

    private static Map<String, ?> parseJSONObject(JSONObject jsonObject) {
        Map<String, ?> map = new HashMap<>();
        for (Object key : jsonObject.keySet()) {
            Object value = jsonObject.get(key);
            map.put(key.toString(), parseJSON2Map(value));
        }
        return map;
    }

    private static Map<String, ?> parseJSONArray(JSONArray jsonArray) {
        List<Map<String, ?>> list = new ArrayList<>();
        for (Object element : jsonArray) {
            list.add(parseJSON2Map(element));
        }
        return Collections.singletonMap(null, list);
    }

    public static void JsonMapData(String json) throws Exception {
        Map<String, ?> map = parseJSON2Map(JSONObject.fromObject(json));
        if (map.containsKey('data')) {
            MySqlRuleDelete();
            Map<String, ?> dataMap = (Map<String, ?>) map.get('data');
            devicename = (String) dataMap.get('name');
            Map<String, ?> deviceProfileDataMap = (Map<String, ?>) dataMap.get('deviceProfileData');
            String bblength = String.valueOf(deviceProfileDataMap);

            if (bblength.length() > 170) {
                List<Map<String, ?>> alarms = (List<Map<String, ?>>) deviceProfileDataMap.get('alarms');
                Map<String, ?> alarm = alarms.get(0);
                entity_id = (String) alarm.get('id');
                Map<String, ?> createRules = (Map<String, ?>) alarm.get('createRules');

                processRule(createRules, 'MAJOR');
                processRule(createRules, 'MINOR');
                processRule(createRules, 'CRITICAL');
            } else if (bblength.length() < 168) {
                jedis.set('Error', 'PassRule');
            }
        }
    }

    private static void processRule(Map<String, ?> createRules, String model) {
        if (createRules.containsKey(model)) {
            JSONObject conditionJson = (JSONObject) ((JSONObject) createRules.get(model)).get('condition');
            Map<String, ?> conditionMap = parseJSON2Map(conditionJson);
            List<Map<String, ?>> conditions = (List<Map<String, ?>>) conditionMap.get('condition');

            ListNum(conditions);

            if (mapstrnum.equals("{predicate=2}")) {
                ForGreaterOrLessOrEqual(conditions, 2, model);
            } else if (mapstrnum.equals("{predicate=3}")) {
                ForGreaterOrLessOrEqual(conditions, 3, model);
            } else {
                GreaterOrLessOrEqual(conditions, 1);
                insertRule(devicename, entity_id, model, operation, defaultValue, 1);
            }
        }
    }

    private static void GreaterOrLessOrEqual(List<Map<String, ?>> list, int i) {
        for (int j = 0; j < i; j++) {
            Map<String, ?> predicate = (Map<String, ?>) list.get(j).get('predicate');
            JSONObject valueJson = (JSONObject) predicate.get('value');
            defaultValue = valueJson.getDouble('defaultValue');
            operation = (String) predicate.get('operation');
        }
    }

    private static void ForGreaterOrLessOrEqual(List<Map<String, ?>> list, int i, String model) {
        Operation_Arr = new String[i];
        Default_Value = new Double[i];
        for (int j = 0; j < i; j++) {
            Map<String, ?> predicate = (Map<String, ?>) list.get(j).get('predicate');
            JSONObject valueJson = (JSONObject) predicate.get('value');
            defaultValue = valueJson.getDouble('defaultValue');
            operation = (String) predicate.get('operation');

            Operation_Arr[j] = operation;
            Default_Value[j] = defaultValue;
            insertRule(devicename, entity_id, model, operation, defaultValue, j + 1);
        }
    }

    private static void insertRule(String devicename, String entity_id, String model, String operation, Double defaultValue, int operationNum) {
        try {
            RuleSqlStruct pressure = new RuleSqlStruct(devicename, entity_id, model, operation, defaultValue, operationNum);
            RulepressDao pressureDao = new RulepressureDaoImpl();
            pressureDao.insertData(pressure, 'rule_kv');
        } catch (Exception e) {
            System.out.println("
告警规则参数插入数据库失败！");
        }
    }

    public static void MySqlRuleDelete() {
        try {
            RulepressDao pressureDao = new RulepressureDaoImpl();
            pressureDao.deleteData();
            System.out.println("
翻新告警规则参数，清空数据库成功！");
        } catch (Exception e) {
            System.out.println("
翻新告警规则参数，清空数据库失败！");
        }
    }

    public static void ListNum(List<Map<String, ?>> list) {
        Map<String, Integer> map = new HashMap<>();
        for (Map<String, ?> str : list) {
            Integer i = 1;
            if (map.get('predicate') != null) {
                i = map.get('predicate') + 1;
            }
            map.put('predicate', i);
        }
        mapstrnum = map.toString();
    }
}
``