/* * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.sun.jmx.mbeanserver; import com.sun.jmx.mbeanserver.MBeanIntrospector.MBeanInfoMap;import com.sun.jmx.mbeanserver.MBeanIntrospector.PerInterfaceMap;import java.lang.annotation.Annotation;import java.lang.reflect.GenericArrayType;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import javax.management.Descriptor;import javax.management.ImmutableDescriptor;import javax.management.MBeanAttributeInfo;import javax.management.MBeanException;import javax.management.MBeanOperationInfo;import javax.management.MBeanParameterInfo;import javax.management.NotCompliantMBeanException;import javax.management.openmbean.OpenMBeanAttributeInfoSupport;import javax.management.openmbean.OpenMBeanOperationInfoSupport;import javax.management.openmbean.OpenMBeanParameterInfo;import javax.management.openmbean.OpenMBeanParameterInfoSupport;import javax.management.openmbean.OpenType; /** * Introspector for MXBeans.  There is exactly one instance of this class. * * @since 1.6 */class MXBeanIntrospector extends MBeanIntrospector<ConvertingMethod> {    private static final MXBeanIntrospector instance = new MXBeanIntrospector();     static MXBeanIntrospector getInstance() {        return instance;    }     @Override    PerInterfaceMap<ConvertingMethod> getPerInterfaceMap() {        return perInterfaceMap;    }     @Override    MBeanInfoMap getMBeanInfoMap() {        return mbeanInfoMap;    }     @Override    MBeanAnalyzer<ConvertingMethod> getAnalyzer(Class<?> mbeanInterface)            throws NotCompliantMBeanException {        return MBeanAnalyzer.analyzer(mbeanInterface, this);    }     @Override    boolean isMXBean() {        return true;    }     @Override    ConvertingMethod mFrom(Method m) {        return ConvertingMethod.from(m);    }     @Override    String getName(ConvertingMethod m) {        return m.getName();    }     @Override    Type getGenericReturnType(ConvertingMethod m) {        return m.getGenericReturnType();    }     @Override    Type[] getGenericParameterTypes(ConvertingMethod m) {        return m.getGenericParameterTypes();    }     @Override    String[] getSignature(ConvertingMethod m) {        return m.getOpenSignature();    }     @Override    void checkMethod(ConvertingMethod m) {        m.checkCallFromOpen();    }     @Override    Object invokeM2(ConvertingMethod m, Object target, Object[] args,                    Object cookie)            throws InvocationTargetException, IllegalAccessException,                   MBeanException {        return m.invokeWithOpenReturn((MXBeanLookup) cookie, target, args);    }     @Override    boolean validParameter(ConvertingMethod m, Object value, int paramNo,                           Object cookie) {        if (value == null) {            // Null is a valid value for all OpenTypes, even though            // OpenType.isValue(null) will return false.  It can always be            // matched to the corresponding Java type, except when that            // type is primitive.            Type t = m.getGenericParameterTypes()[paramNo];            return (!(t instanceof Class<?>) || !((Class<?>) t).isPrimitive());        } else {            Object v;            try {                v = m.fromOpenParameter((MXBeanLookup) cookie, value, paramNo);            } catch (Exception e) {                // Ignore the exception and let MBeanIntrospector.invokeSetter()                // throw the initial exception.                return true;            }            return isValidParameter(m.getMethod(), v, paramNo);        }    }     @Override    MBeanAttributeInfo getMBeanAttributeInfo(String attributeName,            ConvertingMethod getter, ConvertingMethod setter) {         final boolean isReadable = (getter != null);        final boolean isWritable = (setter != null);        final boolean isIs = isReadable && getName(getter).startsWith("is");         final String description = attributeName;         final OpenType<?> openType;        final Type originalType;        if (isReadable) {            openType = getter.getOpenReturnType();            originalType = getter.getGenericReturnType();        } else {            openType = setter.getOpenParameterTypes()[0];            originalType = setter.getGenericParameterTypes()[0];        }        Descriptor descriptor = typeDescriptor(openType, originalType);        if (isReadable) {            descriptor = ImmutableDescriptor.union(descriptor,                    getter.getDescriptor());        }        if (isWritable) {            descriptor = ImmutableDescriptor.union(descriptor,                    setter.getDescriptor());        }         final MBeanAttributeInfo ai;        if (canUseOpenInfo(originalType)) {            ai = new OpenMBeanAttributeInfoSupport(attributeName,                                                   description,                                                   openType,                                                   isReadable,                                                   isWritable,                                                   isIs,                                                   descriptor);        } else {            ai = new MBeanAttributeInfo(attributeName,                                        originalTypeString(originalType),                                        description,                                        isReadable,                                        isWritable,                                        isIs,                                        descriptor);        }        // could also consult annotations for defaultValue,        // minValue, maxValue, legalValues         return ai;    }     @Override    MBeanOperationInfo getMBeanOperationInfo(String operationName,            ConvertingMethod operation) {        final Method method = operation.getMethod();        final String description = operationName;        /* Ideally this would be an empty string, but           OMBOperationInfo constructor forbids that.  Also, we           could consult an annotation to get a useful           description.  */         final int impact = MBeanOperationInfo.UNKNOWN;         final OpenType<?> returnType = operation.getOpenReturnType();        final Type originalReturnType = operation.getGenericReturnType();        final OpenType<?>[] paramTypes = operation.getOpenParameterTypes();        final Type[] originalParamTypes = operation.getGenericParameterTypes();        final MBeanParameterInfo[] params =            new MBeanParameterInfo[paramTypes.length];        boolean openReturnType = canUseOpenInfo(originalReturnType);        boolean openParameterTypes = true;        Annotation[][] annots = method.getParameterAnnotations();        for (int i = 0; i < paramTypes.length; i++) {            final String paramName = "p" + i;            final String paramDescription = paramName;            final OpenType<?> openType = paramTypes[i];            final Type originalType = originalParamTypes[i];            Descriptor descriptor =                typeDescriptor(openType, originalType);            descriptor = ImmutableDescriptor.union(descriptor,                    Introspector.descriptorForAnnotations(annots[i]));            final MBeanParameterInfo pi;            if (canUseOpenInfo(originalType)) {                pi = new OpenMBeanParameterInfoSupport(paramName,                                                       paramDescription,                                                       openType,                                                       descriptor);            } else {                openParameterTypes = false;                pi = new MBeanParameterInfo(                    paramName,                    originalTypeString(originalType),                    paramDescription,                    descriptor);            }            params[i] = pi;        }         Descriptor descriptor =            typeDescriptor(returnType, originalReturnType);        descriptor = ImmutableDescriptor.union(descriptor,                Introspector.descriptorForElement(method));        final MBeanOperationInfo oi;        if (openReturnType && openParameterTypes) {            /* If the return value and all the parameters can be faithfully             * represented as OpenType then we return an OpenMBeanOperationInfo.             * If any of them is a primitive type, we can't.  Compatibility             * with JSR 174 means that we must return an MBean*Info where             * the getType() is the primitive type, not its wrapped type as             * we would get with an OpenMBean*Info.  The OpenType is available             * in the Descriptor in either case.             */            final OpenMBeanParameterInfo[] oparams =                new OpenMBeanParameterInfo[params.length];            System.arraycopy(params, 0, oparams, 0, params.length);            oi = new OpenMBeanOperationInfoSupport(operationName,                                                   description,                                                   oparams,                                                   returnType,                                                   impact,                                                   descriptor);        } else {            oi = new MBeanOperationInfo(operationName,                                        description,                                        params,                                        openReturnType ?                                        returnType.getClassName() :                                        originalTypeString(originalReturnType),                                        impact,                                        descriptor);        }         return oi;    }     @Override    Descriptor getBasicMBeanDescriptor() {        return new ImmutableDescriptor("mxbean=true",                                       "immutableInfo=true");    }     @Override    Descriptor getMBeanDescriptor(Class<?> resourceClass) {        /* We already have immutableInfo=true in the Descriptor         * included in the MBeanInfo for the MXBean interface.  This         * method is being called for the MXBean *class* to add any         * new items beyond those in the interface Descriptor, which         * currently it does not.         */        return ImmutableDescriptor.EMPTY_DESCRIPTOR;    }     private static Descriptor typeDescriptor(OpenType<?> openType,                                             Type originalType) {        return new ImmutableDescriptor(            new String[] {"openType",                          "originalType"},            new Object[] {openType,                          originalTypeString(originalType)});    }     /**     * <p>True if this type can be faithfully represented in an     * OpenMBean*Info.</p>     *     * <p>Compatibility with JSR 174 means that primitive types must be     * represented by an MBean*Info whose getType() is the primitive type     * string, e.g. "int".  If we used an OpenMBean*Info then this string     * would be the wrapped type, e.g. "java.lang.Integer".</p>     *     * <p>Compatibility with JMX 1.2 (including J2SE 5.0) means that arrays     * of primitive types cannot use an ArrayType representing an array of     * primitives, because that didn't exist in JMX 1.2.</p>     */    private static boolean canUseOpenInfo(Type type) {        if (type instanceof GenericArrayType) {            return canUseOpenInfo(                ((GenericArrayType) type).getGenericComponentType());        } else if (type instanceof Class<?> && ((Class<?>) type).isArray()) {            return canUseOpenInfo(                ((Class<?>) type).getComponentType());        }        return (!(type instanceof Class<?> && ((Class<?>) type).isPrimitive()));    }     private static String originalTypeString(Type type) {        if (type instanceof Class<?>)            return ((Class<?>) type).getName();        else            return typeName(type);    }     static String typeName(Type type) {        if (type instanceof Class<?>) {            Class<?> c = (Class<?>) type;            if (c.isArray())                return typeName(c.getComponentType()) + "[]";            else                return c.getName();        } else if (type instanceof GenericArrayType) {            GenericArrayType gat = (GenericArrayType) type;            return typeName(gat.getGenericComponentType()) + "[]";        } else if (type instanceof ParameterizedType) {            ParameterizedType pt = (ParameterizedType) type;            StringBuilder sb = new StringBuilder();            sb.append(typeName(pt.getRawType())).append("<");            String sep = "";            for (Type t : pt.getActualTypeArguments()) {                sb.append(sep).append(typeName(t));                sep = ", ";            }            return sb.append(">").toString();        } else            return "???";    }     private final PerInterfaceMap<ConvertingMethod>        perInterfaceMap = new PerInterfaceMap<ConvertingMethod>();     private static final MBeanInfoMap mbeanInfoMap = new MBeanInfoMap();}