Java Doc for MBeanExporter.java in  » J2EE » spring-framework-2.5 » org » springframework » jmx » export » Java Source Code / Java DocumentationJava Source Code and Java Documentation

If the bean implements one of the JMX management interfaces, then MBeanExporter can simply register the MBean with the server automatically, through its autodetection process.

If the bean does not implement one of the JMX management interfaces, then MBeanExporter will create the management information using the supplied MBeanInfoAssembler implementation.

A list of MBeanExporterListener MBeanExporterListeners can be registered via the MBeanExporter.setListeners(MBeanExporterListener[]) listeners property, allowing application code to be notified of MBean registration and unregistration events.
author:
   Rob Harrop
author:
   Juergen Hoeller
author:
   Rick Evans
author:
   Mark Fisher
since:
   1.2
See Also:   MBeanExporter.setBeans
See Also:   MBeanExporter.setAutodetect
See Also:   MBeanExporter.setAssembler
See Also:   MBeanExporter.setListeners
See Also:   org.springframework.jmx.export.assembler.MBeanInfoAssembler
See Also:   MBeanExporterListener

This method is called to obtain a ModelMBean instance to use when registering a bean.

This method is responsible for deciding how a bean should be exposed to the MBeanServer.

Each bean is exposed to the MBeanServer via a ModelMBean.

The String keys are the basis for the creation of JMX object names. By default, a JMX ObjectName will be created straight from the given key.

The key of each entry in the Map is a String representation of the javax.management.ObjectName or the bean name of the MBean the listener should be registered for.

The default implementation builds a JMX 1.2 StandardMBean for the target's MBean/MXBean interface in case of an AOP proxy, delegating the interface's management operations to the proxy.
Parameters:
  bean - the original bean instance the adapted MBean, or null if not possible

This method is called to obtain a ModelMBean instance to use when registering a bean. This method is called once per bean during the registration phase and must return a new instance of ModelMBean a new instance of a class that implements ModelMBean
throws:
  javax.management.MBeanException - if creation of the ModelMBean failed

If the bean implements the SelfNaming interface, then the ObjectName will be retrieved using SelfNaming.getObjectName(). Otherwise, the configured ObjectNamingStrategy is used.
Parameters:
  bean - the name of the bean in the BeanFactory
Parameters:
  beanKey - the key associated with the bean in the beans map the ObjectName for the supplied bean
throws:
  javax.management.MalformedObjectNameException - if the retrieved ObjectName is malformed

The default implementation delegates to JmxUtils.isMBean , which checks for javax.management.DynamicMBean classes as well as classes with corresponding "*MBean" interface (Standard MBeans) or corresponding "*MXBean" interface (Java 6 MXBeans).
Parameters:
  beanClass - the bean class to analyze whether the class qualifies as an MBean
See Also:   org.springframework.jmx.support.JmxUtils.isMBean(Class)

Please note that if an MBeanExporterListener throws a (runtime) exception when notified, this will essentially interrupt the notification process and any remaining listeners that have yet to be notified will not (obviously) receive the MBeanExporterListener.mbeanRegistered(javax.management.ObjectName) callback.
Parameters:
  objectName - the ObjectName of the registered MBean

Please note that if an MBeanExporterListener throws a (runtime) exception when notified, this will essentially interrupt the notification process and any remaining listeners that have yet to be notified will not (obviously) receive the MBeanExporterListener.mbeanUnregistered(javax.management.ObjectName) callback.
Parameters:
  objectName - the ObjectName of the unregistered MBean

This method is responsible for deciding how a bean should be exposed to the MBeanServer. Specifically, if the supplied mapValue is the name of a bean that is configured for lazy initialization, then a proxy to the resource is registered with the MBeanServer so that the the lazy load behavior is honored. If the bean is already an MBean then it will be registered directly with the MBeanServer without any intervention. For all other beans or bean names, the resource itself is registered with the MBeanServer directly.
Parameters:
  mapValue - the value configured for this bean in the beans map;may be either the String name of a bean, or the bean itself
Parameters:
  beanKey - the key associated with this bean in the beans map the ObjectName under which the resource was registered
throws:
  MBeanExportException - if the export failed
See Also:   MBeanExporter.setBeans
See Also:   MBeanExporter.registerBeanInstance
See Also:   MBeanExporter.registerLazyInit

Each bean is exposed to the MBeanServer via a ModelMBean. The actual implemetation of the ModelMBean interface used depends on the implementation of the ModelMBeanProvider interface that is configured. By default the RequiredModelMBean class that is supplied with all JMX implementations is used.

The management interface produced for each bean is dependent on the MBeanInfoAssembler implementation being used. The ObjectName given to each bean is dependent on the implementation of the ObjectNamingStrategy interface being used.

The passed-in assembler can optionally implement the AutodetectCapableMBeanInfoAssembler interface, which enables it to participate in the exporter's MBean autodetection process.
See Also:   org.springframework.jmx.export.assembler.SimpleReflectiveMBeanInfoAssembler
See Also:   org.springframework.jmx.export.assembler.AutodetectCapableMBeanInfoAssembler
See Also:   org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler
See Also:   MBeanExporter.setAutodetect

This feature is turned off by default. Explicitly specify true here to enable autodetection.
See Also:   MBeanExporter.setAssembler
See Also:   AutodetectCapableMBeanInfoAssembler
See Also:   MBeanExporter.isMBean

The String keys are the basis for the creation of JMX object names. By default, a JMX ObjectName will be created straight from the given key. This can be customized through specifying a custom NamingStrategy.

Both bean instances and bean names are allowed as values. Bean instances are typically linked in through bean references. Bean names will be resolved as beans in the current factory, respecting lazy-init markers (that is, not triggering initialization of such beans).
Parameters:
  beans - Map with JMX names as keys and bean instances or bean namesas values
See Also:   MBeanExporter.setNamingStrategy
See Also:   org.springframework.jmx.export.naming.KeyNamingStrategy
See Also:   javax.management.ObjectName.ObjectName(String)

The default value is true.
See Also:   JmxUtils.appendIdentityToObjectName(javax.management.ObjectNameObject)

The key of each entry in the Map is a String representation of the javax.management.ObjectName or the bean name of the MBean the listener should be registered for. Specifying an asterisk (*) for a key will cause the listener to be associated with all MBeans registered by this class at startup time.

The value of each entry is the javax.management.NotificationListener to register. For more advanced options such as registering javax.management.NotificationFilter NotificationFilters and handback objects see MBeanExporter.setNotificationListeners(NotificationListenerBean[]) .
throws:
  IllegalArgumentException - if the supplied listeners Map is null.