Meta-annotation that describes how an annotation element relates * to a field in a 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.
* *(The DescriptorFields annotation * provides another way to add fields to a {@code Descriptor}. See * the documentation for that annotation for a comparison of the * two possibilities.)
* *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 * 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 with * each other and with any fields contributed by a * DescriptorFields annotation. 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 Class.getName() * (e.g. {@code "java.lang.Thread"}) |
| Enum constant (e.g. ElementType.FIELD) | *Constant name from 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 |
Do not include this field in the Descriptor if the annotation * element has its default value. For example, suppose {@code @Units} is * defined like this:
* *
* @Documented
* @Target(ElementType.METHOD)
* @Retention(RetentionPolicy.RUNTIME)
* public @interface Units {
* @DescriptorKey("units")
* String value();
*
* @DescriptorKey(value = "descriptionResourceKey",
* omitIfDefault = true)
* String resourceKey() default "";
*
* @DescriptorKey(value = "descriptionResourceBundleBaseName",
* omitIfDefault = true)
* String resourceBundleBaseName() default "";
* }
*
*
* Then consider a usage such as {@code @Units("bytes")} or * {@code @Units(value = "bytes", resourceKey = "")}, where the * {@code resourceKey} and {@code resourceBundleBaseNames} elements * have their default values. In this case the Descriptor resulting * from these annotations will not include a {@code descriptionResourceKey} * or {@code descriptionResourceBundleBaseName} field.
*/ boolean omitIfDefault() default false; }