Meta-annotation that describes how an annotation element relates * to a field in a {@link Descriptor}. This can be the Descriptor for * an MBean, or for an attribute, operation, or constructor in an * MBean, or for a parameter of an operation or constructor.
* *Consider this annotation for example:
* *
* @Documented
* @Target(ElementType.METHOD)
* @Retention(RetentionPolicy.RUNTIME)
* public @interface Units {
* @DescriptorKey("units")
* String value();
* }
*
*
* and this use of the annotation:
* *
* public interface CacheControlMBean {
* @Units("bytes")
* public long getCacheSize();
* }
*
*
* When a Standard MBean is made from the {@code CacheControlMBean}, * the usual rules mean that it will have an attribute called * {@code CacheSize} of type {@code long}. The {@code @Units} * annotation, given the above definition, will ensure that the * {@link MBeanAttributeInfo} for this attribute will have a * {@code Descriptor} that has a field called {@code units} with * corresponding value {@code bytes}.
* *Similarly, if the annotation looks like this:
* *
* @Documented
* @Target(ElementType.METHOD)
* @Retention(RetentionPolicy.RUNTIME)
* public @interface Units {
* @DescriptorKey("units")
* String value();
*
* @DescriptorKey("descriptionResourceKey")
* String resourceKey() default "";
*
* @DescriptorKey("descriptionResourceBundleBaseName")
* String resourceBundleBaseName() default "";
* }
*
*
* and it is used like this:
* *
* public interface CacheControlMBean {
* @Units("bytes",
* resourceKey="bytes.key",
* resourceBundleBaseName="com.example.foo.MBeanResources")
* public long getCacheSize();
* }
*
*
* then the resulting {@code Descriptor} will contain the following * fields:
* *| Name | Value |
|---|---|
| units | "bytes" |
| descriptionResourceKey | "bytes.key" |
| descriptionResourceBundleBaseName | *"com.example.foo.MBeanResources" |
An annotation such as {@code @Units} can be applied to:
* *Other uses of the annotation are ignored.
* *Interface annotations are checked only on the exact interface * that defines the management interface of a Standard MBean or an * MXBean, not on its parent interfaces. Method annotations are * checked only in the most specific interface in which the method * appears; in other words, if a child interface overrides a method * from a parent interface, only {@code @DescriptorKey} annotations in * the method in the child interface are considered. * *
The Descriptor fields contributed in this way by different * annotations on the same program element must be consistent. That * is, two different annotations, or two members of the same * annotation, must not define a different value for the same * Descriptor field. Fields from annotations on a getter method must * also be consistent with fields from annotations on the * corresponding setter method.
* *The Descriptor resulting from these annotations will be merged * with any Descriptor fields provided by the implementation, such as * the {@code * immutableInfo} field for an MBean. The fields from the annotations * must be consistent with these fields provided by the implementation.
* *An annotation element to be converted into a descriptor field * can be of any type allowed by the Java language, except an annotation * or an array of annotations. The value of the field is derived from * the value of the annotation element as follows:
* *| Annotation element | Descriptor field |
|---|---|
| Primitive value ({@code 5}, {@code false}, etc) | *Wrapped value ({@code Integer.valueOf(5)}, * {@code Boolean.FALSE}, etc) |
| Class constant (e.g. {@code Thread.class}) | *Class name from {@link Class#getName()} * (e.g. {@code "java.lang.Thread"}) |
| Enum constant (e.g. {@link ElementType#FIELD}) | *Constant name from {@link Enum#name()} * (e.g. {@code "FIELD"}) |
| Array of class constants or enum constants | *String array derived by applying these rules to each * element |
| Value of any other type * ({@code String}, {@code String[]}, {@code int[]}, etc) |
* The same value |