Module java.management
Package javax.management.openmbean

## Class CompositeDataInvocationHandler

- java.lang.Object
- - javax.management.openmbean.CompositeDataInvocationHandler

- All Implemented Interfaces:
    `InvocationHandler`

      public class CompositeDataInvocationHandler
      extends Object
      implements InvocationHandler

  An `InvocationHandler` that forwards getter methods to a `CompositeData`. If you have an interface that contains only getter methods (such as `String getName()` or `boolean isActive()`) then you can use this class in conjunction with the `Proxy` class to produce an implementation of the interface where each getter returns the value of the corresponding item in a `CompositeData`.

  For example, suppose you have an interface like this:

  >        public interface NamedNumber {
  >            public int getNumber();
  >            public String getName();
  >        }

  and a `CompositeData` constructed like this:

  >        CompositeData cd =
  >            new CompositeDataSupport(
  >                someCompositeType,
  >                new String[] {"number", "name"},
  >                new Object[] {5, "five"}
  >            );

  then you can construct an object implementing `NamedNumber` and backed by the object `cd` like this:

  >        InvocationHandler handler =
  >            new CompositeDataInvocationHandler(cd);
  >        NamedNumber nn = (NamedNumber)
  >            Proxy.newProxyInstance(NamedNumber.class.getClassLoader(),
  >                                   new Class[] {NamedNumber.class},
  >                                   handler);

  A call to `nn.getNumber()` will then return 5.

  If the first letter of the property defined by a getter is a capital, then this handler will look first for an item in the `CompositeData` beginning with a capital, then, if that is not found, for an item beginning with the corresponding lowercase letter or code point. For a getter called `getNumber()`, the handler will first look for an item called `Number`, then for `number`. If the getter is called `getnumber()`, then the item must be called `number`.

  If the method given to `invoke` is the method `boolean equals(Object)` inherited from `Object`, then it will return true if and only if the argument is a `Proxy` whose `InvocationHandler` is also a `CompositeDataInvocationHandler` and whose backing `CompositeData` is equal (not necessarily identical) to this object's. If the method given to `invoke` is the method `int hashCode()` inherited from `Object`, then it will return a value that is consistent with this definition of `equals`: if two objects are equal according to `equals`, then they will have the same `hashCode`.

  Since:
    1.6

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `CompositeDataInvocationHandler​(CompositeData compositeData)` | Construct a handler backed by the given `CompositeData`.

  - ### Method Summary

    Modifier and Type | Method | Description
    --- | --- | ---
    `CompositeData` | `getCompositeData()` | Return the `CompositeData` that was supplied to the constructor.

    - ### Methods declared in class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods declared in interface java.lang.reflect.InvocationHandler

      `invoke`

- - ### Constructor Detail

    - #### CompositeDataInvocationHandler

          public CompositeDataInvocationHandler​(CompositeData compositeData)

      Construct a handler backed by the given `CompositeData`.

      Parameters:
        `compositeData` - the `CompositeData` that will supply information to getters.
      Throws:
        `IllegalArgumentException` - if `compositeData` is null.

  - ### Method Detail

    - #### getCompositeData

          public CompositeData getCompositeData()

      Return the `CompositeData` that was supplied to the constructor.
      Returns:
        the `CompositeData` that this handler is backed by. This is never null.