public class MBeanExporter extends MBeanRegistrationSupport implements MBeanExportOperations, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, SmartInitializingSingleton, DisposableBean
MBeanServer
, without the need to define any
JMX-specific information in the bean classes.
If a bean implements one of the JMX management interfaces, MBeanExporter can simply register the MBean with the server through its autodetection process.
If a bean does not implement one of the JMX management interfaces, MBeanExporter
will create the management information using the supplied MBeanInfoAssembler
.
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 MBeans as well as MXBeans.
setBeans(java.util.Map<java.lang.String, java.lang.Object>)
,
setAutodetect(boolean)
,
setAssembler(org.springframework.jmx.export.assembler.MBeanInfoAssembler)
,
setListeners(org.springframework.jmx.export.MBeanExporterListener...)
,
MBeanInfoAssembler
,
MBeanExporterListener
Modifier and Type | Field and Description |
---|---|
static int |
AUTODETECT_ALL
Autodetection mode indicating that all autodetection mechanisms should be used.
|
static int |
AUTODETECT_ASSEMBLER
Autodetection mode indicating that only the
MBeanInfoAssembler should be able
to autodetect beans. |
static int |
AUTODETECT_MBEAN
Autodetection mode indicating that only valid MBeans should be autodetected.
|
static int |
AUTODETECT_NONE
Autodetection mode indicating that no autodetection should be used.
|
logger, server
Constructor and Description |
---|
MBeanExporter() |
Modifier and Type | Method and Description |
---|---|
protected javax.management.DynamicMBean |
adaptMBeanIfPossible(java.lang.Object bean)
Build an adapted MBean for the given bean instance, if possible.
|
void |
addExcludedBean(java.lang.String excludedBean)
Add the name of bean that should be excluded from autodetection.
|
void |
afterPropertiesSet()
Invoked by a BeanFactory after it has set all bean properties supplied
(and satisfied BeanFactoryAware and ApplicationContextAware).
|
void |
afterSingletonsInstantiated()
Kick off bean registration automatically after the regular singleton instantiation phase.
|
protected javax.management.modelmbean.ModelMBean |
createAndConfigureMBean(java.lang.Object managedResource,
java.lang.String beanKey)
Creates an MBean that is configured with the appropriate management
interface for the supplied managed resource.
|
protected javax.management.modelmbean.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
ApplicationContext is destroyed. |
protected javax.management.ObjectName |
getObjectName(java.lang.Object bean,
java.lang.String beanKey)
Retrieve the
ObjectName for a bean. |
protected boolean |
isBeanDefinitionLazyInit(ListableBeanFactory beanFactory,
java.lang.String beanName)
Return whether the specified bean definition should be considered as lazy-init.
|
protected boolean |
isMBean(java.lang.Class<?> beanClass)
Determine whether the given bean class qualifies as an MBean as-is.
|
protected void |
onRegister(javax.management.ObjectName objectName)
Called when an MBean is registered.
|
protected void |
onUnregister(javax.management.ObjectName objectName)
Called when an MBean is unregistered.
|
protected javax.management.ObjectName |
registerBeanNameOrInstance(java.lang.Object mapValue,
java.lang.String beanKey)
Register an individual bean with the
MBeanServer . |
protected void |
registerBeans()
Register the defined beans with the
MBeanServer . |
javax.management.ObjectName |
registerManagedResource(java.lang.Object managedResource)
Register the supplied resource with JMX.
|
void |
registerManagedResource(java.lang.Object managedResource,
javax.management.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
MBeanInfoAssembler interface 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(java.lang.String constantName)
Set the autodetection mode to use by name.
|
void |
setBeanClassLoader(java.lang.ClassLoader classLoader)
Callback that supplies the bean
class loader to
a bean instance. |
void |
setBeanFactory(BeanFactory beanFactory)
This callback is only required for resolution of bean names in the
"beans" Map and for
autodetection of MBeans (in the latter case, a
ListableBeanFactory is required). |
void |
setBeans(java.util.Map<java.lang.String,java.lang.Object> beans)
Supply a
Map of beans to be registered with the JMX
MBeanServer . |
void |
setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)
Indicates whether Spring should ensure that
ObjectNames
generated by the configured ObjectNamingStrategy for
runtime-registered MBeans (registerManagedResource(java.lang.Object) ) should get
modified: to ensure uniqueness for every instance of a managed Class . |
void |
setExcludedBeans(java.lang.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 ClassLoader before
allowing any invocations on the MBean to occur. |
void |
setListeners(MBeanExporterListener... listeners)
Set the
MBeanExporterListener s that should be notified
of MBean registration and unregistration events. |
void |
setNamingStrategy(ObjectNamingStrategy namingStrategy)
Set the implementation of the
ObjectNamingStrategy interface
to use for this exporter. |
void |
setNotificationListenerMappings(java.util.Map<?,? extends javax.management.NotificationListener> listeners)
Set the
NotificationListeners to register
with the MBeanServer . |
void |
setNotificationListeners(NotificationListenerBean... notificationListeners)
Set the
NotificationListenerBeans
containing the
NotificationListeners
that will be registered with the MBeanServer . |
void |
unregisterManagedResource(javax.management.ObjectName objectName)
Remove the specified MBean from the underlying MBeanServer registry.
|
doRegister, doUnregister, getRegisteredObjectNames, getServer, onRegister, setRegistrationPolicy, setServer, unregisterBeans
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
public void setBeans(java.util.Map<java.lang.String,java.lang.Object> 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.
public void setAutodetectMode(int autodetectMode)
java.lang.IllegalArgumentException
- if the supplied value is not
one of the AUTODETECT_
constantssetAutodetectModeName(String)
,
AUTODETECT_ALL
,
AUTODETECT_ASSEMBLER
,
AUTODETECT_MBEAN
,
AUTODETECT_NONE
public void setAutodetectModeName(java.lang.String constantName)
java.lang.IllegalArgumentException
- if the supplied value is not resolvable
to one of the AUTODETECT_
constants or is null
setAutodetectMode(int)
,
AUTODETECT_ALL
,
AUTODETECT_ASSEMBLER
,
AUTODETECT_MBEAN
,
AUTODETECT_NONE
public 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.
public void setNamingStrategy(ObjectNamingStrategy namingStrategy)
ObjectNamingStrategy
interface
to use for this exporter. Default is a KeyNamingStrategy
.KeyNamingStrategy
,
MetadataNamingStrategy
public void setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)
ObjectNames
generated by the configured ObjectNamingStrategy
for
runtime-registered MBeans (registerManagedResource(java.lang.Object)
) should get
modified: to ensure uniqueness for every instance of a managed Class
.
The default value is true
.
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 setExcludedBeans(java.lang.String... excludedBeans)
public void addExcludedBean(java.lang.String excludedBean)
public void setListeners(MBeanExporterListener... listeners)
MBeanExporterListener
s that should be notified
of MBean registration and unregistration events.MBeanExporterListener
public void setNotificationListeners(NotificationListenerBean... notificationListeners)
NotificationListenerBeans
containing the
NotificationListeners
that will be registered with the MBeanServer
.public void setNotificationListenerMappings(java.util.Map<?,? extends javax.management.NotificationListener> 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[])
.
public void setBeanClassLoader(java.lang.ClassLoader classLoader)
BeanClassLoaderAware
class 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 BeanClassLoaderAware
classLoader
- the owning class loaderpublic void setBeanFactory(BeanFactory beanFactory)
"beans"
Map
and for
autodetection of MBeans (in the latter case, a
ListableBeanFactory
is required).setBeanFactory
in interface BeanFactoryAware
beanFactory
- owning BeanFactory (never null
).
The bean can immediately call methods on the factory.setBeans(java.util.Map<java.lang.String, java.lang.Object>)
,
setAutodetect(boolean)
public void afterPropertiesSet()
InitializingBean
This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.
afterPropertiesSet
in interface InitializingBean
public void afterSingletonsInstantiated()
afterSingletonsInstantiated
in interface SmartInitializingSingleton
registerBeans()
public void destroy()
ApplicationContext
is destroyed.destroy
in interface DisposableBean
public javax.management.ObjectName registerManagedResource(java.lang.Object managedResource) throws MBeanExportException
MBeanExportOperations
ObjectName
for the managed resource and returns this to the caller.registerManagedResource
in interface MBeanExportOperations
managedResource
- the resource to expose via JMXObjectName
under which the resource was exposedMBeanExportException
- if Spring is unable to generate an ObjectName
or register the MBeanpublic void registerManagedResource(java.lang.Object managedResource, javax.management.ObjectName objectName) throws MBeanExportException
MBeanExportOperations
registerManagedResource
in interface MBeanExportOperations
managedResource
- the resource to expose via JMXobjectName
- the ObjectName
under which to expose the resourceMBeanExportException
- if Spring is unable to register the MBeanpublic void unregisterManagedResource(javax.management.ObjectName objectName)
MBeanExportOperations
unregisterManagedResource
in interface MBeanExportOperations
objectName
- the ObjectName
of the resource to removeprotected 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, java.lang.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 javax.management.ObjectName registerBeanNameOrInstance(java.lang.Object mapValue, java.lang.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 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 mapObjectName
under which the resource was registeredMBeanExportException
- if the export failedsetBeans(java.util.Map<java.lang.String, java.lang.Object>)
,
registerBeanInstance(java.lang.Object, java.lang.String)
,
registerLazyInit(java.lang.String, java.lang.String)
protected javax.management.ObjectName getObjectName(java.lang.Object bean, @Nullable java.lang.String beanKey) throws javax.management.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 BeanFactory
beanKey
- the key associated with the bean in the beans mapObjectName
for the supplied beanjavax.management.MalformedObjectNameException
- if the retrieved ObjectName
is malformedprotected boolean isMBean(@Nullable java.lang.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 analyzeJmxUtils.isMBean(Class)
@Nullable protected javax.management.DynamicMBean adaptMBeanIfPossible(java.lang.Object bean) throws javax.management.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 instancenull
if not possiblejavax.management.JMException
protected javax.management.modelmbean.ModelMBean createAndConfigureMBean(java.lang.Object managedResource, java.lang.String beanKey) throws MBeanExportException
managedResource
- the resource that is to be exported as an MBeanbeanKey
- the key associated with the managed beanMBeanExportException
createModelMBean()
,
getMBeanInfo(Object, String)
protected javax.management.modelmbean.ModelMBean createModelMBean() throws javax.management.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
javax.management.MBeanException
- if creation of the ModelMBean failedprotected void onRegister(javax.management.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 MBeanRegistrationSupport
objectName
- the ObjectName
of the registered MBeanprotected void onUnregister(javax.management.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 MBeanRegistrationSupport
objectName
- the ObjectName
of the unregistered MBean