org.springframework.jmx.export

Class MBeanExporter

    • Constructor Summary

      Constructors 
      Constructor and Description
      MBeanExporter() 
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      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 the containing BeanFactory after it has set all bean properties and satisfied BeanFactoryAware, ApplicationContextAware etc.
      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 MBeanExporterListeners 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.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • AUTODETECT_NONE

        public static final int AUTODETECT_NONE
        Autodetection mode indicating that no autodetection should be used.
        See Also:
        Constant Field Values
      • AUTODETECT_MBEAN

        public static final int AUTODETECT_MBEAN
        Autodetection mode indicating that only valid MBeans should be autodetected.
        See Also:
        Constant Field Values
      • AUTODETECT_ASSEMBLER

        public static final int AUTODETECT_ASSEMBLER
        Autodetection mode indicating that only the MBeanInfoAssembler should be able to autodetect beans.
        See Also:
        Constant Field Values
      • AUTODETECT_ALL

        public static final int AUTODETECT_ALL
        Autodetection mode indicating that all autodetection mechanisms should be used.
        See Also:
        Constant Field Values
    • Constructor Detail

      • MBeanExporter

        public MBeanExporter()
    • Method Detail

      • setBeans

        public void setBeans(java.util.Map<java.lang.String,java.lang.Object> beans)
        Supply a 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).

        Parameters:
        beans - a Map with JMX names as keys and bean instances or bean names as values
        See Also:
        setNamingStrategy(org.springframework.jmx.export.naming.ObjectNamingStrategy), KeyNamingStrategy, ObjectName.ObjectName(String)
      • 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.

      • setExposeManagedResourceClassLoader

        public 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.

        The default value is true, exposing a SpringModelMBean which performs thread context ClassLoader management. Switch this flag off to expose a standard JMX RequiredModelMBean.

      • setExcludedBeans

        public void setExcludedBeans(java.lang.String... excludedBeans)
        Set the list of names for beans that should be excluded from autodetection.
      • addExcludedBean

        public void addExcludedBean(java.lang.String excludedBean)
        Add the name of bean that should be excluded from autodetection.
      • setListeners

        public void setListeners(MBeanExporterListener... listeners)
        Set the MBeanExporterListeners that should be notified of MBean registration and unregistration events.
        See Also:
        MBeanExporterListener
      • setNotificationListenerMappings

        public void setNotificationListenerMappings(java.util.Map<?,? extends javax.management.NotificationListener> listeners)
        Set the 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[]).

      • afterPropertiesSet

        public void afterPropertiesSet()
        Description copied from interface: InitializingBean
        Invoked by the containing BeanFactory after it has set all bean properties and satisfied BeanFactoryAware, 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.

        Specified by:
        afterPropertiesSet in interface InitializingBean
      • destroy

        public void destroy()
        Unregisters all beans that this exported has exposed via JMX when the enclosing ApplicationContext is destroyed.
        Specified by:
        destroy in interface DisposableBean
      • registerManagedResource

        public javax.management.ObjectName registerManagedResource(java.lang.Object managedResource)
                                                            throws MBeanExportException
        Description copied from interface: 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 an ObjectName for the managed resource and returns this to the caller.
        Specified by:
        registerManagedResource in interface MBeanExportOperations
        Parameters:
        managedResource - the resource to expose via JMX
        Returns:
        the ObjectName under which the resource was exposed
        Throws:
        MBeanExportException - if Spring is unable to generate an ObjectName or register the MBean
      • registerManagedResource

        public void registerManagedResource(java.lang.Object managedResource,
                                            javax.management.ObjectName objectName)
                                     throws MBeanExportException
        Description copied from interface: 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.
        Specified by:
        registerManagedResource in interface MBeanExportOperations
        Parameters:
        managedResource - the resource to expose via JMX
        objectName - the ObjectName under which to expose the resource
        Throws:
        MBeanExportException - if Spring is unable to register the MBean
      • unregisterManagedResource

        public void unregisterManagedResource(javax.management.ObjectName objectName)
        Description copied from interface: MBeanExportOperations
        Remove the specified MBean from the underlying MBeanServer registry.
        Specified by:
        unregisterManagedResource in interface MBeanExportOperations
        Parameters:
        objectName - the ObjectName of the resource to remove
      • registerBeans

        protected void registerBeans()
        Register the defined beans with the 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.

      • registerBeanNameOrInstance

        protected javax.management.ObjectName registerBeanNameOrInstance(java.lang.Object mapValue,
                                                                         java.lang.String beanKey)
                                                                  throws MBeanExportException
        Register an individual bean with the 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.

        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
        beanKey - the key associated with this bean in the beans map
        Returns:
        the ObjectName under which the resource was registered
        Throws:
        MBeanExportException - if the export failed
        See Also:
        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 javax.management.ObjectName getObjectName(java.lang.Object bean,
                                                            @Nullable
                                                            java.lang.String beanKey)
                                                     throws javax.management.MalformedObjectNameException
        Retrieve the 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.

        Parameters:
        bean - the name of the bean in the BeanFactory
        beanKey - the key associated with the bean in the beans map
        Returns:
        the ObjectName for the supplied bean
        Throws:
        javax.management.MalformedObjectNameException - if the retrieved ObjectName is malformed
      • isMBean

        protected boolean isMBean(@Nullable
                                  java.lang.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 for 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
        Returns:
        whether the class qualifies as an MBean
        See Also:
        JmxUtils.isMBean(Class)
      • adaptMBeanIfPossible

        @Nullable
        protected javax.management.DynamicMBean adaptMBeanIfPossible(java.lang.Object bean)
                                                                        throws javax.management.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.

        Parameters:
        bean - the original bean instance
        Returns:
        the adapted MBean, or null if not possible
        Throws:
        javax.management.JMException
      • createAndConfigureMBean

        protected javax.management.modelmbean.ModelMBean createAndConfigureMBean(java.lang.Object managedResource,
                                                                                 java.lang.String beanKey)
                                                                          throws MBeanExportException
        Creates an MBean that is configured with the appropriate management interface for the supplied managed resource.
        Parameters:
        managedResource - the resource that is to be exported as an MBean
        beanKey - the key associated with the managed bean
        Throws:
        MBeanExportException
        See Also:
        createModelMBean(), getMBeanInfo(Object, String)
      • createModelMBean

        protected javax.management.modelmbean.ModelMBean createModelMBean()
                                                                   throws javax.management.MBeanException
        Create an instance of a class that implements 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

        Returns:
        a new instance of a class that implements ModelMBean
        Throws:
        javax.management.MBeanException - if creation of the ModelMBean failed