Java tutorial
/******************************************************************************* * * Copyright 2011 Spiffy UI Team * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ package org.spiffyui.client; import java.util.Date; import java.util.HashMap; import com.google.gwt.json.client.JSONArray; import com.google.gwt.json.client.JSONBoolean; import com.google.gwt.json.client.JSONNumber; import com.google.gwt.json.client.JSONObject; import com.google.gwt.json.client.JSONString; import com.google.gwt.json.client.JSONValue; import org.spiffyui.client.rest.RESTException; /** * A set of static utilities for handling JSON data structures in GWT. */ public final class JSONUtil { /** * Making sure this class can't be instantiated. */ private JSONUtil() { } /** * Get a string from the JSON object or null if it doesn't exist or * isn't a string * * @param obj the object with the value * @param key the key for the object * * @return the value or null if it could not be decoded */ public static String getStringValue(JSONObject obj, String key) { return getStringValue(obj, key, null); } /** * Get a string from the JSON object or defaultValue if it doesn't exist or * isn't a string * * @param obj the object with the value * @param key the key for the object * @param defaultValue the default value to return if the key could not be found * * @return the value or the defaultValue if it could not be decoded */ public static String getStringValue(JSONObject obj, String key, String defaultValue) { if (!obj.containsKey(key)) { return defaultValue; } JSONValue v = obj.get(key); if (v != null) { JSONString s = v.isString(); if (s != null) { return s.stringValue(); } } return defaultValue; } /** * Get a string from the JSON object or null if it doesn't exist or * isn't a string * * @param obj the object with the value * @param key the key for the object * * @return the value or null it could not be decoded */ public static String getStringValueIgnoreCase(JSONObject obj, String key) { return getStringValueIgnoreCase(obj, key, null); } /** * Get a string from the JSON object or defaultValue if it doesn't exist or * isn't a string * * @param obj the object with the value * @param key the key for the object * @param defaultValue the default value to return if the key could not be found * * @return the value or the defaultValue if it could not be decoded */ public static String getStringValueIgnoreCase(JSONObject obj, String key, String defaultValue) { JSONValue v = obj.get(key); if (v == null) { String lowerKey = key.toLowerCase(); for (String k : obj.keySet()) { if (lowerKey.equals(k.toLowerCase())) { v = obj.get(k); break; } } } if (v != null) { JSONString s = v.isString(); if (s != null) { return s.stringValue(); } } return defaultValue; } /** * Get a boolean from the JSON object false if it doesn't exist or * isn't a boolean * * @param obj the object with the value * @param key the key for the object * @return the value or false if it could not be decoded */ public static boolean getBooleanValue(JSONObject obj, String key) { return getBooleanValue(obj, key, false); } /** * Get a boolean from the JSON object or defaultValue if it doesn't exist or * isn't a boolean * * @param obj the object with the value * @param key the key for the object * @param defaultValue the default value if the key can not be found * * @return the value or false it could not be decoded */ public static boolean getBooleanValue(JSONObject obj, String key, boolean defaultValue) { if (!obj.containsKey(key)) { return defaultValue; } JSONValue v = obj.get(key); if (v != null) { JSONBoolean b = v.isBoolean(); if (b != null) { return b.booleanValue(); } else { JSONString s = v.isString(); if (s != null) { return Boolean.parseBoolean(s.stringValue()); } } } return defaultValue; } /** * Get a JSONArray from the JSON object or null if it doesn't exist or * isn't a JSONArray * * @param obj the object with the value * @param key the key for the object * * @return the value or an empty array if it could not be decoded */ public static JSONArray getJSONArray(JSONObject obj, String key) { JSONValue v = obj.get(key); if (v != null) { JSONArray a = v.isArray(); if (a != null) { return a; } } return new JSONArray(); } /** * Get an int from the JSON object or -1 if it doesn't exist or * isn't an int. This will handle JSON numbers like this: * * "val": 5 * * It will also handle numbers in strings like: * * "val": "5" * * @param obj the object with the value * @param key the key for the object * * @return the value or -1 if it could not be decoded */ public static int getIntValue(JSONObject obj, String key) { return getIntValue(obj, key, -1); } /** * Get an int from the JSON object or the defaultValue if it doesn't exist or * isn't an int. This will handle JSON numbers like this: * * "val": 5 * * It will also handle numbers in strings like: * * "val": "5" * * @param obj the object with the value * @param key the key for the object * @param defaultValue the default value if the specified key isn't found. * * @return the value or the defaultValue if it could not be decoded */ public static int getIntValue(JSONObject obj, String key, int defaultValue) { if (!obj.containsKey(key)) { return defaultValue; } try { JSONValue v = obj.get(key); if (v != null) { JSONNumber n = v.isNumber(); if (n != null) { return (int) n.doubleValue(); } else { /* * If this isn't a number, then it might be a string * like "5" so we try to parse it as a number. */ return Integer.parseInt(getStringValue(obj, key)); } } } catch (Exception e) { JSUtil.println(e.getMessage()); } return defaultValue; } /** * Get a double from the JSON object or 0 if it doesn't exist or * isn't a double. This will handle JSON numbers like this: * * "val": 0.5 or "val": -0.5 or "val": +0.5 * * It will also handle numbers in strings like: * * "val": "0.5" or "val": "-0.5" or "val": "+0.5" * * @param obj the object with the value * @param key the key for the object * * @return the value or 0 if it could not be decoded */ public static double getDoubleValue(JSONObject obj, String key) { return getDoubleValue(obj, key, 0); } /** * Get a double from the JSON object or the defaultValue if it doesn't exist or * isn't a double. This will handle JSON numbers like this: * * "val": 0.5 or "val": -0.5 or "val": +0.5 * * It will also handle numbers in strings like: * * "val": "0.5" or "val": "-0.5" or "val": "+0.5" * * @param obj the object with the value * @param key the key for the object * @param defaultValue the default value if the specified key isn't found. * * @return the value or the defaultValue if it could not be decoded */ public static double getDoubleValue(JSONObject obj, String key, double defaultValue) { if (!obj.containsKey(key)) { return defaultValue; } try { JSONValue v = obj.get(key); if (v != null) { JSONNumber n = v.isNumber(); if (n != null) { return n.doubleValue(); } else { /* * If this isn't a number, then it might be a string * like "5" so we try to parse it as a number. */ return Double.parseDouble(getStringValue(obj, key)); } } } catch (Exception e) { JSUtil.println(e.getMessage()); } return defaultValue; } /** * Get a long from the JSON object or -1 if it doesn't exist or * isn't a long. This will handle JSON numbers like this: * * "val": 5 * * It will also handle numbers in strings like: * * "val": "5" * * @param obj the object with the value * @param key the key for the object * * @return the value or -1 if it could not be decoded */ public static long getLongValue(JSONObject obj, String key) { return getLongValue(obj, key, -1L); } /** * Get a long from the JSON object or the defaultValue if it doesn't exist or * isn't a long. This will handle JSON numbers like this: * * "val": 5 * * It will also handle numbers in strings like: * * "val": "5" * * @param obj the object with the value * @param key the key for the object * @param defaultValue the default value if the specified key isn't found. * * @return the value or the defaultValue if it could not be decoded */ public static long getLongValue(JSONObject obj, String key, long defaultValue) { if (!obj.containsKey(key)) { return defaultValue; } try { JSONValue v = obj.get(key); if (v != null) { JSONNumber n = v.isNumber(); if (n != null) { return (long) n.doubleValue(); } else { /* * If this isn't a number, then it might be a string * like "5" so we try to parse it as a number. */ return Long.parseLong(getStringValue(obj, key)); } } } catch (Exception e) { JSUtil.println(e.getMessage()); } return defaultValue; } /** * Get a JSONObject from the JSON object or null if it doesn't exist or * isn't a JSONObject * * @param obj the object with the value * @param key the key for the object * * @return the value or null it could not be decoded */ public static JSONObject getJSONObject(JSONObject obj, String key) { JSONValue v = obj.get(key); if (v != null) { JSONObject a = v.isObject(); if (a != null) { return a; } } return null; } /** * Get a java.util.Date from the JSON object as an epoch time in milliseconds * or return null if it doesn't exist or * cannot be converted from epoch to Date * * @param obj the object with the value * @param key the key for the object * * @return the value or null it could not be decoded/converted */ public static Date getDateValue(JSONObject obj, String key) { JSONValue v = obj.get(key); if (v != null) { JSONNumber n = v.isNumber(); if (n != null) { return new Date(Double.valueOf(n.doubleValue()).longValue()); } else { String s = getStringValue(obj, key); if (s != null) { return new Date(Long.parseLong(s)); } } } return null; } /** * Determines if the specified JSONObject contains the specified key. * * @param obj the object containing the key * @param key the key to look for * * @return true if this object contains the specified key and false otherwise */ public static boolean containsKeyIgnoreCase(JSONObject obj, String key) { if (obj != null) { String lowerKey = key.toLowerCase(); for (String k : obj.keySet()) { if (lowerKey.equals(k.toLowerCase())) { return true; } } } return false; } /** * Get the JSONValue from the specified object ignoring the case of the key. * * @param obj the object containing the value * @param key the key of the value * * @return the value for the specified key or null if the key can't be found */ public static JSONValue getIgnoreCase(JSONObject obj, String key) { if (obj != null) { String lowerKey = key.toLowerCase(); for (String k : obj.keySet()) { if (lowerKey.equals(k.toLowerCase())) { return obj.get(k); } } } return null; } /** * Get the RESTException containing the information in the specified JSON or null if the * JSON object does not correspond to the NCAC exception format. * * @param val the JSON value containing the exception * @param statusCode the status code of the response that generated this data * @param url the URL that was called to get this JSON * * @return the RESTException if this JSON represented an NCAC fault or null if it wasn't an NCAC fault */ public static RESTException getRESTException(JSONValue val, int statusCode, String url) { if (val.isObject() != null && containsKeyIgnoreCase(val.isObject(), "Fault")) { JSONObject fault = getIgnoreCase(val.isObject(), "Fault").isObject(); JSONObject objCode = getIgnoreCase(fault, "Code").isObject(); String code = getStringValueIgnoreCase(objCode, "Value"); String subcode = null; if (getIgnoreCase(objCode, "Subcode") != null) { subcode = getStringValueIgnoreCase(getIgnoreCase(objCode, "Subcode").isObject(), "Value"); } String reason = null; if (getIgnoreCase(fault, "Reason") != null && getIgnoreCase(fault, "Reason").isObject() != null && getIgnoreCase(getIgnoreCase(fault, "Reason").isObject(), "Text") != null) { reason = getStringValueIgnoreCase(getIgnoreCase(fault, "Reason").isObject(), "Text"); } HashMap<String, String> detailMap = new HashMap<String, String>(); if (getIgnoreCase(fault, "Detail") != null) { JSONObject details = getIgnoreCase(fault, "Detail").isObject(); for (String key : details.keySet()) { detailMap.put(key, getIgnoreCase(details, key).isString().stringValue()); } } return new RESTException(code, subcode, reason, detailMap, statusCode, url); } else { return null; } } }