jdk-sandbox: comparison jdk/src/share/classes/com/sun/jmx/mbeanserver/MBeanIntrospector.java

equal deleted inserted replaced

-:460e37d40f12
+:acaa49a2768a
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.WeakHashMap;
-import javax.management.Description;
 import javax.management.Descriptor;
 import javax.management.ImmutableDescriptor;
 import javax.management.IntrospectionException;
 import javax.management.InvalidAttributeValueException;
-import javax.management.MBean;
 import javax.management.MBeanAttributeInfo;
 import javax.management.MBeanConstructorInfo;
 import javax.management.MBeanException;
 import javax.management.MBeanInfo;
 import javax.management.MBeanNotificationInfo;
 import javax.management.MBeanOperationInfo;
-import javax.management.MXBean;
-import javax.management.ManagedAttribute;
-import javax.management.ManagedOperation;
 import javax.management.NotCompliantMBeanException;
 import javax.management.NotificationBroadcaster;
-import javax.management.NotificationInfo;
-import javax.management.NotificationInfos;
 import javax.management.ReflectionException;
 /**
 * An introspector for MBeans of a certain type.  There is one instance
 * of this class for Standard MBeans, and one for every MXBeanMappingFactory;
 * which we could call getName, getGenericReturnType, etc.  A simpler approach
 * would be to wrap every Method in an object that does have a common
 * ancestor with ConvertingMethod.  But that would mean an extra object
 * for every Method in every Standard MBean interface.
 */
-public abstract class MBeanIntrospector<M> {
+abstract class MBeanIntrospector<M> {
 static final class PerInterfaceMap<M>
 extends WeakHashMap<Class<?>, WeakReference<PerInterface<M>>> {}
 /** The map from interface to PerInterface for this type of MBean. */
 abstract PerInterfaceMap<M> getPerInterfaceMap();
 * Construct an MBeanAttributeInfo for the given attribute based on the
 * given getter and setter.  One but not both of the getter and setter
 * may be null.
 */
 abstract MBeanAttributeInfo getMBeanAttributeInfo(String attributeName,
-M getter, M setter) throws IntrospectionException;
+M getter, M setter);
-final String getAttributeDescription(
-String attributeName, String defaultDescription,
-Method getter, Method setter) throws IntrospectionException {
-String g = Introspector.descriptionForElement(getter);
-String s = Introspector.descriptionForElement(setter);
-if (g == null) {
-if (s == null)
-return defaultDescription;
-else
-return s;
-} else if (s == null || g.equals(s)) {
-return g;
-} else {
-throw new IntrospectionException(
-"Inconsistent @Description on getter and setter for " +
-"attribute " + attributeName);
-}
-}
 /**
 * Construct an MBeanOperationInfo for the given operation based on
 * the M it was derived from.
 */
 abstract MBeanOperationInfo getMBeanOperationInfo(String operationName,
 * is resourceClass will always have.
 */
 abstract Descriptor getMBeanDescriptor(Class<?> resourceClass);
 /**
-* Get any additional Descriptor entries for this introspector instance.
-* If there is a non-default MXBeanMappingFactory, it will appear in
-* this Descriptor.
-* @return Additional Descriptor entries, or an empty Descriptor if none.
-*/
-Descriptor getSpecificMBeanDescriptor() {
-return ImmutableDescriptor.EMPTY_DESCRIPTOR;
-}
-void checkCompliance(Class<?> mbeanType) throws NotCompliantMBeanException {
-if (!mbeanType.isInterface() &&
-!mbeanType.isAnnotationPresent(MBean.class) &&
-!Introspector.hasMXBeanAnnotation(mbeanType)) {
-throw new NotCompliantMBeanException("Not an interface and " +
-"does not have @" + MBean.class.getSimpleName() +
-" or @" + MXBean.class.getSimpleName() + " annotation: " +
-mbeanType.getName());
-}
-}
-/**
 * Get the methods to be analyzed to build the MBean interface.
 */
 List<Method> getMethods(final Class<?> mbeanType) throws Exception {
-if (mbeanType.isInterface())
+return Arrays.asList(mbeanType.getMethods());
-return Arrays.asList(mbeanType.getMethods());
-final List<Method> methods = newList();
-getAnnotatedMethods(mbeanType, methods);
-return methods;
 }
 final PerInterface<M> getPerInterface(Class<?> mbeanInterface)
 throws NotCompliantMBeanException {
 PerInterfaceMap<M> map = getPerInterfaceMap();
 * its MBeanAttributeInfo[] and MBeanOperationInfo[] can be inserted
 * into such an MBeanInfo, and its Descriptor can be the basis for
 * the MBeanInfo's Descriptor.
 */
 private MBeanInfo makeInterfaceMBeanInfo(Class<?> mbeanInterface,
-MBeanAnalyzer<M> analyzer) throws IntrospectionException {
+MBeanAnalyzer<M> analyzer) {
 final MBeanInfoMaker maker = new MBeanInfoMaker();
 analyzer.visit(maker);
-final String defaultDescription =
+final String description =
 "Information on the management interface of the MBean";
-String description = Introspector.descriptionForElement(mbeanInterface);
-if (description == null)
-description = defaultDescription;
 return maker.makeMBeanInfo(mbeanInterface, description);
 }
 /** True if the given getter and setter are consistent. */
 final boolean consistent(M getter, M setter) {
 (t == null ? null : t.toString()));
 }
 /** A visitor that constructs the per-interface MBeanInfo. */
 private class MBeanInfoMaker
-implements MBeanAnalyzer.MBeanVisitor<M, IntrospectionException> {
+implements MBeanAnalyzer.MBeanVisitor<M> {
 public void visitAttribute(String attributeName,
 M getter,
-M setter) throws IntrospectionException {
+M setter) {
 MBeanAttributeInfo mbai =
 getMBeanAttributeInfo(attributeName, getter, setter);
 attrs.add(mbai);
 }
 "interfaceClassName=" + mbeanInterface.getName();
 final Descriptor classNameDescriptor =
 new ImmutableDescriptor(interfaceClassName);
 final Descriptor mbeanDescriptor = getBasicMBeanDescriptor();
 final Descriptor annotatedDescriptor =
-Introspector.descriptorForElement(mbeanInterface, false);
+Introspector.descriptorForElement(mbeanInterface);
 final Descriptor descriptor =
 DescriptorCache.getInstance().union(
 classNameDescriptor,
 mbeanDescriptor,
 annotatedDescriptor);
 /**
 * Return the MBeanInfo for the given resource, based on the given
 * per-interface data.
 */
-final MBeanInfo getMBeanInfo(Object resource, PerInterface<M> perInterface)
+final MBeanInfo getMBeanInfo(Object resource, PerInterface<M> perInterface) {
-throws NotCompliantMBeanException {
 MBeanInfo mbi =
 getClassMBeanInfo(resource.getClass(), perInterface);
-MBeanNotificationInfo[] notifs;
+MBeanNotificationInfo[] notifs = findNotifications(resource);
-try {
+if (notifs == null || notifs.length == 0)
-notifs = findNotifications(resource);
-} catch (RuntimeException e) {
-NotCompliantMBeanException x =
-new NotCompliantMBeanException(e.getMessage());
-x.initCause(e);
-throw x;
-}
-Descriptor d = getSpecificMBeanDescriptor();
-boolean anyNotifs = (notifs != null && notifs.length > 0);
-if (!anyNotifs && ImmutableDescriptor.EMPTY_DESCRIPTOR.equals(d))
 return mbi;
 else {
-d = ImmutableDescriptor.union(d, mbi.getDescriptor());
 return new MBeanInfo(mbi.getClassName(),
 mbi.getDescription(),
 mbi.getAttributes(),
 mbi.getConstructors(),
 mbi.getOperations(),
 notifs,
-d);
+mbi.getDescriptor());
 }
 }
 /**
 * Return the basic MBeanInfo for resources of the given class and
 }
 return mbi;
 }
 }
-/*
-* Add to "methods" every public method that has the @ManagedAttribute
-* or @ManagedOperation annotation, in the given class or any of
-* its superclasses or superinterfaces.
-*
-* We always add superclass or superinterface methods first, so that
-* the stable sort used by eliminateCovariantMethods will put the
-* method from the most-derived class last.  This means that we will
-* see the version of the @ManagedAttribute (or ...Operation) annotation
-* from that method, which might have a different description or whatever.
-*/
-public static void getAnnotatedMethods(Class<?> c, List<Method> methods)
-throws Exception {
-Class<?> sup = c.getSuperclass();
-if (sup != null)
-getAnnotatedMethods(sup, methods);
-Class<?>[] intfs = c.getInterfaces();
-for (Class<?> intf : intfs)
-getAnnotatedMethods(intf, methods);
-for (Method m : c.getMethods()) {
-// We are careful not to add m if it is inherited from a parent
-// class or interface, because duplicate methods lead to nasty
-// behaviour in eliminateCovariantMethods.
-if (m.getDeclaringClass() == c &&
-(m.isAnnotationPresent(ManagedAttribute.class) ||
-m.isAnnotationPresent(ManagedOperation.class)))
-methods.add(m);
-}
-}
-/*
-* Return the array of MBeanNotificationInfo for the given MBean object.
-* If the object implements NotificationBroadcaster and its
-* getNotificationInfo() method returns a non-empty array, then that
-* is the result.  Otherwise, if the object has a @NotificationInfo
-* or @NotificationInfos annotation, then its contents form the result.
-* Otherwise, the result is null.
-*/
 static MBeanNotificationInfo[] findNotifications(Object moi) {
-if (moi instanceof NotificationBroadcaster) {
+if (!(moi instanceof NotificationBroadcaster))
-MBeanNotificationInfo[] mbn =
-((NotificationBroadcaster) moi).getNotificationInfo();
-if (mbn != null && mbn.length > 0) {
-MBeanNotificationInfo[] result =
-new MBeanNotificationInfo[mbn.length];
-for (int i = 0; i < mbn.length; i++) {
-MBeanNotificationInfo ni = mbn[i];
-if (ni.getClass() != MBeanNotificationInfo.class)
-ni = (MBeanNotificationInfo) ni.clone();
-result[i] = ni;
-}
-return result;
-}
-} else {
-try {
-if (!MBeanInjector.injectsSendNotification(moi))
-return null;
-} catch (NotCompliantMBeanException e) {
-throw new RuntimeException(e);
-}
-}
-return findNotificationsFromAnnotations(moi.getClass());
-}
-public static MBeanNotificationInfo[] findNotificationsFromAnnotations(
-Class<?> mbeanClass) {
-Class<?> c = getAnnotatedNotificationInfoClass(mbeanClass);
-if (c == null)
 return null;
-NotificationInfo ni = c.getAnnotation(NotificationInfo.class);
+MBeanNotificationInfo[] mbn =
-NotificationInfos nis = c.getAnnotation(NotificationInfos.class);
+((NotificationBroadcaster) moi).getNotificationInfo();
-List<NotificationInfo> list = newList();
+if (mbn == null)
-if (ni != null)
-list.add(ni);
-if (nis != null)
-list.addAll(Arrays.asList(nis.value()));
-if (list.isEmpty())
 return null;
-List<MBeanNotificationInfo> mbnis = newList();
+MBeanNotificationInfo[] result =
-for (NotificationInfo x : list) {
+new MBeanNotificationInfo[mbn.length];
-// The Descriptor includes any fields explicitly specified by
+for (int i = 0; i < mbn.length; i++) {
-// x.descriptorFields(), plus any fields from the contained
+MBeanNotificationInfo ni = mbn[i];
-// @Description annotation.
+if (ni.getClass() != MBeanNotificationInfo.class)
-Descriptor d = new ImmutableDescriptor(x.descriptorFields());
+ni = (MBeanNotificationInfo) ni.clone();
-d = ImmutableDescriptor.union(
+result[i] = ni;
-d, Introspector.descriptorForAnnotation(x.description()));
+}
-MBeanNotificationInfo mbni = new MBeanNotificationInfo(
+return result;
-x.types(), x.notificationClass().getName(),
-x.description().value(), d);
-mbnis.add(mbni);
-}
-return mbnis.toArray(new MBeanNotificationInfo[mbnis.size()]);
-}
-private static final Map<Class<?>, WeakReference<Class<?>>>
-annotatedNotificationInfoClasses = newWeakHashMap();
-private static Class<?> getAnnotatedNotificationInfoClass(Class<?> baseClass) {
-synchronized (annotatedNotificationInfoClasses) {
-WeakReference<Class<?>> wr =
-annotatedNotificationInfoClasses.get(baseClass);
-if (wr != null)
-return wr.get();
-Class<?> c = null;
-if (baseClass.isAnnotationPresent(NotificationInfo.class) ||
-baseClass.isAnnotationPresent(NotificationInfos.class)) {
-c = baseClass;
-} else {
-Class<?>[] intfs = baseClass.getInterfaces();
-for (Class<?> intf : intfs) {
-Class<?> c1 = getAnnotatedNotificationInfoClass(intf);
-if (c1 != null) {
-if (c != null) {
-throw new IllegalArgumentException(
-"Class " + baseClass.getName() + " inherits " +
-"@NotificationInfo(s) from both " +
-c.getName() + " and " + c1.getName());
-}
-c = c1;
-}
-}
-}
-// Record the result of the search.  If no @NotificationInfo(s)
-// were found, c is null, and we store a WeakReference(null).
-// This prevents us from having to search again and fail again.
-annotatedNotificationInfoClasses.put(baseClass,
-new WeakReference<Class<?>>(c));
-return c;
-}
 }
 private static MBeanConstructorInfo[] findConstructors(Class<?> c) {
 Constructor<?>[] cons = c.getConstructors();
 MBeanConstructorInfo[] mbc = new MBeanConstructorInfo[cons.length];
 for (int i = 0; i < cons.length; i++) {
-String descr = "Public constructor of the MBean";
+final String descr = "Public constructor of the MBean";
-Description d = cons[i].getAnnotation(Description.class);
-if (d != null)
-descr = d.value();
 mbc[i] = new MBeanConstructorInfo(descr, cons[i]);
 }
 return mbc;
 }

changeset 4156	acaa49a2768a
parent 1702	50e12093123c
child 4328	9591511c1d88