// 測試一下，沒問題啊
String scientificValue = 2e31;
double result = Double.parseDouble(scientificValue);
System.out.println(result); // 輸出：2.0E31

用戶輸入：2e31
系統(tǒng)處理：字符串 2e31
預(yù)期結(jié)果：數(shù)值 2.0E31
實(shí)際結(jié)果：0.0 (解析失敗)

前端輸入 -> JSON傳輸 -> 后端處理 -> 數(shù)據(jù)庫存儲(chǔ)

// 直接解析 - 正常
String value = 2e31;
double direct = Double.parseDouble(value);
System.out.println(直接解析:  + direct); // 2.0E31

// 通過FastJSON - 出問題了！
String json = {\value\: 2e31};
JSONObject jsonObject = JSONObject.parseObject(json);
Object obj = jsonObject.get(value);
System.out.println(對(duì)象類型:  + obj.getClass()); // String!
System.out.println(對(duì)象值:  + obj); // 2e31

// 前端處理
let input = 2e31;
let number = parseFloat(input);
let jsonData = {value: number};

String json = {\value\: \2e31\};
JSONObject jsonObject = JSONObject.parseObject(json);
String strValue = jsonObject.getString(value);
double result = Double.parseDouble(strValue);

public static double safeGetDouble(JSONObject jsonObject, String key) {
    Object value = jsonObject.get(key);
    
    if (value == null) {
        return 0.0;
    }
    
    // 如果已經(jīng)是數(shù)字類型
    if (value instanceof Number) {
        return ((Number) value).doubleValue();
    }
    
    // 如果是字符串類型，嘗試解析
    if (value instanceof String) {
        String strValue = ((String) value).trim();
        if (strValue.isEmpty()) {
            return 0.0;
        }
        
        try {
            return Double.parseDouble(strValue);
        } catch (NumberFormatException e) {
            System.err.println(無法解析字符串為double:  + strValue);
            return 0.0;
        }
    }
    
    // 其他情況，嘗試轉(zhuǎn)換為字符串再解析
    try {
        return Double.parseDouble(value.toString().trim());
    } catch (NumberFormatException e) {
        System.err.println(無法解析對(duì)象為double:  + value);
        return 0.0;
    }
}

public class FastJsonDoubleUtils {
    
    /**
     * 安全地從JSONObject中獲取double值
     */
    public static double getDoubleValue(JSONObject jsonObject, String key, double defaultValue) {
        if (jsonObject == null || !jsonObject.containsKey(key)) {
            return defaultValue;
        }
        
        Object value = jsonObject.get(key);
        return parseToDouble(value, defaultValue);
    }
    
    /**
     * 將對(duì)象解析為double值
     */
    public static double parseToDouble(Object value, double defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        
        if (value instanceof Number) {
            return ((Number) value).doubleValue();
        }
        
        if (value instanceof String) {
            String strValue = ((String) value).trim();
            if (strValue.isEmpty()) {
                return defaultValue;
            }
            
            try {
                return Double.parseDouble(strValue);
            } catch (NumberFormatException e) {
                System.err.println(無法解析字符串為double:  + strValue);
                return defaultValue;
            }
        }
        
        try {
            return Double.parseDouble(value.toString().trim());
        } catch (NumberFormatException e) {
            System.err.println(無法解析對(duì)象為double:  + value);
            return defaultValue;
        }
    }
    
    /**
     * 使用BigDecimal進(jìn)行精確解析
     */
    public static BigDecimal getBigDecimalValue(JSONObject jsonObject, String key, BigDecimal defaultValue) {
        if (jsonObject == null || !jsonObject.containsKey(key)) {
            return defaultValue;
        }
        
        Object value = jsonObject.get(key);
        return parseToBigDecimal(value, defaultValue);
    }
    
    /**
     * 將對(duì)象解析為BigDecimal
     */
    public static BigDecimal parseToBigDecimal(Object value, BigDecimal defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        
        try {
            if (value instanceof BigDecimal) {
                return (BigDecimal) value;
            }
            
            if (value instanceof Number) {
                return BigDecimal.valueOf(((Number) value).doubleValue());
            }
            
            if (value instanceof String) {
                String strValue = ((String) value).trim();
                if (strValue.isEmpty()) {
                    return defaultValue;
                }
                return new BigDecimal(strValue);
            }
            
            return new BigDecimal(value.toString().trim());
        } catch (NumberFormatException e) {
            System.err.println(無法解析為BigDecimal:  + value);
            return defaultValue;
        }
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(NumberFormatException.class)
    public ResponseEntity<String> handleNumberFormatException(NumberFormatException e) {
        return ResponseEntity.badRequest().body(數(shù)值格式錯(cuò)誤:  + e.getMessage());
    }
}

@Test
public void testScientificNotationParsing() {
    // 測試各種科學(xué)計(jì)數(shù)法格式
    String[] testCases = {
        {\value\: 2e31},
        {\value\: \2e31\},
        {\value\: 2.5e30},
        {\value\: \1.23e-10\},
        {\value\: null},
        {\value\: \\}
    };
    
    for (String testCase : testCases) {
        JSONObject json = JSONObject.parseObject(testCase);
        double result = FastJsonDoubleUtils.getDoubleValue(json, value, 0.0);
        System.out.println(測試:  + testCase +  ->  + result);
    }
}

// 永遠(yuǎn)不要直接使用JSONObject.getXxx()方法
// 錯(cuò)誤示例
double value = jsonObject.getDouble(value); // 可能拋異常

// 正確示例
double value = FastJsonDoubleUtils.getDoubleValue(jsonObject, value, 0.0);

public class JsonTypeUtils {
    
    public static int getIntValue(JSONObject json, String key, int defaultValue) {
        // 實(shí)現(xiàn)邏輯
    }
    
    public static long getLongValue(JSONObject json, String key, long defaultValue) {
        // 實(shí)現(xiàn)邏輯
    }
    
    public static BigDecimal getBigDecimalValue(JSONObject json, String key, BigDecimal defaultValue) {
        // 實(shí)現(xiàn)邏輯
    }
}

public static boolean isValidDouble(Object value) {
    try {
        parseToDouble(value, 0.0);
        return true;
    } catch (Exception e) {
        return false;
    }
}

private static final Logger logger = LoggerFactory.getLogger(JsonTypeUtils.class);

public static double parseToDouble(Object value, double defaultValue) {
    // ... 解析邏輯
    
    if (parseError) {
        logger.warn(Failed to parse value to double: {}, using default: {}, value, defaultValue);
    }
    
    return result;
}