| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.springframework.jmx.support.MBeanRegistrationSupport
org.springframework.jmx.export.MBeanExporter
public class MBeanExporter
JMX exporter that allows for exposing any Spring-managed bean
 to a JMX MBeanServer, without the need to define any
 JMX-specific information in the bean classes.
 
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 MBeanExporterListeners
 can be registered via the
 listeners property,
 allowing application code to be notified of MBean registration and
 unregistration events.
 
This exporter is compatible with JMX 1.0 or higher for its basic functionality. However, for adapting AOP proxies where the target bean is a native MBean, JMX 1.2 is required. As of Spring 2.5, this class also autodetects and exports JDK 1.6 MXBeans.
setBeans(java.util.Map), 
setAutodetect(boolean), 
setAssembler(org.springframework.jmx.export.assembler.MBeanInfoAssembler), 
setListeners(org.springframework.jmx.export.MBeanExporterListener[]), 
MBeanInfoAssembler, 
MBeanExporterListener| Field Summary | |
|---|---|
| static int | AUTODETECT_ALLAutodetection mode indicating that all autodetection mechanisms should be used. | 
| static int | AUTODETECT_ASSEMBLERAutodetection mode indicating that only the MBeanInfoAssemblershould be able
 to autodetect beans. | 
| static int | AUTODETECT_MBEANAutodetection mode indicating that only valid MBeans should be autodetected. | 
| static int | AUTODETECT_NONEAutodetection mode indicating that no autodetection should be used. | 
| Fields inherited from class org.springframework.jmx.support.MBeanRegistrationSupport | 
|---|
| logger, registeredBeans, REGISTRATION_FAIL_ON_EXISTING, REGISTRATION_IGNORE_EXISTING, REGISTRATION_REPLACE_EXISTING, server | 
| Constructor Summary | |
|---|---|
| MBeanExporter() | |
| Method Summary | |
|---|---|
| protected  DynamicMBean | adaptMBeanIfPossible(Object bean)Build an adapted MBean for the given bean instance, if possible. | 
|  void | afterPropertiesSet()Start bean registration automatically when deployed in an ApplicationContext. | 
| protected  ModelMBean | createAndConfigureMBean(Object managedResource,
                        String beanKey)Creates an MBean that is configured with the appropriate management interface for the supplied managed resource. | 
| protected  ModelMBean | createModelMBean()Create an instance of a class that implements ModelMBean. | 
|  void | destroy()Unregisters all beans that this exported has exposed via JMX when the enclosing ApplicationContextis destroyed. | 
| protected  ObjectName | getObjectName(Object bean,
              String beanKey)Retrieve the ObjectNamefor a bean. | 
| protected  boolean | isBeanDefinitionLazyInit(ListableBeanFactory beanFactory,
                         String beanName)Return whether the specified bean definition should be considered as lazy-init. | 
| protected  boolean | isMBean(Class beanClass)Determine whether the given bean class qualifies as an MBean as-is. | 
| protected  void | onRegister(ObjectName objectName)Called when an MBean is registered. | 
| protected  void | onUnregister(ObjectName objectName)Called when an MBean is unregistered. | 
| protected  ObjectName | registerBeanNameOrInstance(Object mapValue,
                           String beanKey)Registers an individual bean with the MBeanServer. | 
| protected  void | registerBeans()Registers the defined beans with the MBeanServer. | 
|  ObjectName | registerManagedResource(Object managedResource)Register the supplied resource with JMX. | 
|  void | registerManagedResource(Object managedResource,
                        ObjectName objectName)Register the supplied resource with JMX. | 
|  void | setAllowEagerInit(boolean allowEagerInit)Specify whether to allow eager initialization of candidate beans when autodetecting MBeans in the Spring application context. | 
|  void | setAssembler(MBeanInfoAssembler assembler)Set the implementation of the MBeanInfoAssemblerinterface to use
 for this exporter. | 
|  void | setAutodetect(boolean autodetect)Set whether to autodetect MBeans in the bean factory that this exporter runs in. | 
|  void | setAutodetectMode(int autodetectMode)Set the autodetection mode to use. | 
|  void | setAutodetectModeName(String constantName)Set the autodetection mode to use by name. | 
|  void | setBeanClassLoader(ClassLoader classLoader)Callback that supplies the bean class loaderto
 a bean instance. | 
|  void | setBeanFactory(BeanFactory beanFactory)This callback is only required for resolution of bean names in the "beans"Mapand for
 autodetection of MBeans (in the latter case, aListableBeanFactoryis required). | 
|  void | setBeans(Map beans)Supply a Mapof beans to be registered with the JMXMBeanServer. | 
|  void | setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)Indicates whether Spring should ensure that ObjectNamesgenerated by the configuredObjectNamingStrategyfor
 runtime-registered MBeans should be modified to ensure uniqueness
 for every instance of a managedClass. | 
|  void | setExcludedBeans(String[] excludedBeans)Set the list of names for beans that should be excluded from autodetection. | 
|  void | setExposeManagedResourceClassLoader(boolean exposeManagedResourceClassLoader)Indicates whether or not the managed resource should be exposed on the thread context ClassLoaderbefore
 allowing any invocations on the MBean to occur. | 
|  void | setListeners(MBeanExporterListener[] listeners)Set the MBeanExporterListeners that should be notified
 of MBean registration and unregistration events. | 
|  void | setNamingStrategy(ObjectNamingStrategy namingStrategy)Set the implementation of the ObjectNamingStrategyinterface
 to use for this exporter. | 
|  void | setNotificationListenerMappings(Map listeners)Set the NotificationListenersto register
 with theMBeanServer. | 
|  void | setNotificationListeners(NotificationListenerBean[] notificationListeners)Set the NotificationListenerBeanscontaining theNotificationListenersthat will be registered with theMBeanServer. | 
| Methods inherited from class org.springframework.jmx.support.MBeanRegistrationSupport | 
|---|
| doRegister, doUnregister, getRegisteredObjectNames, getServer, onRegister, setRegistrationBehavior, setRegistrationBehaviorName, setServer, unregisterBeans | 
| Methods inherited from class java.lang.Object | 
|---|
| clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait | 
| Field Detail | 
|---|
public static final int AUTODETECT_NONE
public static final int AUTODETECT_MBEAN
public static final int AUTODETECT_ASSEMBLER
MBeanInfoAssembler should be able
 to autodetect beans.
public static final int AUTODETECT_ALL
| Constructor Detail | 
|---|
public MBeanExporter()
| Method Detail | 
|---|
public void setBeans(Map beans)
Map of beans to be registered with the JMX
 MBeanServer.
 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).
beans - Map with JMX names as keys and bean instances or bean names
 as valuessetNamingStrategy(org.springframework.jmx.export.naming.ObjectNamingStrategy), 
KeyNamingStrategy, 
ObjectName.ObjectName(String)public void setAutodetect(boolean autodetect)
AutodetectCapableMBeanInfoAssembler
 if available.
 This feature is turned off by default. Explicitly specify
 true here to enable autodetection.
setAssembler(org.springframework.jmx.export.assembler.MBeanInfoAssembler), 
AutodetectCapableMBeanInfoAssembler, 
isMBean(java.lang.Class)public void setAutodetectMode(int autodetectMode)
IllegalArgumentException - if the supplied value is not
 one of the AUTODETECT_ constantssetAutodetectModeName(String), 
AUTODETECT_ALL, 
AUTODETECT_ASSEMBLER, 
AUTODETECT_MBEAN, 
AUTODETECT_NONEpublic void setAutodetectModeName(String constantName)
IllegalArgumentException - if the supplied value is not resolvable
 to one of the AUTODETECT_ constants or is nullsetAutodetectMode(int), 
AUTODETECT_ALL, 
AUTODETECT_ASSEMBLER, 
AUTODETECT_MBEAN, 
AUTODETECT_NONEpublic void setAllowEagerInit(boolean allowEagerInit)
Default is "false", respecting lazy-init flags on bean definitions. Switch this to "true" in order to search lazy-init beans as well, including FactoryBean-produced objects that haven't been initialized yet.
public void setAssembler(MBeanInfoAssembler assembler)
MBeanInfoAssembler interface to use
 for this exporter. Default is a SimpleReflectiveMBeanInfoAssembler.
 The passed-in assembler can optionally implement the
 AutodetectCapableMBeanInfoAssembler interface, which enables it
 to participate in the exporter's MBean autodetection process.
SimpleReflectiveMBeanInfoAssembler, 
AutodetectCapableMBeanInfoAssembler, 
MetadataMBeanInfoAssembler, 
setAutodetect(boolean)public void setNamingStrategy(ObjectNamingStrategy namingStrategy)
ObjectNamingStrategy interface
 to use for this exporter. Default is a KeyNamingStrategy.
KeyNamingStrategy, 
MetadataNamingStrategypublic void setListeners(MBeanExporterListener[] listeners)
MBeanExporterListeners that should be notified
 of MBean registration and unregistration events.
MBeanExporterListenerpublic void setExcludedBeans(String[] excludedBeans)
public void setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)
ObjectNames
 generated by the configured ObjectNamingStrategy for
 runtime-registered MBeans should be modified to ensure uniqueness
 for every instance of a managed Class.
 The default value is true.
JmxUtils.appendIdentityToObjectName(javax.management.ObjectName, Object)public void setExposeManagedResourceClassLoader(boolean exposeManagedResourceClassLoader)
thread context ClassLoader before
 allowing any invocations on the MBean to occur.
 The default value is true, exposing a SpringModelMBean
 which performs thread context ClassLoader management. Switch this flag off to
 expose a standard JMX RequiredModelMBean.
public void setNotificationListeners(NotificationListenerBean[] notificationListeners)
NotificationListenerBeans
 containing the
 NotificationListeners
 that will be registered with the MBeanServer.
setNotificationListenerMappings(java.util.Map), 
NotificationListenerBeanpublic void setNotificationListenerMappings(Map listeners)
NotificationListeners to register
 with the MBeanServer.
 The key of each entry in the Map is a String
 representation of the 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
 NotificationListener to register. For more
 advanced options such as registering
 NotificationFilters and
 handback objects see setNotificationListeners(NotificationListenerBean[]).
IllegalArgumentException - if the supplied listeners Map is null.public void setBeanClassLoader(ClassLoader classLoader)
BeanClassLoaderAwareclass loader to
 a bean instance.
 Invoked after the population of normal bean properties but
 before an initialization callback such as
 InitializingBean's
 InitializingBean.afterPropertiesSet()
 method or a custom init-method.
setBeanClassLoader in interface BeanClassLoaderAwareclassLoader - the owning class loader; may be null in
 which case a default ClassLoader must be used, for example
 the ClassLoader obtained via
 ClassUtils.getDefaultClassLoader()public void setBeanFactory(BeanFactory beanFactory)
"beans" Map and for
 autodetection of MBeans (in the latter case, a
 ListableBeanFactory is required).
setBeanFactory in interface BeanFactoryAwarebeanFactory - owning BeanFactory (never null).
 The bean can immediately call methods on the factory.
IllegalArgumentException - if the supplied beanFactory is not a ListableBeanFactory.setBeans(java.util.Map), 
setAutodetect(boolean)public void afterPropertiesSet()
ApplicationContext.
afterPropertiesSet in interface InitializingBeanregisterBeans()public void destroy()
ApplicationContext is destroyed.
destroy in interface DisposableBean
public ObjectName registerManagedResource(Object managedResource)
                                   throws MBeanExportException
MBeanExportOperationsObjectName for the managed resource and returns this to the caller.
registerManagedResource in interface MBeanExportOperationsmanagedResource - the resource to expose via JMX
ObjectName under which the resource was exposed
MBeanExportException - if Spring is unable to generate an ObjectName
 or register the MBean
public void registerManagedResource(Object managedResource,
                                    ObjectName objectName)
                             throws MBeanExportException
MBeanExportOperations
registerManagedResource in interface MBeanExportOperationsmanagedResource - the resource to expose via JMXobjectName - the ObjectName under which to expose the resource
MBeanExportException - if Spring is unable to register the MBeanprotected void registerBeans()
MBeanServer.
 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.
protected boolean isBeanDefinitionLazyInit(ListableBeanFactory beanFactory,
                                           String beanName)
beanFactory - the bean factory that is supposed to contain the bean definitionbeanName - the name of the bean to checkConfigurableListableBeanFactory.getBeanDefinition(java.lang.String), 
BeanDefinition.isLazyInit()
protected ObjectName registerBeanNameOrInstance(Object mapValue,
                                                String beanKey)
                                         throws MBeanExportException
MBeanServer.
 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.
mapValue - the value configured for this bean in the beans map;
 may be either the String name of a bean, or the bean itselfbeanKey - the key associated with this bean in the beans map
ObjectName under which the resource was registered
MBeanExportException - if the export failedsetBeans(java.util.Map), 
registerBeanInstance(java.lang.Object, java.lang.String), 
registerLazyInit(java.lang.String, java.lang.String)
protected ObjectName getObjectName(Object bean,
                                   String beanKey)
                            throws MalformedObjectNameException
ObjectName for a bean.
 If the bean implements the SelfNaming interface, then the
 ObjectName will be retrieved using SelfNaming.getObjectName().
 Otherwise, the configured ObjectNamingStrategy is used.
bean - the name of the bean in the BeanFactorybeanKey - the key associated with the bean in the beans map
ObjectName for the supplied bean
MalformedObjectNameException - if the retrieved ObjectName is malformedprotected boolean isMBean(Class beanClass)
The default implementation delegates to JmxUtils.isMBean(java.lang.Class),
 which checks for DynamicMBean classes as well
 as classes with corresponding "*MBean" interface (Standard MBeans)
 or corresponding "*MXBean" interface (Java 6 MXBeans).
beanClass - the bean class to analyze
JmxUtils.isMBean(Class)
protected DynamicMBean adaptMBeanIfPossible(Object bean)
                                     throws JMException
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.
bean - the original bean instance
null if not possible
JMException
protected ModelMBean createAndConfigureMBean(Object managedResource,
                                             String beanKey)
                                      throws MBeanExportException
managedResource - the resource that is to be exported as an MBeanbeanKey - the key associated with the managed bean
MBeanExportExceptioncreateModelMBean(), 
getMBeanInfo(Object, String)
protected ModelMBean createModelMBean()
                               throws MBeanException
ModelMBean.
 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
ModelMBean
MBeanException - if creation of the ModelMBean failedprotected void onRegister(ObjectName objectName)
MBeanExporterListeners of the registration event.
 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.
onRegister in class MBeanRegistrationSupportobjectName - the ObjectName of the registered MBeanprotected void onUnregister(ObjectName objectName)
MBeanExporterListeners of the unregistration event.
 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.
onUnregister in class MBeanRegistrationSupportobjectName - the ObjectName of the unregistered MBean| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||