类 MBeanExporter
- java.lang.Object
- org.springframework.jmx.support.MBeanRegistrationSupport
- org.springframework.jmx.export.MBeanExporter
- 所有已实现的接口:
Aware
,BeanClassLoaderAware
,BeanFactoryAware
,DisposableBean
,InitializingBean
,SmartInitializingSingleton
,MBeanExportOperations
- 直接已知子类:
AnnotationMBeanExporter
public class MBeanExporter extends MBeanRegistrationSupport implements MBeanExportOperations, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, SmartInitializingSingleton, DisposableBean
JMX exporter that allows for exposing any Spring-managed bean to a JMXMBeanServer
, 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 thelisteners
property, allowing application code to be notified of MBean registration and unregistration events.This exporter is compatible with MBeans as well as MXBeans.
- 从以下版本开始:
- 1.2
- 作者:
- Rob Harrop, Juergen Hoeller, Rick Evans, Mark Fisher, Stephane Nicoll
- 另请参阅:
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
字段概要
字段 修饰符和类型 字段 说明 static int
AUTODETECT_ALL
Autodetection mode indicating that all autodetection mechanisms should be used.static int
AUTODETECT_ASSEMBLER
Autodetection mode indicating that only theMBeanInfoAssembler
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.从类继承的字段 org.springframework.jmx.support.MBeanRegistrationSupport
logger, REGISTRATION_FAIL_ON_EXISTING, REGISTRATION_IGNORE_EXISTING, REGISTRATION_REPLACE_EXISTING, server
构造器概要
构造器 构造器 说明 MBeanExporter()
方法概要
所有方法 实例方法 具体方法 修饰符和类型 方法 说明 protected DynamicMBean
adaptMBeanIfPossible(Object bean)
Build an adapted MBean for the given bean instance, if possible.void
addExcludedBean(String excludedBean)
Add the name of bean that should be excluded from autodetection.void
afterPropertiesSet()
Invoked by the containingBeanFactory
after it has set all bean properties and satisfiedBeanFactoryAware
,ApplicationContextAware
etc.void
afterSingletonsInstantiated()
Kick off bean registration automatically after the regular singleton instantiation phase.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 implementsModelMBean
.void
destroy()
Unregisters all beans that this exported has exposed via JMX when the enclosingApplicationContext
is destroyed.protected ObjectName
getObjectName(Object bean, String beanKey)
Retrieve theObjectName
for 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)
Register an individual bean with theMBeanServer
.protected void
registerBeans()
Register the defined beans with theMBeanServer
.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 theMBeanInfoAssembler
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(String constantName)
Set the autodetection mode to use by name.void
setBeanClassLoader(ClassLoader classLoader)
Callback that supplies the beanclass loader
to a bean instance.void
setBeanFactory(BeanFactory beanFactory)
void
setBeans(Map<String,Object> beans)
Supply aMap
of beans to be registered with the JMXMBeanServer
.void
setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)
Indicates whether Spring should ensure thatObjectNames
generated by the configuredObjectNamingStrategy
for runtime-registered MBeans (registerManagedResource(java.lang.Object)
) should get 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 thethread context ClassLoader
before allowing any invocations on the MBean to occur.void
setListeners(MBeanExporterListener... listeners)
Set theMBeanExporterListener
s that should be notified of MBean registration and unregistration events.void
setNamingStrategy(ObjectNamingStrategy namingStrategy)
Set the implementation of theObjectNamingStrategy
interface to use for this exporter.void
setNotificationListenerMappings(Map<?,? extends NotificationListener> listeners)
Set theNotificationListeners
to register with theMBeanServer
.void
setNotificationListeners(NotificationListenerBean... notificationListeners)
Set theNotificationListenerBeans
containing theNotificationListeners
that will be registered with theMBeanServer
.void
unregisterManagedResource(ObjectName objectName)
Remove the specified MBean from the underlying MBeanServer registry.从类继承的方法 org.springframework.jmx.support.MBeanRegistrationSupport
doRegister, doUnregister, getRegisteredObjectNames, getServer, onRegister, setRegistrationBehavior, setRegistrationBehaviorName, setRegistrationPolicy, setServer, unregisterBeans
字段详细资料
AUTODETECT_NONE
public static final int AUTODETECT_NONE
Autodetection mode indicating that no autodetection should be used.- 另请参阅:
- 常量字段值
AUTODETECT_MBEAN
public static final int AUTODETECT_MBEAN
Autodetection mode indicating that only valid MBeans should be autodetected.- 另请参阅:
- 常量字段值
AUTODETECT_ASSEMBLER
public static final int AUTODETECT_ASSEMBLER
Autodetection mode indicating that only theMBeanInfoAssembler
should be able to autodetect beans.- 另请参阅:
- 常量字段值
AUTODETECT_ALL
public static final int AUTODETECT_ALL
Autodetection mode indicating that all autodetection mechanisms should be used.- 另请参阅:
- 常量字段值
构造器详细资料
MBeanExporter
public MBeanExporter()
方法详细资料
setBeans
public void setBeans(Map<String,Object> beans)
Supply aMap
of beans to be registered with the JMXMBeanServer
.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 customNamingStrategy
.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 values- 另请参阅:
setNamingStrategy(org.springframework.jmx.export.naming.ObjectNamingStrategy)
,KeyNamingStrategy
,ObjectName(String)
setAutodetect
public void setAutodetect(boolean autodetect)
Set whether to autodetect MBeans in the bean factory that this exporter runs in. Will also ask anAutodetectCapableMBeanInfoAssembler
if available.This feature is turned off by default. Explicitly specify
true
here to enable autodetection.
setAutodetectMode
public void setAutodetectMode(int autodetectMode)
Set the autodetection mode to use.- 抛出:
IllegalArgumentException
- if the supplied value is not one of theAUTODETECT_
constants- 另请参阅:
setAutodetectModeName(String)
,AUTODETECT_ALL
,AUTODETECT_ASSEMBLER
,AUTODETECT_MBEAN
,AUTODETECT_NONE
setAutodetectModeName
public void setAutodetectModeName(String constantName)
Set the autodetection mode to use by name.- 抛出:
IllegalArgumentException
- if the supplied value is not resolvable to one of theAUTODETECT_
constants or isnull
- 另请参阅:
setAutodetectMode(int)
,AUTODETECT_ALL
,AUTODETECT_ASSEMBLER
,AUTODETECT_MBEAN
,AUTODETECT_NONE
setAllowEagerInit
public void setAllowEagerInit(boolean allowEagerInit)
Specify whether to allow eager initialization of candidate beans when autodetecting MBeans in the Spring application context.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.
setAssembler
public void setAssembler(MBeanInfoAssembler assembler)
Set the implementation of theMBeanInfoAssembler
interface to use for this exporter. Default is aSimpleReflectiveMBeanInfoAssembler
.The passed-in assembler can optionally implement the
AutodetectCapableMBeanInfoAssembler
interface, which enables it to participate in the exporter's MBean autodetection process.
setNamingStrategy
public void setNamingStrategy(ObjectNamingStrategy namingStrategy)
Set the implementation of theObjectNamingStrategy
interface to use for this exporter. Default is aKeyNamingStrategy
.
setEnsureUniqueRuntimeObjectNames
public void setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)
Indicates whether Spring should ensure thatObjectNames
generated by the configuredObjectNamingStrategy
for runtime-registered MBeans (registerManagedResource(java.lang.Object)
) should get modified: to ensure uniqueness for every instance of a managedClass
.The default value is
true
.
setExposeManagedResourceClassLoader
public void setExposeManagedResourceClassLoader(boolean exposeManagedResourceClassLoader)
Indicates whether or not the managed resource should be exposed on thethread context ClassLoader
before allowing any invocations on the MBean to occur.The default value is
true
, exposing aSpringModelMBean
which performs thread context ClassLoader management. Switch this flag off to expose a standard JMXRequiredModelMBean
.
setExcludedBeans
public void setExcludedBeans(String... excludedBeans)
Set the list of names for beans that should be excluded from autodetection.
addExcludedBean
public void addExcludedBean(String excludedBean)
Add the name of bean that should be excluded from autodetection.
setListeners
public void setListeners(MBeanExporterListener... listeners)
Set theMBeanExporterListener
s that should be notified of MBean registration and unregistration events.
setNotificationListeners
public void setNotificationListeners(NotificationListenerBean... notificationListeners)
Set theNotificationListenerBeans
containing theNotificationListeners
that will be registered with theMBeanServer
.
setNotificationListenerMappings
public void setNotificationListenerMappings(Map<?,? extends NotificationListener> listeners)
Set theNotificationListeners
to register with theMBeanServer
.The key of each entry in the
Map
is aString
representation of theObjectName
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 registeringNotificationFilters
and handback objects seesetNotificationListeners(NotificationListenerBean[])
.
setBeanClassLoader
public void setBeanClassLoader(ClassLoader classLoader)
从接口复制的说明:BeanClassLoaderAware
Callback that supplies the beanclass 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
在接口中BeanClassLoaderAware
- 参数:
classLoader
- the owning class loader; may benull
in which case a defaultClassLoader
must be used, for example theClassLoader
obtained viaClassUtils.getDefaultClassLoader()
setBeanFactory
public 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, aListableBeanFactory
is required).- 指定者:
setBeanFactory
在接口中BeanFactoryAware
- 参数:
beanFactory
- owning BeanFactory (nevernull
). The bean can immediately call methods on the factory.- 另请参阅:
setBeans(java.util.Map<java.lang.String, java.lang.Object>)
,setAutodetect(boolean)
afterPropertiesSet
public void afterPropertiesSet()
从接口复制的说明:InitializingBean
Invoked by the containingBeanFactory
after it has set all bean properties and satisfiedBeanFactoryAware
,ApplicationContextAware
etc.This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.
- 指定者:
afterPropertiesSet
在接口中InitializingBean
afterSingletonsInstantiated
public void afterSingletonsInstantiated()
Kick off bean registration automatically after the regular singleton instantiation phase.
destroy
public void destroy()
Unregisters all beans that this exported has exposed via JMX when the enclosingApplicationContext
is destroyed.- 指定者:
destroy
在接口中DisposableBean
registerManagedResource
public ObjectName registerManagedResource(Object managedResource) throws MBeanExportException
从接口复制的说明:MBeanExportOperations
Register the supplied resource with JMX. If the resource is not a valid MBean already, Spring will generate a management interface for it. The exact interface generated will depend on the implementation and its configuration. This call also generates anObjectName
for the managed resource and returns this to the caller.- 指定者:
registerManagedResource
在接口中MBeanExportOperations
- 参数:
managedResource
- the resource to expose via JMX- 返回:
- the
ObjectName
under which the resource was exposed - 抛出:
MBeanExportException
- if Spring is unable to generate anObjectName
or register the MBean
registerManagedResource
public void registerManagedResource(Object managedResource, ObjectName objectName) throws MBeanExportException
从接口复制的说明:MBeanExportOperations
Register the supplied resource with JMX. If the resource is not a valid MBean already, Spring will generate a management interface for it. The exact interface generated will depend on the implementation and its configuration.- 指定者:
registerManagedResource
在接口中MBeanExportOperations
- 参数:
managedResource
- the resource to expose via JMXobjectName
- theObjectName
under which to expose the resource- 抛出:
MBeanExportException
- if Spring is unable to register the MBean
unregisterManagedResource
public void unregisterManagedResource(ObjectName objectName)
从接口复制的说明:MBeanExportOperations
Remove the specified MBean from the underlying MBeanServer registry.- 指定者:
unregisterManagedResource
在接口中MBeanExportOperations
- 参数:
objectName
- theObjectName
of the resource to remove
registerBeans
protected void registerBeans()
Register the defined beans with theMBeanServer
.Each bean is exposed to the
MBeanServer
via aModelMBean
. The actual implemetation of theModelMBean
interface used depends on the implementation of theModelMBeanProvider
interface that is configured. By default theRequiredModelMBean
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. TheObjectName
given to each bean is dependent on the implementation of theObjectNamingStrategy
interface being used.
isBeanDefinitionLazyInit
protected boolean isBeanDefinitionLazyInit(ListableBeanFactory beanFactory, String beanName)
Return whether the specified bean definition should be considered as lazy-init.- 参数:
beanFactory
- the bean factory that is supposed to contain the bean definitionbeanName
- the name of the bean to check- 另请参阅:
ConfigurableListableBeanFactory.getBeanDefinition(java.lang.String)
,BeanDefinition.isLazyInit()
registerBeanNameOrInstance
protected ObjectName registerBeanNameOrInstance(Object mapValue, String beanKey) throws MBeanExportException
Register an individual bean with theMBeanServer
.This method is responsible for deciding how a bean should be exposed to the
MBeanServer
. Specifically, if the suppliedmapValue
is the name of a bean that is configured for lazy initialization, then a proxy to the resource is registered with theMBeanServer
so that the lazy load behavior is honored. If the bean is already an MBean then it will be registered directly with theMBeanServer
without any intervention. For all other beans or bean names, the resource itself is registered with theMBeanServer
directly.- 参数:
mapValue
- the value configured for this bean in the beans map; may be either theString
name of a bean, or the bean itselfbeanKey
- the key associated with this bean in the beans map- 返回:
- the
ObjectName
under which the resource was registered, ornull
if the actual resource wasnull
as well - 抛出:
MBeanExportException
- if the export failed- 另请参阅:
setBeans(java.util.Map<java.lang.String, java.lang.Object>)
,registerBeanInstance(java.lang.Object, java.lang.String)
,registerLazyInit(java.lang.String, java.lang.String)
getObjectName
protected ObjectName getObjectName(Object bean, String beanKey) throws MalformedObjectNameException
Retrieve theObjectName
for a bean.If the bean implements the
SelfNaming
interface, then theObjectName
will be retrieved usingSelfNaming.getObjectName()
. Otherwise, the configuredObjectNamingStrategy
is used.- 参数:
bean
- the name of the bean in theBeanFactory
beanKey
- the key associated with the bean in the beans map- 返回:
- the
ObjectName
for the supplied bean - 抛出:
MalformedObjectNameException
- if the retrievedObjectName
is malformed
isMBean
protected boolean isMBean(Class<?> beanClass)
Determine whether the given bean class qualifies as an MBean as-is.The default implementation delegates to
JmxUtils.isMBean(java.lang.Class<?>)
, which checks forDynamicMBean
classes as well as classes with corresponding "*MBean" interface (Standard MBeans) or corresponding "*MXBean" interface (Java 6 MXBeans).- 参数:
beanClass
- the bean class to analyze- 返回:
- whether the class qualifies as an MBean
- 另请参阅:
JmxUtils.isMBean(Class)
adaptMBeanIfPossible
protected DynamicMBean adaptMBeanIfPossible(Object bean) throws JMException
Build an adapted MBean for the given bean instance, if possible.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- 返回:
- the adapted MBean, or
null
if not possible - 抛出:
JMException
createAndConfigureMBean
protected ModelMBean createAndConfigureMBean(Object managedResource, String beanKey) throws MBeanExportException
Creates an MBean that is configured with the appropriate management interface for the supplied managed resource.- 参数:
managedResource
- the resource that is to be exported as an MBeanbeanKey
- the key associated with the managed bean- 抛出:
MBeanExportException
- 另请参阅:
createModelMBean()
,getMBeanInfo(Object, String)
createModelMBean
protected ModelMBean createModelMBean() throws MBeanException
Create an instance of a class that implementsModelMBean
.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 ofModelMBean
- 返回:
- a new instance of a class that implements
ModelMBean
- 抛出:
MBeanException
- if creation of the ModelMBean failed
onRegister
protected void onRegister(ObjectName objectName)
Called when an MBean is registered. Notifies all registeredMBeanExporterListeners
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 theMBeanExporterListener.mbeanRegistered(javax.management.ObjectName)
callback.- 覆盖:
onRegister
在类中MBeanRegistrationSupport
- 参数:
objectName
- theObjectName
of the registered MBean
onUnregister
protected void onUnregister(ObjectName objectName)
Called when an MBean is unregistered. Notifies all registeredMBeanExporterListeners
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 theMBeanExporterListener.mbeanUnregistered(javax.management.ObjectName)
callback.- 覆盖:
onUnregister
在类中MBeanRegistrationSupport
- 参数:
objectName
- theObjectName
of the unregistered MBean