1 /*

     2  * Copyright 1999-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.management;

    27 

    28 import java.io.IOException;

    29 import java.io.StreamCorruptedException;

    30 import java.io.Serializable;

    31 import java.io.ObjectOutputStream;

    32 import java.io.ObjectInputStream;

    33 import java.lang.reflect.Method;

    34 import java.util.Arrays;

    35 import java.util.Map;

    36 import java.util.WeakHashMap;

    37 import java.security.AccessController;

    38 import java.security.PrivilegedAction;

    39 

    40 import static javax.management.ImmutableDescriptor.nonNullDescriptor;

    41 

    42 /**

    43  * <p>Describes the management interface exposed by an MBean; that is,

    44  * the set of attributes and operations which are available for

    45  * management operations.  Instances of this class are immutable.

    46  * Subclasses may be mutable but this is not recommended.</p>

    47  *

    48  * <p>The contents of the <code>MBeanInfo</code> for a Dynamic MBean

    49  * are determined by its {@link DynamicMBean#getMBeanInfo

    50  * getMBeanInfo()} method.  This includes Open MBeans and Model

    51  * MBeans, which are kinds of Dynamic MBeans.</p>

    52  *

    53  * <p>The contents of the <code>MBeanInfo</code> for a Standard MBean

    54  * are determined by the MBean server as follows:</p>

    55  *

    56  * <ul>

    57  *

    58  * <li>{@link #getClassName()} returns the Java class name of the MBean

    59  * object;

    60  *

    61  * <li>{@link #getConstructors()} returns the list of all public

    62  * constructors in that object;

    63  *

    64  * <li>{@link #getAttributes()} returns the list of all attributes

    65  * whose existence is deduced from the presence in the MBean interface

    66  * of a <code>get<i>Name</i></code>, <code>is<i>Name</i></code>, or

    67  * <code>set<i>Name</i></code> method that conforms to the conventions

    68  * for Standard MBeans;

    69  *

    70  * <li>{@link #getOperations()} returns the list of all methods in

    71  * the MBean interface that do not represent attributes;

    72  *

    73  * <li>{@link #getNotifications()} returns an empty array if the MBean

    74  * does not implement the {@link NotificationBroadcaster} interface,

    75  * otherwise the result of calling {@link

    76  * NotificationBroadcaster#getNotificationInfo()} on it;

    77  *

    78  * <li>{@link #getDescriptor()} returns a descriptor containing the contents

    79  * of any descriptor annotations in the MBean interface.

    80  *

    81  * </ul>

    82  *

    83  * <p>The description returned by {@link #getDescription()} and the

    84  * descriptions of the contained attributes and operations are determined

    85  * by the corresponding <!-- link here --> Description annotations if any;

    86  * otherwise their contents are not specified.</p>

    87  *

    88  * <p>The remaining details of the <code>MBeanInfo</code> for a

    89  * Standard MBean are not specified.  This includes the description of

    90  * any contained constructors, and notifications; the names

    91  * of parameters to constructors and operations; and the descriptions of

    92  * constructor parameters.</p>

    93  *

    94  * @since 1.5

    95  */

    96 public class MBeanInfo implements Cloneable, Serializable, DescriptorRead {

    97 

    98     /* Serial version */

    99     static final long serialVersionUID = -6451021435135161911L;

   100 

   101     /**

   102      * @serial The Descriptor for the MBean.  This field

   103      * can be null, which is equivalent to an empty Descriptor.

   104      */

   105     private transient Descriptor descriptor;

   106 

   107     /**

   108      * @serial The human readable description of the class.

   109      */

   110     private final String description;

   111 

   112     /**

   113      * @serial The MBean qualified name.

   114      */

   115     private final String className;

   116 

   117     /**

   118      * @serial The MBean attribute descriptors.

   119      */

   120     private final MBeanAttributeInfo[] attributes;

   121 

   122     /**

   123      * @serial The MBean operation descriptors.

   124      */

   125     private final MBeanOperationInfo[] operations;

   126 

   127      /**

   128      * @serial The MBean constructor descriptors.

   129      */

   130     private final MBeanConstructorInfo[] constructors;

   131 

   132     /**

   133      * @serial The MBean notification descriptors.

   134      */

   135     private final MBeanNotificationInfo[] notifications;

   136 

   137     private transient int hashCode;

   138 

   139     /**

   140      * <p>True if this class is known not to override the array-valued

   141      * getters of MBeanInfo.  Obviously true for MBeanInfo itself, and true

   142      * for a subclass where we succeed in reflecting on the methods

   143      * and discover they are not overridden.</p>

   144      *

   145      * <p>The purpose of this variable is to avoid cloning the arrays

   146      * when doing operations like {@link #equals} where we know they

   147      * will not be changed.  If a subclass overrides a getter, we

   148      * cannot access the corresponding array directly.</p>

   149      */

   150     private final transient boolean arrayGettersSafe;

   151 

   152     /**

   153      * Constructs an <CODE>MBeanInfo</CODE>.

   154      *

   155      * @param className The name of the Java class of the MBean described

   156      * by this <CODE>MBeanInfo</CODE>.  This value may be any

   157      * syntactically legal Java class name.  It does not have to be a

   158      * Java class known to the MBean server or to the MBean's

   159      * ClassLoader.  If it is a Java class known to the MBean's

   160      * ClassLoader, it is recommended but not required that the

   161      * class's public methods include those that would appear in a

   162      * Standard MBean implementing the attributes and operations in

   163      * this MBeanInfo.

   164      * @param description A human readable description of the MBean (optional).

   165      * @param attributes The list of exposed attributes of the MBean.

   166      * This may be null with the same effect as a zero-length array.

   167      * @param constructors The list of public constructors of the

   168      * MBean.  This may be null with the same effect as a zero-length

   169      * array.

   170      * @param operations The list of operations of the MBean.  This

   171      * may be null with the same effect as a zero-length array.

   172      * @param notifications The list of notifications emitted.  This

   173      * may be null with the same effect as a zero-length array.

   174      */

   175     public MBeanInfo(String className,

   176                      String description,

   177                      MBeanAttributeInfo[] attributes,

   178                      MBeanConstructorInfo[] constructors,

   179                      MBeanOperationInfo[] operations,

   180                      MBeanNotificationInfo[] notifications)

   181             throws IllegalArgumentException {

   182         this(className, description, attributes, constructors, operations,

   183              notifications, null);

   184     }

   185 

   186     /**

   187      * Constructs an <CODE>MBeanInfo</CODE>.

   188      *

   189      * @param className The name of the Java class of the MBean described

   190      * by this <CODE>MBeanInfo</CODE>.  This value may be any

   191      * syntactically legal Java class name.  It does not have to be a

   192      * Java class known to the MBean server or to the MBean's

   193      * ClassLoader.  If it is a Java class known to the MBean's

   194      * ClassLoader, it is recommended but not required that the

   195      * class's public methods include those that would appear in a

   196      * Standard MBean implementing the attributes and operations in

   197      * this MBeanInfo.

   198      * @param description A human readable description of the MBean (optional).

   199      * @param attributes The list of exposed attributes of the MBean.

   200      * This may be null with the same effect as a zero-length array.

   201      * @param constructors The list of public constructors of the

   202      * MBean.  This may be null with the same effect as a zero-length

   203      * array.

   204      * @param operations The list of operations of the MBean.  This

   205      * may be null with the same effect as a zero-length array.

   206      * @param notifications The list of notifications emitted.  This

   207      * may be null with the same effect as a zero-length array.

   208      * @param descriptor The descriptor for the MBean.  This may be null

   209      * which is equivalent to an empty descriptor.

   210      *

   211      * @since 1.6

   212      */

   213     public MBeanInfo(String className,

   214                      String description,

   215                      MBeanAttributeInfo[] attributes,

   216                      MBeanConstructorInfo[] constructors,

   217                      MBeanOperationInfo[] operations,

   218                      MBeanNotificationInfo[] notifications,

   219                      Descriptor descriptor)

   220             throws IllegalArgumentException {

   221 

   222         this.className = className;

   223 

   224         this.description = description;

   225 

   226         if (attributes == null)

   227             attributes = MBeanAttributeInfo.NO_ATTRIBUTES;

   228         this.attributes = attributes;

   229 

   230         if (operations == null)

   231             operations = MBeanOperationInfo.NO_OPERATIONS;

   232         this.operations = operations;

   233 

   234         if (constructors == null)

   235             constructors = MBeanConstructorInfo.NO_CONSTRUCTORS;

   236         this.constructors = constructors;

   237 

   238         if (notifications == null)

   239             notifications = MBeanNotificationInfo.NO_NOTIFICATIONS;

   240         this.notifications = notifications;

   241 

   242         if (descriptor == null)

   243             descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;

   244         this.descriptor = descriptor;

   245 

   246         this.arrayGettersSafe =

   247                 arrayGettersSafe(this.getClass(), MBeanInfo.class);

   248     }

   249 

   250     /**

   251      * <p>Returns a shallow clone of this instance.

   252      * The clone is obtained by simply calling <tt>super.clone()</tt>,

   253      * thus calling the default native shallow cloning mechanism

   254      * implemented by <tt>Object.clone()</tt>.

   255      * No deeper cloning of any internal field is made.</p>

   256      *

   257      * <p>Since this class is immutable, the clone method is chiefly of

   258      * interest to subclasses.</p>

   259      */

   260      public Object clone () {

   261          try {

   262              return super.clone() ;

   263          } catch (CloneNotSupportedException e) {

   264              // should not happen as this class is cloneable

   265              return null;

   266          }

   267      }

   268 

   269 

   270     /**

   271      * Returns the name of the Java class of the MBean described by

   272      * this <CODE>MBeanInfo</CODE>.

   273      *

   274      * @return the class name.

   275      */

   276     public String getClassName()  {

   277         return className;

   278     }

   279 

   280     /**

   281      * Returns a human readable description of the MBean.

   282      *

   283      * @return the description.

   284      */

   285     public String getDescription()  {

   286         return description;

   287     }

   288 

   289     /**

   290      * Returns the list of attributes exposed for management.

   291      * Each attribute is described by an <CODE>MBeanAttributeInfo</CODE> object.

   292      *

   293      * The returned array is a shallow copy of the internal array,

   294      * which means that it is a copy of the internal array of

   295      * references to the <CODE>MBeanAttributeInfo</CODE> objects

   296      * but that each referenced <CODE>MBeanAttributeInfo</CODE> object is not copied.

   297      *

   298      * @return  An array of <CODE>MBeanAttributeInfo</CODE> objects.

   299      */

   300     public MBeanAttributeInfo[] getAttributes()   {

   301         MBeanAttributeInfo[] as = nonNullAttributes();

   302         if (as.length == 0)

   303             return as;

   304         else

   305             return as.clone();

   306     }

   307 

   308     private MBeanAttributeInfo[] fastGetAttributes() {

   309         if (arrayGettersSafe)

   310             return nonNullAttributes();

   311         else

   312             return getAttributes();

   313     }

   314 

   315     /**

   316      * Return the value of the attributes field, or an empty array if

   317      * the field is null.  This can't happen with a

   318      * normally-constructed instance of this class, but can if the

   319      * instance was deserialized from another implementation that

   320      * allows the field to be null.  It would be simpler if we enforced

   321      * the class invariant that these fields cannot be null by writing

   322      * a readObject() method, but that would require us to define the

   323      * various array fields as non-final, which is annoying because

   324      * conceptually they are indeed final.

   325      */

   326     private MBeanAttributeInfo[] nonNullAttributes() {

   327         return (attributes == null) ?

   328             MBeanAttributeInfo.NO_ATTRIBUTES : attributes;

   329     }

   330 

   331     /**

   332      * Returns the list of operations  of the MBean.

   333      * Each operation is described by an <CODE>MBeanOperationInfo</CODE> object.

   334      *

   335      * The returned array is a shallow copy of the internal array,

   336      * which means that it is a copy of the internal array of

   337      * references to the <CODE>MBeanOperationInfo</CODE> objects

   338      * but that each referenced <CODE>MBeanOperationInfo</CODE> object is not copied.

   339      *

   340      * @return  An array of <CODE>MBeanOperationInfo</CODE> objects.

   341      */

   342     public MBeanOperationInfo[] getOperations()  {

   343         MBeanOperationInfo[] os = nonNullOperations();

   344         if (os.length == 0)

   345             return os;

   346         else

   347             return os.clone();

   348     }

   349 

   350     private MBeanOperationInfo[] fastGetOperations() {

   351         if (arrayGettersSafe)

   352             return nonNullOperations();

   353         else

   354             return getOperations();

   355     }

   356 

   357     private MBeanOperationInfo[] nonNullOperations() {

   358         return (operations == null) ?

   359             MBeanOperationInfo.NO_OPERATIONS : operations;

   360     }

   361 

   362     /**

   363      * <p>Returns the list of the public constructors of the MBean.

   364      * Each constructor is described by an

   365      * <CODE>MBeanConstructorInfo</CODE> object.</p>

   366      *

   367      * <p>The returned array is a shallow copy of the internal array,

   368      * which means that it is a copy of the internal array of

   369      * references to the <CODE>MBeanConstructorInfo</CODE> objects but

   370      * that each referenced <CODE>MBeanConstructorInfo</CODE> object

   371      * is not copied.</p>

   372      *

   373      * <p>The returned list is not necessarily exhaustive.  That is,

   374      * the MBean may have a public constructor that is not in the

   375      * list.  In this case, the MBean server can construct another

   376      * instance of this MBean's class using that constructor, even

   377      * though it is not listed here.</p>

   378      *

   379      * @return  An array of <CODE>MBeanConstructorInfo</CODE> objects.

   380      */

   381     public MBeanConstructorInfo[] getConstructors()  {

   382         MBeanConstructorInfo[] cs = nonNullConstructors();

   383         if (cs.length == 0)

   384             return cs;

   385         else

   386             return cs.clone();

   387     }

   388 

   389     private MBeanConstructorInfo[] fastGetConstructors() {

   390         if (arrayGettersSafe)

   391             return nonNullConstructors();

   392         else

   393             return getConstructors();

   394     }

   395 

   396     private MBeanConstructorInfo[] nonNullConstructors() {

   397         return (constructors == null) ?

   398             MBeanConstructorInfo.NO_CONSTRUCTORS : constructors;

   399     }

   400 

   401     /**

   402      * Returns the list of the notifications emitted by the MBean.

   403      * Each notification is described by an <CODE>MBeanNotificationInfo</CODE> object.

   404      *

   405      * The returned array is a shallow copy of the internal array,

   406      * which means that it is a copy of the internal array of

   407      * references to the <CODE>MBeanNotificationInfo</CODE> objects

   408      * but that each referenced <CODE>MBeanNotificationInfo</CODE> object is not copied.

   409      *

   410      * @return  An array of <CODE>MBeanNotificationInfo</CODE> objects.

   411      */

   412     public MBeanNotificationInfo[] getNotifications()  {

   413         MBeanNotificationInfo[] ns = nonNullNotifications();

   414         if (ns.length == 0)

   415             return ns;

   416         else

   417             return ns.clone();

   418     }

   419 

   420     private MBeanNotificationInfo[] fastGetNotifications() {

   421         if (arrayGettersSafe)

   422             return nonNullNotifications();

   423         else

   424             return getNotifications();

   425     }

   426 

   427     private MBeanNotificationInfo[] nonNullNotifications() {

   428         return (notifications == null) ?

   429             MBeanNotificationInfo.NO_NOTIFICATIONS : notifications;

   430     }

   431 

   432     /**

   433      * Get the descriptor of this MBeanInfo.  Changing the returned value

   434      * will have no affect on the original descriptor.

   435      *

   436      * @return a descriptor that is either immutable or a copy of the original.

   437      *

   438      * @since 1.6

   439      */

   440     public Descriptor getDescriptor() {

   441         return (Descriptor) nonNullDescriptor(descriptor).clone();

   442     }

   443 

   444     public String toString() {

   445         return

   446             getClass().getName() + "[" +

   447             "description=" + getDescription() + ", " +

   448             "attributes=" + Arrays.asList(fastGetAttributes()) + ", " +

   449             "constructors=" + Arrays.asList(fastGetConstructors()) + ", " +

   450             "operations=" + Arrays.asList(fastGetOperations()) + ", " +

   451             "notifications=" + Arrays.asList(fastGetNotifications()) + ", " +

   452             "descriptor=" + getDescriptor() +

   453             "]";

   454     }

   455 

   456     /**

   457      * <p>Compare this MBeanInfo to another.  Two MBeanInfo objects

   458      * are equal if and only if they return equal values for {@link

   459      * #getClassName()}, for {@link #getDescription()}, and for

   460      * {@link #getDescriptor()}, and the

   461      * arrays returned by the two objects for {@link

   462      * #getAttributes()}, {@link #getOperations()}, {@link

   463      * #getConstructors()}, and {@link #getNotifications()} are

   464      * pairwise equal.  Here "equal" means {@link

   465      * Object#equals(Object)}, not identity.</p>

   466      *

   467      * <p>If two MBeanInfo objects return the same values in one of

   468      * their arrays but in a different order then they are not equal.</p>

   469      *

   470      * @param o the object to compare to.

   471      *

   472      * @return true if and only if <code>o</code> is an MBeanInfo that is equal

   473      * to this one according to the rules above.

   474      */

   475     public boolean equals(Object o) {

   476         if (o == this)

   477             return true;

   478         if (!(o instanceof MBeanInfo))

   479             return false;

   480         MBeanInfo p = (MBeanInfo) o;

   481         if (!isEqual(getClassName(),  p.getClassName()) ||

   482                 !isEqual(getDescription(), p.getDescription()) ||

   483                 !getDescriptor().equals(p.getDescriptor())) {

   484             return false;

   485         }

   486 

   487         return

   488             (Arrays.equals(p.fastGetAttributes(), fastGetAttributes()) &&

   489              Arrays.equals(p.fastGetOperations(), fastGetOperations()) &&

   490              Arrays.equals(p.fastGetConstructors(), fastGetConstructors()) &&

   491              Arrays.equals(p.fastGetNotifications(), fastGetNotifications()));

   492     }

   493 

   494     public int hashCode() {

   495         /* Since computing the hashCode is quite expensive, we cache it.

   496            If by some terrible misfortune the computed value is 0, the

   497            caching won't work and we will recompute it every time.

   498 

   499            We don't bother synchronizing, because, at worst, n different

   500            threads will compute the same hashCode at the same time.  */

   501         if (hashCode != 0)

   502             return hashCode;

   503 

   504         hashCode =

   505             getClassName().hashCode() ^

   506             getDescriptor().hashCode() ^

   507             arrayHashCode(fastGetAttributes()) ^

   508             arrayHashCode(fastGetOperations()) ^

   509             arrayHashCode(fastGetConstructors()) ^

   510             arrayHashCode(fastGetNotifications());

   511 

   512         return hashCode;

   513     }

   514 

   515     private static int arrayHashCode(Object[] array) {

   516         int hash = 0;

   517         for (int i = 0; i < array.length; i++)

   518             hash ^= array[i].hashCode();

   519         return hash;

   520     }

   521 

   522     /**

   523      * Cached results of previous calls to arrayGettersSafe.  This is

   524      * a WeakHashMap so that we don't prevent a class from being

   525      * garbage collected just because we know whether it's immutable.

   526      */

   527     private static final Map<Class, Boolean> arrayGettersSafeMap =

   528         new WeakHashMap<Class, Boolean>();

   529 

   530     /**

   531      * Return true if <code>subclass</code> is known to preserve the

   532      * immutability of <code>immutableClass</code>.  The class

   533      * <code>immutableClass</code> is a reference class that is known

   534      * to be immutable.  The subclass <code>subclass</code> is

   535      * considered immutable if it does not override any public method

   536      * of <code>immutableClass</code> whose name begins with "get".

   537      * This is obviously not an infallible test for immutability,

   538      * but it works for the public interfaces of the MBean*Info classes.

   539     */

   540     static boolean arrayGettersSafe(Class subclass, Class immutableClass) {

   541         if (subclass == immutableClass)

   542             return true;

   543         synchronized (arrayGettersSafeMap) {

   544             Boolean safe = arrayGettersSafeMap.get(subclass);

   545             if (safe == null) {

   546                 try {

   547                     ArrayGettersSafeAction action =

   548                         new ArrayGettersSafeAction(subclass, immutableClass);

   549                     safe = AccessController.doPrivileged(action);

   550                 } catch (Exception e) { // e.g. SecurityException

   551                     /* We don't know, so we assume it isn't.  */

   552                     safe = false;

   553                 }

   554                 arrayGettersSafeMap.put(subclass, safe);

   555             }

   556             return safe;

   557         }

   558     }

   559 

   560     /*

   561      * The PrivilegedAction stuff is probably overkill.  We can be

   562      * pretty sure the caller does have the required privileges -- a

   563      * JMX user that can't do reflection can't even use Standard

   564      * MBeans!  But there's probably a performance gain by not having

   565      * to check the whole call stack.

   566      */

   567     private static class ArrayGettersSafeAction

   568             implements PrivilegedAction<Boolean> {

   569 

   570         private final Class<?> subclass;

   571         private final Class<?> immutableClass;

   572 

   573         ArrayGettersSafeAction(Class<?> subclass, Class<?> immutableClass) {

   574             this.subclass = subclass;

   575             this.immutableClass = immutableClass;

   576         }

   577 

   578         public Boolean run() {

   579             Method[] methods = immutableClass.getMethods();

   580             for (int i = 0; i < methods.length; i++) {

   581                 Method method = methods[i];

   582                 String methodName = method.getName();

   583                 if (methodName.startsWith("get") &&

   584                         method.getParameterTypes().length == 0 &&

   585                         method.getReturnType().isArray()) {

   586                     try {

   587                         Method submethod =

   588                             subclass.getMethod(methodName);

   589                         if (!submethod.equals(method))

   590                             return false;

   591                     } catch (NoSuchMethodException e) {

   592                         return false;

   593                     }

   594                 }

   595             }

   596             return true;

   597         }

   598     }

   599 

   600     private static boolean isEqual(String s1, String s2) {

   601         boolean ret;

   602 

   603         if (s1 == null) {

   604             ret = (s2 == null);

   605         } else {

   606             ret = s1.equals(s2);

   607         }

   608 

   609         return ret;

   610     }

   611 

   612     /**

   613      * Serializes an {@link MBeanInfo} to an {@link ObjectOutputStream}.

   614      * @serialData

   615      * For compatibility reasons, an object of this class is serialized as follows.

   616      * <ul>

   617      * The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}

   618      * is called first to serialize the object except the field {@code descriptor}

   619      * which is declared as transient. The field {@code descriptor} is serialized

   620      * as follows:

   621      *     <ul>

   622      *     <li> If {@code descriptor} is an instance of the class

   623      *        {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write

   624      *        write(int val)} is called to write a byte with the value {@code 1},

   625      *        then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}

   626      *        is called twice to serialize the field names and the field values of the

   627      *        {@code descriptor}, respectively as a {@code String[]} and an

   628      *        {@code Object[]};</li>

   629      *     <li> Otherwise, the method {@link ObjectOutputStream#write write(int val)}

   630      *        is called to write a byte with the value {@code 0}, then the method

   631      *        {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called

   632      *        to serialize the field {@code descriptor} directly.

   633      *     </ul>

   634      * </ul>

   635      * @since 1.6

   636      */

   637     private void writeObject(ObjectOutputStream out) throws IOException {

   638         out.defaultWriteObject();

   639 

   640         if (descriptor.getClass() == ImmutableDescriptor.class) {

   641             out.write(1);

   642 

   643             final String[] names = descriptor.getFieldNames();

   644 

   645             out.writeObject(names);

   646             out.writeObject(descriptor.getFieldValues(names));

   647         } else {

   648             out.write(0);

   649 

   650             out.writeObject(descriptor);

   651         }

   652     }

   653 

   654     /**

   655      * Deserializes an {@link MBeanInfo} from an {@link ObjectInputStream}.

   656      * @serialData

   657      * For compatibility reasons, an object of this class is deserialized as follows.

   658      * <ul>

   659      * The method {@link ObjectInputStream#defaultReadObject defaultReadObject()}

   660      * is called first to deserialize the object except the field

   661      * {@code descriptor}, which is not serialized in the default way. Then the method

   662      * {@link ObjectInputStream#read read()} is called to read a byte, the field

   663      * {@code descriptor} is deserialized according to the value of the byte value:

   664      *    <ul>

   665      *    <li>1. The method {@link ObjectInputStream#readObject readObject()}

   666      *       is called twice to obtain the field names (a {@code String[]}) and

   667      *       the field values (a {@code Object[]}) of the {@code descriptor}.

   668      *       The two obtained values then are used to construct

   669      *       an {@link ImmutableDescriptor} instance for the field

   670      *       {@code descriptor};</li>

   671      *    <li>0. The value for the field {@code descriptor} is obtained directly

   672      *       by calling the method {@link ObjectInputStream#readObject readObject()}.

   673      *       If the obtained value is null, the field {@code descriptor} is set to

   674      *       {@link ImmutableDescriptor#EMPTY_DESCRIPTOR EMPTY_DESCRIPTOR};</li>

   675      *    <li>-1. This means that there is no byte to read and that the object is from

   676      *       an earlier version of the JMX API. The field {@code descriptor} is set to

   677      *       {@link ImmutableDescriptor#EMPTY_DESCRIPTOR EMPTY_DESCRIPTOR}.</li>

   678      *    <li>Any other value. A {@link StreamCorruptedException} is thrown.</li>

   679      *    </ul>

   680      * </ul>

   681      * @since 1.6

   682      */

   683 

   684     private void readObject(ObjectInputStream in)

   685         throws IOException, ClassNotFoundException {

   686 

   687         in.defaultReadObject();

   688 

   689         switch (in.read()) {

   690         case 1:

   691             final String[] names = (String[])in.readObject();

   692 

   693             if (names.length == 0) {

   694                 descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;

   695             } else {

   696                 final Object[] values = (Object[])in.readObject();

   697                 descriptor = new ImmutableDescriptor(names, values);

   698             }

   699 

   700             break;

   701         case 0:

   702             descriptor = (Descriptor)in.readObject();

   703 

   704             if (descriptor == null) {

   705                 descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;

   706             }

   707 

   708             break;

   709         case -1: // from an earlier version of the JMX API

   710             descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;

   711 

   712             break;

   713         default:

   714             throw new StreamCorruptedException("Got unexpected byte.");

   715         }

   716     }

   717 }