javax.management.openmbean

## Interface CompositeDataView

-     public interface CompositeDataView

  A Java class can implement this interface to indicate how it is to be converted into a `CompositeData` by the MXBean framework.

  A typical way to use this class is to add extra items to the `CompositeData` in addition to the ones that are declared in the `CompositeType` supplied by the MXBean framework. To do this, you must create another `CompositeType` that has all the same items, plus your extra items.

  For example, suppose you have a class `Measure` that consists of a String called `units` and a `value` that is either a `long` or a `double`. It might look like this:

       public class Measure implements CompositeDataView {
           private String units;
           private Number value; // a Long or a Double

           public Measure(String units, Number value) {
               this.units = units;
               this.value = value;
           }

           public static Measure from(CompositeData cd) {
               return new Measure((String) cd.get("units"),
                                  (Number) cd.get("value"));
           }

           public String getUnits() {
               return units;
           }

           // Can't be called getValue(), because Number is not a valid type
           // in an MXBean, so the implied "value" property would be rejected.
           public Number _getValue() {
               return value;
           }

           public CompositeData toCompositeData(CompositeType ct) {
               try {
                   List<String> itemNames = new ArrayList<String>(ct.keySet());
                   List<String> itemDescriptions = new ArrayList<String>();
                   List<OpenType<?>> itemTypes = new ArrayList<OpenType<?>>();
                   for (String item : itemNames) {
                       itemDescriptions.add(ct.getDescription(item));
                       itemTypes.add(ct.getType(item));
                   }
                   itemNames.add("value");
                   itemDescriptions.add("long or double value of the measure");
                   itemTypes.add((value instanceof Long) ? SimpleType.LONG :
                                 SimpleType.DOUBLE);
                   CompositeType xct =
                       new CompositeType(ct.getTypeName(),
                                         ct.getDescription(),
                                         itemNames.toArray(new String[0]),
                                         itemDescriptions.toArray(new String[0]),
                                         itemTypes.toArray(new OpenType<?>[0]));
                   CompositeData cd =
                       new CompositeDataSupport(xct,
                                                new String[] {"units", "value"},
                                                new Object[] {units, value});
                   assert ct.isValue(cd);  // check we've done it right
                   return cd;
               } catch (Exception e) {
                   throw new RuntimeException(e);
               }
           }
       }

  The `CompositeType` that will appear in the `openType` field of the `Descriptor` for an attribute or operation of this type will show only the `units` item, but the actual `CompositeData` that is generated will have both `units` and `value`.

  Since:
    1.6
  See Also:
    `MXBean`

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `CompositeData` | `toCompositeData(CompositeType ct)` Return a `CompositeData` corresponding to the values in this object.

- - ### Method Detail

    - #### toCompositeData

          CompositeData toCompositeData(CompositeType ct)

      Return a `CompositeData` corresponding to the values in this object. The returned value should usually be an instance of `CompositeDataSupport`, or a class that serializes as a `CompositeDataSupport` via a `writeReplace` method. Otherwise, a remote client that receives the object might not be able to reconstruct it.

      Parameters:
        `ct` - The expected `CompositeType` of the returned value. If the returned value is `cd`, then `cd.getCompositeType().equals(ct)` should be true. Typically this will be because `cd` is a `CompositeDataSupport` constructed with `ct` as its `CompositeType`.
      Returns:
        the `CompositeData`.

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.