Defines how types are mapped for a given MXBean or set of MXBeans. * An {@code MXBeanMappingFactory} can be specified either through the * {@link MXBeanMappingFactoryClass} annotation, or through the * {@link javax.management.JMX.MBeanOptions JMX.MBeanOptions} argument to a * {@link javax.management.StandardMBean StandardMBean} constructor or MXBean * proxy.
* *An {@code MXBeanMappingFactory} must return an {@code MXBeanMapping} * for any Java type that appears in the MXBeans that the factory is being * used for. Usually it does that by handling any custom types, and * forwarding everything else to the {@linkplain #DEFAULT default mapping * factory}.
* *Consider the {@code MyLinkedList} example from the {@link MXBeanMapping} * documentation. If we are unable to change the {@code MyLinkedList} class * to add an {@link MXBeanMappingClass} annotation, we could achieve the same * effect by defining {@code MyLinkedListMappingFactory} as follows:
* *
* public class MyLinkedListMappingFactory implements MXBeanMappingFactory {
* public MyLinkedListMappingFactory() {}
*
* public MXBeanMapping mappingForType(Type t, MXBeanMappingFactory f)
* throws OpenDataException {
* if (t == MyLinkedList.class)
* return new MyLinkedListMapping(t);
* else
* return MXBeanMappingFactory.DEFAULT.mappingForType(t, f);
* }
* }
*
*
* The mapping factory handles only the {@code MyLinkedList} class.
* Every other type is forwarded to the default mapping factory.
* This includes types such as {@code MyLinkedList[]} and
* {@code List
Once we have defined {@code MyLinkedListMappingFactory}, we can use * it in an MXBean interface like this:
* *
* {@literal @MXBeanMappingFactoryClass}(MyLinkedListMappingFactory.class)
* public interface SomethingMXBean {
* public MyLinkedList getSomething();
* }
*
*
* Alternatively we can annotate the package that {@code SomethingMXBean} * appears in, or we can supply the factory to a {@link * javax.management.StandardMBean StandardMBean} constructor or MXBean * proxy.
* * @see MXBean specification, section * "Custom MXBean type mappings" */ public abstract class MXBeanMappingFactory { /** *Construct an instance of this class.
*/ protected MXBeanMappingFactory() {} /** *Mapping factory that applies the default rules for MXBean * mappings, as described in the MXBean specification.
*/ public static final MXBeanMappingFactory DEFAULT = new DefaultMXBeanMappingFactory(); /** *Determine the appropriate MXBeanMappingFactory to use for the given * MXBean interface, based on its annotations. If the interface has an * {@link MXBeanMappingFactoryClass @MXBeanMappingFactoryClass} annotation, * that is used to determine the MXBeanMappingFactory. Otherwise, if the * package containing the interface has such an annotation, that is used. * Otherwise the MXBeanMappingFactory is the {@linkplain #DEFAULT default} * one.
* * @param intf the MXBean interface for which to determine the * MXBeanMappingFactory. * * @return the MXBeanMappingFactory for the given MXBean interface. * * @throws IllegalArgumentException if {@code intf} is null, or if an * exception occurs while trying constructing an MXBeanMappingFactory * based on an annotation. In the second case, the exception will appear * in the {@linkplain Throwable#getCause() cause chain} of the * {@code IllegalArgumentException}. */ public static MXBeanMappingFactory forInterface(Class intf) { if (intf == null) throw new IllegalArgumentException("Null interface"); MXBeanMappingFactoryClass annot = intf.getAnnotation(MXBeanMappingFactoryClass.class); if (annot == null) { Package p = intf.getPackage(); if (p != null) annot = p.getAnnotation(MXBeanMappingFactoryClass.class); } if (annot == null) return MXBeanMappingFactory.DEFAULT; Class factoryClass = annot.value(); try { return annot.value().newInstance(); } catch (Exception e) { throw new IllegalArgumentException( "Could not instantiate MXBeanMappingFactory " + factoryClass.getName() + " from @MXBeanMappingFactoryClass", e); } } /** *Return the mapping for the given Java type. Typically, a * mapping factory will return mappings for types it handles, and * forward other types to another mapping factory, most often * the {@linkplain #DEFAULT default one}.
* @param t the Java type to be mapped. * @param f the original mapping factory that was consulted to do * the mapping. A mapping factory should pass this parameter intact * if it forwards a type to another mapping factory. In the example, * this is how {@code MyLinkedListMappingFactory} works for types * like {@code MyLinkedList[]} and {@code List