1. import java.util.HashMap;
  2. import java.util.Map;
  4. public class ApiPayloadParser {
  6. /**
  7. * Parses API payload arguments with defensive checks.
  8. * @param payload A map representing the API payload.
  9. * @param expectedKeys A map of expected keys and their data types.
  10. * @return A map containing the parsed arguments, or null if parsing fails.
  11. */
  12. public static Map<String, Object> parsePayload(Map<String, String> payload, Map<String, Class<?>> expectedKeys) {
  13. Map<String, Object> parsedPayload = new HashMap<>();
  15. if (payload == null || expectedKeys == null) {
  16. System.err.println("Error: Payload or expected keys are null.");
  17. return null;
  18. }
  20. for (Map.Entry<String, Class<?>> entry : expectedKeys.entrySet()) {
  21. String key = entry.getKey();
  22. Class<?> expectedType = entry.getValue();
  24. if (!payload.containsKey(key)) {
  25. System.err.println("Error: Missing key: " + key);
  26. return null;
  27. }
  29. String value = payload.get(key);
  31. try {
  32. Object parsedValue = parseValue(value, expectedType);
  33. parsedPayload.put(key, parsedValue);
  34. } catch (IllegalArgumentException e) {
  35. System.err.println("Error: Invalid value for key '" + key + "': " + e.getMessage());
  36. return null;
  37. } catch (Exception e) {
  38. System.err.println("Error: Unexpected error parsing key '" + key + "': " + e.getMessage());
  39. return null;
  40. }
  41. }
  43. return parsedPayload;
  44. }
  46. /**
  47. * Parses a string value into the expected data type.
  48. * @param value The string value to parse.
  49. * @param type The expected data type.
  50. * @return The parsed value.
  51. * @throws IllegalArgumentException if the value cannot be parsed.
  52. */
  53. private static Object parseValue(String value, Class<?> type) throws IllegalArgumentException {
  54. if (value == null || value.isEmpty()) {
  55. return null; // Or handle null/empty values as needed
  56. }
  58. if (type == String.class) {
  59. return value;
  60. } else if (type == Integer.class) {
  61. try {
  62. return Integer.parseInt(value);
  63. } catch (NumberFormatException e) {
  64. throw new IllegalArgumentException("Invalid integer value: " + value, e);
  65. }
  66. } else if (type == Double.class) {
  67. try {
  68. return Double.parseDouble(value);
  69. } catch (NumberFormatException e) {
  70. throw new IllegalArgumentException("Invalid double value: " + value, e);
  71. }
  72. } else if (type == Boolean.class) {
  73. return Boolean.parseBoolean(value.toLowerCase());
  74. } else if (type == Long.class) {
  75. try {
  76. return Long.parseLong(value);
  77. } catch (NumberFormatException e) {
  78. throw new IllegalArgumentException("Invalid long value: " + value, e);
  79. }
  80. }
  81. else {
  82. return value; //Return as String if type not supported
  83. }
  85. }
  88. public static void main(String[] args) {
  89. // Example Usage
  90. Map<String, String> payload = new HashMap<>();
  91. payload.put("name", "John Doe");
  92. payload.put("age", "30");
  93. payload.put("height", "1.75");
  94. payload.put("isActive", "true");
  96. Map<String, Class<?>> expectedKeys = new HashMap<>();
  97. expectedKeys.put("name", String.class);
  98. expectedKeys.put("age", Integer.class);
  99. expectedKeys.put("height", Double.class);
  100. expectedKeys.put("isActive", Boolean.class);
  103. Map<String, Object> parsedPayload = parsePayload(payload, expectedKeys);
  105. if (parsedPayload != null) {
  106. System.out.println("Parsed Payload: " + parsedPayload);
  107. }
  109. //Example with missing key
  110. Map<String, String> payload2 = new HashMap<>();
  111. payload2.put("name", "Jane Doe");
  112. Map<String, Class<?>> expectedKeys2 = new HashMap<>();
  113. expectedKeys2.put("name", String.class);

Add your comment