CompositeDataView (Java SE 22 & JDK 22)
Description: declaration: module: java.management, package: javax.management.openmbean, interface: CompositeDataView
Keywords: javax.management.openmbean.CompositeDataView interface

Module java.management
Package javax.management.openmbean

# Interface CompositeDataView

All Known Implementing Classes:
  `GarbageCollectionNotificationInfo`, `GcInfo`

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

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

- ## Method Details

  - ### 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`.