package org.jolokia.converter.json;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import javax.management.AttributeNotFoundException;
import org.jolokia.converter.object.StringToObjectConverter;
import org.jolokia.util.EscapeUtil;
import org.jolokia.util.ServiceObjectFactory;
/*
* 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.
*/
/**
* A converter which converts attribute and return values
* into a JSON representation. It uses certain handlers for this which
* are registered in the constructor.
*
* Each handler gets a reference to this converter object so that it
* can use it for a recursive solution of nested objects.
*
* @author roland
* @since Apr 19, 2009
*/
public final class ObjectToJsonConverter {
// List of dedicated handlers used for delegation in serialization/deserializatin
private List<Extractor> handlers;
private ArrayExtractor arrayExtractor;
// Thread-Local set in order to prevent infinite recursions
private ThreadLocal<ObjectSerializationContext> stackContextLocal = new ThreadLocal<ObjectSerializationContext>();
// Used for converting string to objects when setting attributes
private StringToObjectConverter stringToObjectConverter;
// Definition of simplifiers
private static final String SIMPLIFIERS_DEFAULT_DEF = "META-INF/simplifiers-default";
private static final String SIMPLIFIERS_DEF = "META-INF/simplifiers";
/**
* New object-to-json converter
*
* @param pStringToObjectConverter used when setting values
* @param pSimplifyHandlers a bunch of simplifiers used for mangling the conversion result
*/
public ObjectToJsonConverter(StringToObjectConverter pStringToObjectConverter,
Extractor... pSimplifyHandlers) {
handlers = new ArrayList<Extractor>();
// TabularDataExtractor must be before MapExtractor
// since TabularDataSupport isa Map
handlers.add(new TabularDataExtractor());
handlers.add(new CompositeDataExtractor());
// Collection handlers
handlers.add(new ListExtractor());
handlers.add(new MapExtractor());
handlers.add(new CollectionExtractor());
// Special, well known objects
addSimplifiers(handlers, pSimplifyHandlers);
// Enum handling
handlers.add(new EnumExtractor());
// Special date handling
handlers.add(new DateExtractor());
// Must be last in handlers, used default algorithm
handlers.add(new BeanExtractor());
arrayExtractor = new ArrayExtractor();
stringToObjectConverter = pStringToObjectConverter;
}
/**
* Convert the return value to a JSON object.
*
*
*
* @param pValue the value to convert
* @param pPathParts path parts to use for extraction
* @param pOptions options used for parsing
* @return the converter object. This either a subclass of {@link org.json.simple.JSONAware} or a basic data type like String or Long.
* @throws AttributeNotFoundException if within an path an attribute could not be found
*/
public Object convertToJson(Object pValue, List<String> pPathParts, JsonConvertOptions pOptions)
throws AttributeNotFoundException {
Stack<String> extraStack = pPathParts != null ? EscapeUtil.reversePath(pPathParts) : new Stack<String>();
return extractObjectWithContext(pValue, extraStack, pOptions, true);
}
/**
* Set an inner value of a complex object. A given path must point to the attribute/index to set within the outer object.
*
*
* @param pOuterObject the object to dive in
* @param pNewValue the value to set
* @param pPathParts the path within the outer object. This object will be modified and be a modifiable list.
* @return the old value
*
* @throws AttributeNotFoundException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public Object setInnerValue(Object pOuterObject, Object pNewValue, List<String> pPathParts)
throws AttributeNotFoundException, IllegalAccessException, InvocationTargetException {
String lastPathElement = pPathParts.remove(pPathParts.size()-1);
Stack<String> extraStack = EscapeUtil.reversePath(pPathParts);
// Get the object pointed to do with path-1
// We are using no limits here, since a path must have been given (see above), and hence we should
// be save anyway.
Object inner = extractObjectWithContext(pOuterObject, extraStack, JsonConvertOptions.DEFAULT, false);
// Set the attribute pointed to by the path elements
// (depending of the parent object's type)
return setObjectValue(inner, lastPathElement, pNewValue);
}
// =================================================================================================
/**
* Related to {@link #extractObjectWithContext} except that
* it does not setup a context. This method is called back from the
* various extractors to recursively continue the extraction, hence it is public.
*
* This method must not be used as entry point for serialization.
* Use {@link #convertToJson(Object, List, JsonConvertOptions)} or
* {@link #setInnerValue(Object, Object, List)} instead.
*
* @param pValue value to extract from
* @param pPathParts stack for diving into the object
* @param pJsonify whether a JSON representation {@link org.json.simple.JSONObject}
* @return extracted object either in native format or as {@link org.json.simple.JSONObject}
* @throws AttributeNotFoundException if an attribute is not found during traversal
*/
public Object extractObject(Object pValue, Stack<String> pPathParts, boolean pJsonify)
throws AttributeNotFoundException {
ObjectSerializationContext stackContext = stackContextLocal.get();
String limitReached = checkForLimits(pValue, stackContext);
Stack<String> pathStack = pPathParts != null ? pPathParts : new Stack<String>();
if (limitReached != null) {
return limitReached;
}
try {
stackContext.push(pValue);
if (pValue == null) {
return pathStack.isEmpty() ?
null :
stackContext.getValueFaultHandler().handleException(
new AttributeNotFoundException("Cannot apply a path to an null value"));
}
if (pValue.getClass().isArray()) {
// Special handling for arrays
return arrayExtractor.extractObject(this,pValue,pathStack,pJsonify);
}
return callHandler(pValue, pathStack, pJsonify);
} finally {
stackContext.pop();
}
}
/**
* Handle a value which means to dive into the internal of a complex object
* (if <code>pExtraArgs</code> is not null) and/or to convert
* it to JSON (if <code>pJsonify</code> is true).
*
*
* @param pValue value to extract from
* @param pExtraArgs stack used for diving in to the value
* @param pOpts options from which various processing
* parameters (like maxDepth, maxCollectionSize and maxObjects) are taken and put
* into context in order to influence the object traversal.
* @param pJsonify whether the result should be returned as an JSON object
* @return extracted value, either natively or as JSON
* @throws AttributeNotFoundException if during traversal an attribute is not found as specified in the stack
*/
private Object extractObjectWithContext(Object pValue, Stack<String> pExtraArgs, JsonConvertOptions pOpts, boolean pJsonify)
throws AttributeNotFoundException {
Object jsonResult;
setupContext(pOpts);
try {
jsonResult = extractObject(pValue, pExtraArgs, pJsonify);
} catch (ValueFaultHandler.AttributeFilteredException exp) {
jsonResult = null;
} finally {
clearContext();
}
return jsonResult;
}
/**
* Set an value of an inner object
*
* @param pInner the inner object
* @param pAttribute the attribute to set
* @param pValue the value to set
* @return the old value
* @throws IllegalAccessException if the reflection code fails during setting of the value
* @throws InvocationTargetException reflection error
*/
private Object setObjectValue(Object pInner, String pAttribute, Object pValue)
throws IllegalAccessException, InvocationTargetException {
// Call various handlers depending on the type of the inner object, as is extract Object
Class clazz = pInner.getClass();
if (clazz.isArray()) {
return arrayExtractor.setObjectValue(stringToObjectConverter,pInner,pAttribute,pValue);
}
Extractor handler = getExtractor(clazz);
if (handler != null) {
return handler.setObjectValue(stringToObjectConverter,pInner,pAttribute,pValue);
} else {
throw new IllegalStateException(
"Internal error: No handler found for class " + clazz + " for setting object value." +
" (object: " + pInner + ", attribute: " + pAttribute + ", value: " + pValue + ")");
}
}
// =================================================================================
/**
* Get the length of an extracted collection, but not larger than the configured limit.
*
* @param originalLength the orginal length
* @return the original length if is smaller than then the configured maximum length. Otherwise the
* maximum length is returned.
*/
int getCollectionLength(int originalLength) {
ObjectSerializationContext ctx = stackContextLocal.get();
return ctx.getCollectionSizeTruncated(originalLength);
}
/**
* Get the fault handler used for dealing with exceptions during value extraction.
*
* @return the fault handler
*/
public ValueFaultHandler getValueFaultHandler() {
ObjectSerializationContext ctx = stackContextLocal.get();
return ctx.getValueFaultHandler();
}
/**
* Clear the context used for counting objects and limits
*/
void clearContext() {
stackContextLocal.remove();
}
/**
* Setup the context with hard limits and defaults
*/
void setupContext() {
setupContext(new JsonConvertOptions.Builder().build());
}
/**
* Setup the context with the limits given in the request or with the default limits if not. In all cases,
* hard limits as defined in the servlet configuration are never exceeded.
*
* @param pOpts options used for parsing.
*/
void setupContext(JsonConvertOptions pOpts) {
ObjectSerializationContext stackContext = new ObjectSerializationContext(pOpts);
stackContextLocal.set(stackContext);
}
// =================================================================================
// Get the extractor for a certain class
private Extractor getExtractor(Class pClazz) {
for (Extractor handler : handlers) {
if (handler.canSetValue() && handler.getType() != null && handler.getType().isAssignableFrom(pClazz)) {
return handler;
}
}
return null;
}
private String checkForLimits(Object pValue, ObjectSerializationContext pStackContext) {
if (pValue != null) {
if (pStackContext.maxDepthReached()) {
// We use its string representation.
return pValue.toString();
}
if (pStackContext.alreadyVisited(pValue)) {
return "[Reference " + pValue.getClass().getName() + "@" + Integer.toHexString(pValue.hashCode()) + "]";
}
}
if (pStackContext.maxObjectsExceeded()) {
return "[Object limit exceeded]";
}
return null;
}
private Object callHandler(Object pValue, Stack<String> pPathParts, boolean pJsonify)
throws AttributeNotFoundException {
Class pClazz = pValue.getClass();
for (Extractor handler : handlers) {
if (handler.getType() != null && handler.getType().isAssignableFrom(pClazz)) {
return handler.extractObject(this,pValue,pPathParts,pJsonify);
}
}
throw new IllegalStateException(
"Internal error: No handler found for class " + pClazz +
" (object: " + pValue + ", extraArgs: " + pPathParts + ")");
}
// Used for testing only. Hence final and package local
ThreadLocal<ObjectSerializationContext> getStackContextLocal() {
return stackContextLocal;
}
// Simplifiers are added either explicitely or by reflection from a subpackage
private void addSimplifiers(List<Extractor> pHandlers, Extractor[] pSimplifyHandlers) {
if (pSimplifyHandlers != null && pSimplifyHandlers.length > 0) {
pHandlers.addAll(Arrays.asList(pSimplifyHandlers));
} else {
// Add all
pHandlers.addAll(ServiceObjectFactory.<Extractor>createServiceObjects(SIMPLIFIERS_DEFAULT_DEF, SIMPLIFIERS_DEF));
}
}
}