Java tutorial
package org.jolokia.converter.object; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.math.BigDecimal; import java.math.BigInteger; import java.net.MalformedURLException; import java.net.URL; import java.util.*; import javax.management.ObjectName; import org.jolokia.util.*; import org.json.simple.JSONArray; import org.json.simple.JSONObject; import org.json.simple.parser.ParseException; /* * Copyright 2009-2013 Roland Huss * * 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. */ /** * Converter from a string representation to its Java object form * @author roland * @since Jun 11, 2009 */ public class StringToObjectConverter { private static final Map<String, Parser> PARSER_MAP = new HashMap<String, Parser>(); private static final Map<String, Class> TYPE_SIGNATURE_MAP = new HashMap<String, Class>(); static { PARSER_MAP.put(Byte.class.getName(), new ByteParser()); PARSER_MAP.put("byte", new ByteParser()); PARSER_MAP.put(Integer.class.getName(), new IntParser()); PARSER_MAP.put("int", new IntParser()); PARSER_MAP.put(Long.class.getName(), new LongParser()); PARSER_MAP.put("long", new LongParser()); PARSER_MAP.put(Short.class.getName(), new ShortParser()); PARSER_MAP.put("short", new ShortParser()); PARSER_MAP.put(Double.class.getName(), new DoubleParser()); PARSER_MAP.put("double", new DoubleParser()); PARSER_MAP.put(Float.class.getName(), new FloatParser()); PARSER_MAP.put("float", new FloatParser()); PARSER_MAP.put(BigDecimal.class.getName(), new BigDecimalParser()); PARSER_MAP.put(BigInteger.class.getName(), new BigIntegerParser()); PARSER_MAP.put(Boolean.class.getName(), new BooleanParser()); PARSER_MAP.put("boolean", new BooleanParser()); PARSER_MAP.put("char", new CharParser()); PARSER_MAP.put(Character.class.getName(), new CharParser()); PARSER_MAP.put(String.class.getName(), new StringParser()); PARSER_MAP.put(Date.class.getName(), new DateParser()); PARSER_MAP.put(ObjectName.class.getName(), new ObjectNameParser()); PARSER_MAP.put(URL.class.getName(), new URLParser()); JSONParser jsonExtractor = new JSONParser(); for (Class type : new Class[] { Map.class, List.class, JSONObject.class, JSONArray.class }) { PARSER_MAP.put(type.getName(), jsonExtractor); } TYPE_SIGNATURE_MAP.put("Z", boolean.class); TYPE_SIGNATURE_MAP.put("B", byte.class); TYPE_SIGNATURE_MAP.put("C", char.class); TYPE_SIGNATURE_MAP.put("S", short.class); TYPE_SIGNATURE_MAP.put("I", int.class); TYPE_SIGNATURE_MAP.put("J", long.class); TYPE_SIGNATURE_MAP.put("F", float.class); TYPE_SIGNATURE_MAP.put("D", double.class); } /** * Prepare a value from a either a given object or its string representation. * If the value is already assignable to the given class name it is returned directly. * * @param pExpectedClassName type name of the expected type * @param pValue value to either take directly or to convert from its string representation. * @return the prepared / converted object */ public Object prepareValue(String pExpectedClassName, Object pValue) { if (pValue == null) { return null; } else { Class expectedClass = ClassUtil.classForName(pExpectedClassName); Object param = null; if (expectedClass != null) { param = prepareValue(expectedClass, pValue); } if (param == null) { // Ok, we try to convert it from a string // If expectedClass is null, it is probably a native type, so we // let happen the string conversion // later on (e.g. conversion of pArgument.toString()) which will throw // an exception at this point if conversion can not be done return convertFromString(pExpectedClassName, pValue.toString()); } return param; } } // Extract a type version of the method above. This might be useful later // on, e.g. when setting enums should be supported for certain // use cases private Object prepareValue(Class expectedClass, Object pValue) { if (pValue == null) { return null; } if (Enum.class.isAssignableFrom(expectedClass)) { return Enum.valueOf(expectedClass, pValue.toString()); } else { return prepareForDirectUsage(expectedClass, pValue); } } /** * For GET requests, where operation arguments and values to write are given in * string representation as part of the URL, certain special tags are used to indicate * special values: * * <ul> * <li><code>[null]</code> for indicating a null value</li> * <li><code>""</code> for indicating an empty string</li> * </ul> * * This method converts these tags to the proper value. If not a tag, the original * value is returned. * * If you need this tag values in the original semantics, please use POST requests. * * @param pValue the string value to check for a tag * @return the converted value or the original one if no tag has been found. */ public static String convertSpecialStringTags(String pValue) { if ("[null]".equals(pValue)) { // Null marker for get requests return null; } else if ("\"\"".equals(pValue)) { // Special string value for an empty String return ""; } else { return pValue; } } // ====================================================================================================== // Check whether an argument can be used directly // or the argument could be used in a public constructor // or whether it needs some sort of conversion, // Returns null if a string conversion should happen private Object prepareForDirectUsage(Class expectedClass, Object pArgument) { Class givenClass = pArgument.getClass(); if (expectedClass.isArray() && List.class.isAssignableFrom(givenClass)) { return convertListToArray(expectedClass, (List) pArgument); } else { return expectedClass.isAssignableFrom(givenClass) ? pArgument : null; } } private Object convertByConstructor(String pType, String pValue) { Class<?> expectedClass = ClassUtil.classForName(pType); if (expectedClass != null) { for (Constructor<?> constructor : expectedClass.getConstructors()) { // only support only 1 constructor parameter if (constructor.getParameterTypes().length == 1 && constructor.getParameterTypes()[0].isAssignableFrom(String.class)) { try { return constructor.newInstance(pValue); } catch (Exception ignore) { } } } } return null; } /** * Deserialize a string representation to an object for a given type * * @param pType type to convert to * @param pValue the value to convert from * @return the converted value */ public Object convertFromString(String pType, String pValue) { String value = convertSpecialStringTags(pValue); if (value == null) { return null; } if (pType.startsWith("[") && pType.length() >= 2) { return convertToArray(pType, value); } Parser parser = PARSER_MAP.get(pType); if (parser != null) { return parser.extract(value); } Object cValue = convertByConstructor(pType, pValue); if (cValue != null) { return cValue; } throw new IllegalArgumentException( "Cannot convert string " + value + " to type " + pType + " because no converter could be found"); } // Convert an array private Object convertToArray(String pType, String pValue) { // It's an array String t = pType.substring(1, 2); Class valueType; if (t.equals("L")) { // It's an object-type String oType = pType.substring(2, pType.length() - 1).replace('/', '.'); valueType = ClassUtil.classForName(oType); if (valueType == null) { throw new IllegalArgumentException("No class of type " + oType + "found"); } } else { valueType = TYPE_SIGNATURE_MAP.get(t); if (valueType == null) { throw new IllegalArgumentException("Cannot convert to unknown array type " + t); } } String[] values = EscapeUtil.splitAsArray(pValue, EscapeUtil.PATH_ESCAPE, ","); Object ret = Array.newInstance(valueType, values.length); int i = 0; for (String value : values) { Array.set(ret, i++, value.equals("[null]") ? null : convertFromString(valueType.getCanonicalName(), value)); } return ret; } // Convert a list to an array of the given type private Object convertListToArray(Class pType, List pList) { Class valueType = pType.getComponentType(); Object ret = Array.newInstance(valueType, pList.size()); int i = 0; for (Object value : pList) { if (value == null) { if (!valueType.isPrimitive()) { Array.set(ret, i++, null); } else { throw new IllegalArgumentException( "Cannot use a null value in an array of type " + valueType.getSimpleName()); } } else { if (valueType.isAssignableFrom(value.getClass())) { // Can be set directly Array.set(ret, i++, value); } else { // Try to convert from string Array.set(ret, i++, convertFromString(valueType.getCanonicalName(), value.toString())); } } } return ret; } // =========================================================================== // Extractor interface private interface Parser { /** * Extract a particular string value * @param pValue value to extract * @return the extracted value */ Object extract(String pValue); } private static class StringParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return pValue; } } private static class IntParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Integer.parseInt(pValue); } } private static class LongParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Long.parseLong(pValue); } } private static class BooleanParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Boolean.parseBoolean(pValue); } } private static class DoubleParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Double.parseDouble(pValue); } } private static class FloatParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Float.parseFloat(pValue); } } private static class ByteParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Byte.parseByte(pValue); } } private static class CharParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return pValue.charAt(0); } } private static class ShortParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return Short.parseShort(pValue); } } private static class BigDecimalParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return new BigDecimal(pValue); } } private static class BigIntegerParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { return new BigInteger(pValue); } } private static class DateParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { long time; try { time = Long.parseLong(pValue); return new Date(time); } catch (NumberFormatException exp) { return DateUtil.fromISO8601(pValue); } } } private static class JSONParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { try { return new org.json.simple.parser.JSONParser().parse(pValue); } catch (ParseException e) { throw new IllegalArgumentException("Cannot parse JSON " + pValue + ": " + e, e); } } } private static class ObjectNameParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { try { return new javax.management.ObjectName(pValue); } catch (javax.management.MalformedObjectNameException e) { throw new IllegalArgumentException("Cannot parse ObjectName " + pValue + ": " + e, e); } } } private static class URLParser implements Parser { /** {@inheritDoc} */ public Object extract(String pValue) { try { return new URL(pValue); } catch (MalformedURLException e) { throw new IllegalArgumentException("Cannot parse URL " + pValue + ": " + e, e); } } } }