openconverter.java

Mobile 应用程序使用 Java Micro Edition (Java ME) 平台

/*
 * @(#)OpenConverter.java	1.23 08/07/01
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.jmx.mbeanserver;

import static com.sun.jmx.mbeanserver.Util.*;

import com.sun.jmx.remote.util.EnvHelp;

import java.beans.ConstructorProperties;
import java.io.InvalidObjectException;
import java.lang.ref.WeakReference;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.WeakHashMap;
import javax.management.JMX;
import javax.management.ObjectName;
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeDataInvocationHandler;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeDataView;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
import javax.management.openmbean.TabularData;
import javax.management.openmbean.TabularDataSupport;
import javax.management.openmbean.TabularType;
import static javax.management.openmbean.SimpleType.*;

/**
   <p>A converter between Java types and the limited set of classes
   defined by Open MBeans.</p>

   <p>A Java type is an instance of java.lang.reflect.Type.  For our
   purposes, it is either a Class, such as String.class or int.class;
   or a ParameterizedType, such as List<String> or Map<Integer,
   String[]>.  On J2SE 1.4 and earlier, it can only be a Class.</p>

   <p>Each Type is associated with an OpenConverter.  The
   OpenConverter defines an OpenType corresponding to the Type, plus a
   Java class corresponding to the OpenType.  For example:</p>

   <pre>
   Type                     Open class     OpenType
   ----                     ----------     --------
   Integer		    Integer	   SimpleType.INTEGER
   int			    int 	   SimpleType.INTEGER
   Integer[]		    Integer[]	   ArrayType(1, SimpleType.INTEGER)
   int[]		    Integer[]	   ArrayType(SimpleType.INTEGER, true)
   String[][]		    String[][]	   ArrayType(2, SimpleType.STRING)
   List<String>		    String[]	   ArrayType(1, SimpleType.STRING)
   ThreadState (an Enum)    String         SimpleType.STRING
   Map<Integer, String[]>   TabularData	   TabularType(
   			    		     CompositeType(
					       {"key", SimpleType.INTEGER},
					       {"value",
					         ArrayType(1,
						  SimpleType.STRING)}),
					     indexNames={"key"})
   </pre>

   <p>Apart from simple types, arrays, and collections, Java types are
   converted through introspection into CompositeType.  The Java type
   must have at least one getter (method such as "int getSize()" or
   "boolean isBig()"), and we must be able to deduce how to
   reconstruct an instance of the Java class from the values of the
   getters using one of various heuristics.</p>

   @since 1.6
 */
public abstract class OpenConverter {
    private OpenConverter(Type targetType, OpenType openType,
			  Class openClass) {
	this.targetType = targetType;
	this.openType = openType;
	this.openClass = openClass;
    }

    /** <p>Convert an instance of openClass into an instance of targetType. */
    public final Object fromOpenValue(MXBeanLookup lookup, Object value)
            throws InvalidObjectException {
        if (value == null)
            return null;
        else
            return fromNonNullOpenValue(lookup, value);
    }

    abstract Object fromNonNullOpenValue(MXBeanLookup lookup, Object value)
            throws InvalidObjectException;

    /** <p>Throw an appropriate InvalidObjectException if we will not be able
        to convert back from the open data to the original Java object.</p> */
    void checkReconstructible() throws InvalidObjectException {
        // subclasses override if action necessary
    }

    /** <p>Convert an instance of targetType into an instance of openClass. */
    final Object toOpenValue(MXBeanLookup lookup, Object value)
            throws OpenDataException {
        if (value == null)
            return null;
        else
            return toNonNullOpenValue(lookup, value);
    }

    abstract Object toNonNullOpenValue(MXBeanLookup lookup, Object value)
            throws OpenDataException;

    /** <p>True if and only if this OpenConverter's toOpenValue and fromOpenValue
	methods are the identity function.</p> */
    boolean isIdentity() {
	return false;
    }

    final Type getTargetType() {
	return targetType;
    }

    final OpenType getOpenType() {
	return openType;
    }

    /* The Java class corresponding to getOpenType().  This is the class
       named by getOpenType().getClassName(), except that it may be a
       primitive type or an array of primitive type.  */
    final Class getOpenClass() {
	return openClass;
    }

    private final Type targetType;
    private final OpenType openType;
    private final Class openClass;

    private static final class ConverterMap
        extends WeakHashMap<Type, WeakReference<OpenConverter>> {}

    private static final ConverterMap converterMap = new ConverterMap();

    /** Following List simply serves to keep a reference to predefined
        OpenConverters so they don't get garbage collected. */
    private static final List<OpenConverter> permanentConverters = newList();

    private static synchronized OpenConverter getConverter(Type type) {
        // Work around bug 5041784:
        if (type instanceof GenericArrayType) {
            Type component = ((GenericArrayType) type).getGenericComponentType();
            if (component instanceof Class)
                type = Array.newInstance((Class<?>) component, 0).getClass();
        }

        WeakReference<OpenConverter> wr = converterMap.get(type);
        return (wr == null) ? null : wr.get();
    }

    private static synchronized void putConverter(Type type,
                                                  OpenConverter conv) {
        WeakReference<OpenConverter> wr =
            new WeakReference<OpenConverter>(conv);
        converterMap.put(type, wr);
    }

    private static synchronized void putPermanentConverter(Type type,
                                                           OpenConverter conv) {
        putConverter(type, conv);
        permanentConverters.add(conv);
    }

    static {
	/* Set up the mappings for Java types that map to SimpleType.  */

	final OpenType[] simpleTypes = {
	    BIGDECIMAL, BIGINTEGER, BOOLEAN, BYTE, CHARACTER, DATE,
	    DOUBLE, FLOAT, INTEGER, LONG, OBJECTNAME, SHORT, STRING,
	    VOID,
	};

	for (int i = 0; i < simpleTypes.length; i++) {
	    final OpenType t = simpleTypes[i];
	    Class c;
	    try {
		c = Class.forName(t.getClassName(), false,
				  ObjectName.class.getClassLoader());
	    } catch (ClassNotFoundException e) {
		// the classes that these predefined types declare must exist!
		throw new Error(e);
	    }
	    final OpenConverter conv = new IdentityConverter(c, t, c);
            putPermanentConverter(c, conv);

            if (c.getName().startsWith("java.lang.")) {
		try {
		    final Field typeField = c.getField("TYPE");
		    final Class primitiveType = (Class) typeField.get(null);
		    final OpenConverter primitiveConv =
			new IdentityConverter(primitiveType, t, primitiveType);
                    putPermanentConverter(primitiveType,
                                          primitiveConv);
                    if (primitiveType != void.class) {
                        final Class primitiveArrayType =
                            Array.newInstance(primitiveType, 0).getClass();
                        final OpenType primitiveArrayOpenType =
                            ArrayType.getPrimitiveArrayType(primitiveArrayType);
                        final OpenConverter primitiveArrayConv =
                            new IdentityConverter(primitiveArrayType,
                                                  primitiveArrayOpenType,
                                                  primitiveArrayType);
                        putPermanentConverter(primitiveArrayType,
                                              primitiveArrayConv);
                    }
		} catch (NoSuchFieldException e) {
		    // OK: must not be a primitive wrapper
		} catch (IllegalAccessException e) {
		    // Should not reach here
		    assert(false);
		}
	    }
	}
    }

    /** Get the converter for the given Java type, creating it if necessary. */
    public static synchronized OpenConverter toConverter(Type objType)
	    throws OpenDataException {

        if (inProgress.containsKey(objType)) {
            throw new OpenDataException(
                    "Recursive data structure, including " + typeName(objType));
        }

        OpenConverter conv;

	conv = getConverter(objType);
	if (conv != null)
            return conv;

        inProgress.put(objType, objType);
        try {
            conv = makeConverter(objType);
        } catch (OpenDataException e) {
            throw openDataException("Cannot convert type: " + objType, e);
        } finally {
            inProgress.remove(objType);
        }

	putConverter(objType, conv);
        return conv;
    }

    private static OpenConverter makeConverter(Type objType)
            throws OpenDataException {

	/* It's not yet worth formalizing these tests by having for example
	   an array of factory classes, each of which says whether it
	   recognizes the Type (Chain of Responsibility pattern).  */
        if (objType instanceof GenericArrayType) {
            Type componentType =
                ((GenericArrayType) objType).getGenericComponentType();
            return makeArrayOrCollectionConverter(objType, componentType);
        } else if (objType instanceof Class) {
            Class objClass = (Class<?>) objType;
            if (objClass.isEnum()) {
                return makeEnumConverter(objClass);
            } else if (objClass.isArray()) {
                Type componentType = objClass.getComponentType();
                return makeArrayOrCollectionConverter(objClass, componentType);
            } else if (JMX.isMXBeanInterface(objClass)) {
                return makeMXBeanConverter(objClass);
            } else {
                return makeCompositeConverter(objClass);
            }
        } else if (objType instanceof ParameterizedType) {
            return makeParameterizedConverter((ParameterizedType) objType);
        } else
            throw new OpenDataException("Cannot map type: " + objType);
    }

    private static <T extends Enum<T>> OpenConverter
	    makeEnumConverter(Class<T> enumClass) {
	return new EnumConverter<T>(enumClass);
    }

    /* Make the converter for an array type, or a collection such as
     * List<String> or Set<Integer>.  We never see one-dimensional
     * primitive arrays (e.g. int[]) here because they use the identity
     * converter and are registered as such in the static initializer.
     */
    private static OpenConverter
	makeArrayOrCollectionConverter(Type collectionType, Type elementType)
	    throws OpenDataException {

        final OpenConverter elementConverter = toConverter(elementType);
	final OpenType elementOpenType = elementConverter.getOpenType();
	final ArrayType openType = new ArrayType(1, elementOpenType);
	final Class elementOpenClass = elementConverter.getOpenClass();

	final Class openArrayClass;
        final String openArrayClassName;
        if (elementOpenClass.isArray())
            openArrayClassName = "[" + elementOpenClass.getName();
        else
            openArrayClassName = "[L" + elementOpenClass.getName() + ";";
        try {
            openArrayClass = Class.forName(openArrayClassName);
        } catch (ClassNotFoundException e) {
            throw openDataException("Cannot obtain array class", e);
        }

	if (collectionType instanceof ParameterizedType) {
	    return new CollectionConverter(collectionType,
					   openType, openArrayClass,
					   elementConverter);
        } else {
            if (elementConverter.isIdentity()) {
		return new IdentityConverter(collectionType,
                                             openType,
                                             openArrayClass);
	    } else {
		return new ArrayConverter(collectionType,
                                          openType,
                                          openArrayClass,
                                          elementConverter);
	    }
	}
    }

    private static final String[] keyArray = {"key"};
    private static final String[] keyValueArray = {"key", "value"};

    private static OpenConverter
	makeTabularConverter(Type objType, boolean sortedMap,
                             Type keyType, Type valueType)
	    throws OpenDataException {

	final String objTypeName = objType.toString();
	final OpenConverter keyConverter = toConverter(keyType);
	final OpenConverter valueConverter = toConverter(valueType);
	final OpenType keyOpenType = keyConverter.getOpenType();
	final OpenType valueOpenType = valueConverter.getOpenType();
	final CompositeType rowType =
	    new CompositeType(objTypeName,
			      objTypeName,
			      keyValueArray,
			      keyValueArray,
			      new OpenType[] {keyOpenType, valueOpenType});
	final TabularType tabularType =
	    new TabularType(objTypeName, objTypeName, rowType, keyArray);
	return new TabularConverter(objType, sortedMap, tabularType,
				    keyConverter, valueConverter);
    }

    /* We know how to translate List<E>, Set<E>, SortedSet<E>,
       Map<K,V>, SortedMap<K,V>, and that's it.  We don't accept
       subtypes of those because we wouldn't know how to deserialize
       them.  We don't accept Queue<E> because it is unlikely people
       would use that as a parameter or return type in an MBean.  */
    private static OpenConverter