MBeanExporter 源码分析

/**
 * JMX 导出器允许导出任何Spring管理Bean为 JMX，不需要在类中定义任何JMX信息
 * 如果一个bean已经实现了一个JMX 管理接口，MBeanExporter可以通过它的自动检查过程简单地通过MBeanServer注册
 *
 * 如果一个bean 没有实现任何JMX 管理接口，MBeanExporter将使用提供的MBeanInfoAssembler创建一个管理信息
 * 
 */
public class MBeanExporter extends MBeanRegistrationSupport
		implements MBeanExportOperations, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {

	/**
	 * 不自动检测
	 */
	public static final int AUTODETECT_NONE = 0;

	/**
	 * 自动检测合法的MBean
	 */
	public static final int AUTODETECT_MBEAN = 1;

	/**
	 * 自动检测MBeanInfoAssember
	 */
	public static final int AUTODETECT_ASSEMBLER = 2;

	/**
	 *自动检测所有
	 */
	public static final int AUTODETECT_ALL = AUTODETECT_MBEAN | AUTODETECT_ASSEMBLER;


	/**
	 * 通配符
	 */
	private static final String WILDCARD = "*";

	/** Constant for the JMX <code>mr_type</code> "ObjectReference" */
	private static final String MR_TYPE_OBJECT_REFERENCE = "ObjectReference";

	/** Prefix for the autodetect constants defined in this class */
	private static final String CONSTANT_PREFIX_AUTODETECT = "AUTODETECT_";


	/** 当前类的COnstants实例 */
	private static final Constants constants = new Constants(MBeanExporter.class);

	/** 需要导出为JMX管理资源的bean,使用 JMX的名字作为键**/
	private Map<String, Object> beans;

	/** 自动检测模型 */
	private Integer autodetectMode;

	/** 是否在自动检测MBean时，立即初始化候选bean**/
	private boolean allowEagerInit = false;

	/** 指明Spring是否修改生成的ObjectName */
	private boolean ensureUniqueRuntimeObjectNames = true;

	/** 指明Spring是否在MBean中托管管理资源**/ 
	private boolean exposeManagedResourceClassLoader = true;

	/** 一组排除自动检测外的bean */
	private Set<String> excludedBeans;

	/** MBeanExporter的监听器 */
	private MBeanExporterListener[] listeners;

	/**监听器 */
	private NotificationListenerBean[] notificationListeners;

	private final Map<NotificationListenerBean, ObjectName[]> registeredNotificationListeners =
			new LinkedHashMap<NotificationListenerBean, ObjectName[]>();

	/**存储该导出器使用的MBeanInfo装配器，默认是简单反射MBeanInfo装配器***/ 
	private MBeanInfoAssembler assembler = new SimpleReflectiveMBeanInfoAssembler();

	/** 为一个对象创建ObjectName的策略*/
	private ObjectNamingStrategy namingStrategy = new KeyNamingStrategy();

	/** 为创建懒加载的代理保存ClassLoader**/
	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

	/** 为自动检测保存BeanFactory */
	private ListableBeanFactory beanFactory;


	/**
	 * 提供一个需要注册为JMX MBeanServer的bean的一个图，字符串key是创建JMX 对象名称的基础。
	 * 默认情况下，一个JMX 的ObjectName就直接使用给定的key去创建。这个可以通过指定NamingStragegy进行自定义
	 */
	public void setBeans(Map<String, Object> beans) {
		this.beans = beans;
	}

	/**
	 *设置是否自动检测
	 */
	public void setAutodetect(boolean autodetect) {
		this.autodetectMode = (autodetect ? AUTODETECT_ALL : AUTODETECT_NONE);
	}

	/**
	 * 设置自动检测模式
	 */
	public void setAutodetectMode(int autodetectMode) {
		if (!constants.getValues(CONSTANT_PREFIX_AUTODETECT).contains(autodetectMode)) {
			throw new IllegalArgumentException("Only values of autodetect constants allowed");
		}
		this.autodetectMode = autodetectMode;
	}

	
	public void setAutodetectModeName(String constantName) {
		if (constantName == null || !constantName.startsWith(CONSTANT_PREFIX_AUTODETECT)) {
			throw new IllegalArgumentException("Only autodetect constants allowed");
		}
		this.autodetectMode = (Integer) constants.asNumber(constantName);
	}

	
	public void setAllowEagerInit(boolean allowEagerInit) {
		this.allowEagerInit = allowEagerInit;
	}

	/**
	 * 设置MBeanInfo装配器
	 **/
	public void setAssembler(MBeanInfoAssembler assembler) {
		this.assembler = assembler;
	}

	public void setNamingStrategy(ObjectNamingStrategy namingStrategy) {
		this.namingStrategy = namingStrategy;
	}

	public void setListeners(MBeanExporterListener[] listeners) {
		this.listeners = listeners;
	}

	
	public void setExcludedBeans(String[] excludedBeans) {
		this.excludedBeans = (excludedBeans != null ? new HashSet<String>(Arrays.asList(excludedBeans)) : null);
	}

	
	public void setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames) {
		this.ensureUniqueRuntimeObjectNames = ensureUniqueRuntimeObjectNames;
	}

	
	public void setExposeManagedResourceClassLoader(boolean exposeManagedResourceClassLoader) {
		this.exposeManagedResourceClassLoader = exposeManagedResourceClassLoader;
	}

	
	public void setNotificationListeners(NotificationListenerBean[] notificationListeners) {
		this.notificationListeners = notificationListeners;
	}

	/**
	 *设置通知监听器
	 */
	public void setNotificationListenerMappings(Map<?, ? extends NotificationListener> listeners) {
		Assert.notNull(listeners, "'listeners' must not be null");
		List<NotificationListenerBean> notificationListeners =
				new ArrayList<NotificationListenerBean>(listeners.size());

		for (Map.Entry<?, ? extends NotificationListener> entry : listeners.entrySet()) {
			// 从map中获取监听器，构建成一个Spring的NotificationListenerBean
			NotificationListenerBean bean = new NotificationListenerBean(entry.getValue());
			// 获取ObjectName
			Object key = entry.getKey();
			// 如果key不是null且不是通配符
			if (key != null && !WILDCARD.equals(key)) {
				// 将将监听器注册为一个特殊的ObjectName
				bean.setMappedObjectName(entry.getKey());
			}
			// 添加监听器
			notificationListeners.add(bean);
		}

		this.notificationListeners =
				notificationListeners.toArray(new NotificationListenerBean[notificationListeners.size()]);
	}

	public void setBeanClassLoader(ClassLoader classLoader) {
		this.beanClassLoader = classLoader;
	}

	public void setBeanFactory(BeanFactory beanFactory) {
		if (beanFactory instanceof ListableBeanFactory) {
			this.beanFactory = (ListableBeanFactory) beanFactory;
		}
		else {
			logger.info("MBeanExporter not running in a ListableBeanFactory: autodetection of MBeans not available.");
		}
	}


	//---------------------------------------------------------------------
	// Lifecycle in bean factory: automatically register/unregister beans
	//---------------------------------------------------------------------

	/**
	 *在应用上下文中被部署时自动注册
	 */
	public void afterPropertiesSet() {
		// //如果没有MBeanServer被提供，将尝试去找到一个MBeanServer.这个在JDK1.5,Tomcat或者JBoss等已经加载过一个MBeanServer//的环境中非常有用
		if (this.server == null) {
			this.server = JmxUtils.locateMBeanServer();
		}
		try {
			logger.info("Registering beans for JMX exposure on startup");
			//注册MBean
			registerBeans();
			//注册通知监听器
			registerNotificationListeners();
		}
		catch (RuntimeException ex) {
			//注销通知监听器
			unregisterNotificationListeners();
			//注销MBean
			unregisterBeans();
			throw ex;
		}
	}

	/**
	 * 注销
	 */
	public void destroy() {
		logger.info("Unregistering JMX-exposed beans on shutdown");
		unregisterNotificationListeners();
		unregisterBeans();
	}


	//---------------------------------------------------------------------
	// Implementation of MBeanExportOperations interface
	//---------------------------------------------------------------------

	public ObjectName registerManagedResource(Object managedResource) throws MBeanExportException {
		Assert.notNull(managedResource, "Managed resource must not be null");
		ObjectName objectName;
		try {
			objectName = getObjectName(managedResource, null);
			if (this.ensureUniqueRuntimeObjectNames) {
				objectName = JmxUtils.appendIdentityToObjectName(objectName, managedResource);
			}
		}
		catch (Exception ex) {
			throw new MBeanExportException("Unable to generate ObjectName for MBean [" + managedResource + "]", ex);
		}
		registerManagedResource(managedResource, objectName);
		return objectName;
	}

	public void registerManagedResource(Object managedResource, ObjectName objectName) throws MBeanExportException {
		Assert.notNull(managedResource, "Managed resource must not be null");
		Assert.notNull(objectName, "ObjectName must not be null");
		try {
			if (isMBean(managedResource.getClass())) {
				doRegister(managedResource, objectName);
			}
			else {
				ModelMBean mbean = createAndConfigureMBean(managedResource, managedResource.getClass().getName());
				doRegister(mbean, objectName);
				injectNotificationPublisherIfNecessary(managedResource, mbean, objectName);
			}
		}
		catch (JMException ex) {
			throw new UnableToRegisterMBeanException(
					"Unable to register MBean [" + managedResource + "] with object name [" + objectName + "]", ex);
		}
	}

	public void unregisterManagedResource(ObjectName objectName) {
		Assert.notNull(objectName, "ObjectName must not be null");
		doUnregister(objectName);
	}


	//---------------------------------------------------------------------
	// Exporter implementation
	//---------------------------------------------------------------------

	/**
	 * 通过MBeanServer注册已经定义的Bean
	 *  每个Bean都是通过ModelMBean导出到MBeanServer
	 * 实际ModelMBean接口的实现依赖于已经配置的ModelMBeanProvider的接口实现。
	 * 默认情况下，RequiredModelMBean 提供了所有JMX的实现
	 *
	 * <p>The management interface produced for each bean is dependent on the
	 * <code>MBeanInfoAssembler</code> implementation being used. The
	 * <code>ObjectName</code> given to each bean is dependent on the
	 * implementation of the <code>ObjectNamingStrategy</code> interface being used.
	 */
	protected void registerBeans() {
		// 如果beans为null
		if (this.beans == null) {
			this.beans = new HashMap<String, Object>();
			// 如果没有明确指定autodetectMode值，默认只用AUTODETECT_ALL
			if (this.autodetectMode == null) {
				this.autodetectMode = AUTODETECT_ALL;
			}
		}

		// 如果autodetectMode不为null,则使用autodetectModel否则使用AUTODETECT_NONE
		int mode = (this.autodetectMode != null ? this.autodetectMode : AUTODETECT_NONE);
		// 如果不是AUTODETECT_NONE
		if (mode != AUTODETECT_NONE) {
			// 如果beanFactory==null,则抛出一个异常
			if (this.beanFactory == null) {
				throw new MBeanExportException("Cannot autodetect MBeans if not running in a BeanFactory");
			}
			//如果模式是AUTODETECT_MBEAN或者是AUTODETECT_ALL,则自动检测MBean
			if (mode == AUTODETECT_MBEAN || mode == AUTODETECT_ALL) {
				// Autodetect any beans that are already MBeans.
				this.logger.debug("Autodetecting user-defined JMX MBeans");
				autodetectMBeans();
			}
			// Allow the assembler a chance to vote for bean inclusion.
			if ((mode == AUTODETECT_ASSEMBLER || mode == AUTODETECT_ALL) &&
					this.assembler instanceof AutodetectCapableMBeanInfoAssembler) {
				autodetectBeans((AutodetectCapableMBeanInfoAssembler) this.assembler);
			}
		}
	// 如果beans不为空
		if (!this.beans.isEmpty()) {
		// 遍历beans
			for (Map.Entry<String, Object> entry : this.beans.entrySet()) {
				//注册bean
				registerBeanNameOrInstance(entry.getValue(), entry.getKey());
			}
		}
	}

	/**
	 * 判断一个bean是否是懒加载模式bean
	 */
	protected boolean isBeanDefinitionLazyInit(ListableBeanFactory beanFactory, String beanName) {
		return (beanFactory instanceof ConfigurableListableBeanFactory && beanFactory.containsBeanDefinition(beanName) &&
				((ConfigurableListableBeanFactory) beanFactory).getBeanDefinition(beanName).isLazyInit());
	}

	/**
	 * 通过MBeanServer注册个体Bean。 
	 * 这个方法决定如何去注册一个需要暴露到MBeanServer.具体而言，如果提供的mapValue是一个懒加载Bean的名称
	 * *将通过MBeanServer注册这个资源的代理，这样懒加载行为将得到尊重。如果一个Bean已经是一个Mbean,无需任何介入处理，将直**接通过MBeanServer注册。对于其他Bean或Bean的名称，通过MBeaServer注册资源自身
	 */
	protected ObjectName registerBeanNameOrInstance(Object mapValue, String beanKey) throws MBeanExportException {
		try {
		     // 如果mapValue是字符串
			if (mapValue instanceof String) {
				// beanFactory为null则抛出一个异常
				if (this.beanFactory == null) {
					throw new MBeanExportException("Cannot resolve bean names if not running in a BeanFactory");
				}
				// beanName
				String beanName = (String) mapValue;
				// 如果是懒加载
				if (isBeanDefinitionLazyInit(this.beanFactory, beanName)) {
					ObjectName objectName = registerLazyInit(beanName, beanKey);
					replaceNotificationListenerBeanNameKeysIfNecessary(beanName, objectName);
					return objectName;
				}
				else {
					// 获取bean实例
					Object bean = this.beanFactory.getBean(beanName);
					// 注册bean实例
					ObjectName objectName = registerBeanInstance(bean, beanKey);
					replaceNotificationListenerBeanNameKeysIfNecessary(beanName, objectName);
					return objectName;
				}
			}
			else {
				// 原生Bean，则直接注册
				if (this.beanFactory != null) {
					Map<String, ?> beansOfSameType =
							this.beanFactory.getBeansOfType(mapValue.getClass(), false, this.allowEagerInit);
					for (Map.Entry<String, ?> entry : beansOfSameType.entrySet()) {
						if (entry.getValue() == mapValue) {
							String beanName = entry.getKey();
							ObjectName objectName = registerBeanInstance(mapValue, beanKey);
							replaceNotificationListenerBeanNameKeysIfNecessary(beanName, objectName);
							return objectName;
						}
					}
				}
				return registerBeanInstance(mapValue, beanKey);
			}
		}
		catch (Exception ex) {
			throw new UnableToRegisterMBeanException(
					"Unable to register MBean [" + mapValue + "] with key '" + beanKey + "'", ex);
		}
	}
	
	/**
	 * Replaces any bean names used as keys in the <code>NotificationListener</code>
	 * mappings with their corresponding <code>ObjectName</code> values.
	 * @param beanName the name of the bean to be registered
	 * @param objectName the <code>ObjectName</code> under which the bean will be registered
	 * with the <code>MBeanServer</code>
	 */
	private void replaceNotificationListenerBeanNameKeysIfNecessary(String beanName, ObjectName objectName) {
		if (this.notificationListeners != null) {
			for (NotificationListenerBean notificationListener : this.notificationListeners) {
				notificationListener.replaceObjectName(beanName, objectName);
			}
		}
	}

	/**
	 * 通过MBeanServer注册一个已经存在的MBean或一个原生Bean的Mbean适配器Bean
	 */
	private ObjectName registerBeanInstance(Object bean, String beanKey) throws JMException {
		// 获取ObjectName
		ObjectName objectName = getObjectName(bean, beanKey);
		Object mbeanToExpose = null;
		// 如果是Mbean,则需要暴露的bean就是当前bean
		if (isMBean(bean.getClass())) {
			mbeanToExpose = bean;
		}
		else {
			// 否则创建一个动态Mbean
			DynamicMBean adaptedBean = adaptMBeanIfPossible(bean);
			// 创建动态Mbean成功则导出Bean就为该Bean
			if (adaptedBean != null) {
				mbeanToExpose = adaptedBean;
			}
		}
		// 如果需暴露的mbean对象不为null
		if (mbeanToExpose != null) {
			if (logger.isInfoEnabled()) {
				logger.info("Located MBean '" + beanKey + "': registering with JMX server as MBean [" +
						objectName + "]");
			}
			// 注册mbean
			doRegister(mbeanToExpose, objectName);
		}
		else {
			if (logger.isInfoEnabled()) {
				logger.info("Located managed bean '" + beanKey + "': registering with JMX server as MBean [" +
						objectName + "]");
			}
			// 如果创建和配置一个ModelMBean
			ModelMBean mbean = createAndConfigureMBean(bean, beanKey);
			// 注册ModelMBean
			doRegister(mbean, objectName);
			injectNotificationPublisherIfNecessary(bean, mbean, objectName);
		}
		return objectName;
	}

	/**
	 *通过一个注册为延迟初始化bean的代理使用MBeanServer注册bean
	 */
	private ObjectName registerLazyInit(String beanName, String beanKey) throws JMException {
		
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setProxyTargetClass(true);
		proxyFactory.setFrozen(true);

		if (isMBean(this.beanFactory.getType(beanName))) {
			// A straight MBean... Let's create a simple lazy-init CGLIB proxy for it.
			LazyInitTargetSource targetSource = new LazyInitTargetSource();
			targetSource.setTargetBeanName(beanName);
			targetSource.setBeanFactory(this.beanFactory);
			proxyFactory.setTargetSource(targetSource);

			Object proxy = proxyFactory.getProxy(this.beanClassLoader);
			ObjectName objectName = getObjectName(proxy, beanKey);
			if (logger.isDebugEnabled()) {
				logger.debug("Located MBean '" + beanKey + "': registering with JMX server as lazy-init MBean [" +
						objectName + "]");
			}
			doRegister(proxy, objectName);
			return objectName;
		}

		else {
			// A simple bean... Let's create a lazy-init ModelMBean proxy with notification support.
			NotificationPublisherAwareLazyTargetSource targetSource = new NotificationPublisherAwareLazyTargetSource();
			targetSource.setTargetBeanName(beanName);
			targetSource.setBeanFactory(this.beanFactory);
			proxyFactory.setTargetSource(targetSource);

			Object proxy = proxyFactory.getProxy(this.beanClassLoader);
			ObjectName objectName = getObjectName(proxy, beanKey);
			if (logger.isDebugEnabled()) {
				logger.debug("Located simple bean '" + beanKey + "': registering with JMX server as lazy-init MBean [" +
						objectName + "]");
			}
			ModelMBean mbean = createAndConfigureMBean(proxy, beanKey);
			targetSource.setModelMBean(mbean);
			targetSource.setObjectName(objectName);
			doRegister(mbean, objectName);
			return objectName;
		}
	}

	/**
	 * 获取一个bean的ObjectName
	 * 如果bean实现了SelfNaming接口，ObjectName将通过SelfNaming接口的getObjectName()方法获取
	 *  否则，将使用配置的ObjectNamingStrategy
	 */
	protected ObjectName getObjectName(Object bean, String beanKey) throws MalformedObjectNameException {
		if (bean instanceof SelfNaming) {
			return ((SelfNaming) bean).getObjectName();
		}
		else {
			return this.namingStrategy.getObjectName(bean, beanKey);
		}
	}

	/**
	 * 判断一个Bean是不是MBean
	 */
	protected boolean isMBean(Class beanClass) {
		return JmxUtils.isMBean(beanClass);
	}

	/**
	 * 如果有可能，为给定的Bean创建一个适配MBean
	 */
	@SuppressWarnings("unchecked")
	protected DynamicMBean adaptMBeanIfPossible(Object bean) throws JMException {
	     //获取指定Bean的目标类
		Class targetClass = AopUtils.getTargetClass(bean);
		// 如果目标class不等于bean的class
		if (targetClass != bean.getClass()) {
			// 获取MXBean的接口
			Class ifc = JmxUtils.getMXBeanInterface(targetClass);
			// 如果接口不为null
			if (ifc != null) {
				if (!(ifc.isInstance(bean))) {
					throw new NotCompliantMBeanException("Managed bean [" + bean +
							"] has a target class with an MXBean interface but does not expose it in the proxy");
				}
				// 创建一个标准的Mbean返回
				return new StandardMBean(bean, ifc, true);
			}
			else {
				// 获取MBean接口
				ifc = JmxUtils.getMBeanInterface(targetClass);
				if (ifc != null) {
					if (!(ifc.isInstance(bean))) {
						throw new NotCompliantMBeanException("Managed bean [" + bean +
								"] has a target class with an MBean interface but does not expose it in the proxy");
					}
					// 创建一个标准的MBean 并返回
					return new StandardMBean(bean, ifc);
				}
			}
		}
		//如果Bean没有实现MXBean接口也没有实现MBean接口
		return null;
	}

	/**
	 *   对提供管理资源已经配置相应管理的接口创建一个Mbean
	 */
	protected ModelMBean createAndConfigureMBean(Object managedResource, String beanKey)
			throws MBeanExportException {
		try {
			// 创建一个新的ModelMBean
			ModelMBean mbean = createModelMBean();
			// 设置modelMBeanInfo
			mbean.setModelMBeanInfo(getMBeanInfo(managedResource, beanKey));
			// 设置ManagedResource
			mbean.setManagedResource(managedResource, MR_TYPE_OBJECT_REFERENCE);
			return mbean;
		}
		catch (Exception ex) {
			throw new MBeanExportException("Could not create ModelMBean for managed resource [" +
					managedResource + "] with key '" + beanKey + "'", ex);
		}
	}

	/**
	 * 创建一个实现ModelMBean接口的实例。这个方法在注册一个bean是被调用用来获取一个ModelMBean实例
	 * 这个方法在每个bean的注册阶段被调用，且每次都必须返回一个新的ModelMbean实例 
	 */
	protected ModelMBean createModelMBean() throws MBeanException {
		return (this.exposeManagedResourceClassLoader ? new SpringModelMBean() : new RequiredModelMBean());
	}

	
	private ModelMBeanInfo getMBeanInfo(Object managedBean, String beanKey) throws JMException {
		ModelMBeanInfo info = this.assembler.getMBeanInfo(managedBean, beanKey);
		if (logger.isWarnEnabled() && ObjectUtils.isEmpty(info.getAttributes()) &&
				ObjectUtils.isEmpty(info.getOperations())) {
			logger.warn("Bean with key '" + beanKey +
					"' has been registered as an MBean but has no exposed attributes or operations");
		}
		return info;
	}


	//---------------------------------------------------------------------
	// Autodetection process
	//---------------------------------------------------------------------

	
	private void autodetectBeans(final AutodetectCapableMBeanInfoAssembler assembler) {
		autodetect(new AutodetectCallback() {
			public boolean include(Class beanClass, String beanName) {
				return assembler.includeBean(beanClass, beanName);
			}
		});
	}

	/**
	 *尝试检测应用上下文中定义的所有有效的MBean,并自动用MBeanServer注册它们
	 */
	private void autodetectMBeans() {
		autodetect(new AutodetectCallback() {
			public boolean include(Class beanClass, String beanName) {
				return isMBean(beanClass);
			}
		});
	}

	/**
	 * 执行实际自动检测过程，委托给AutodetectCallback实例去对一个给定吧Bean进行表决
	 */
	private void autodetect(AutodetectCallback callback) {
	   // 初始化一个BeanNames的Set
		Set<String> beanNames = new LinkedHashSet<String>(this.beanFactory.getBeanDefinitionCount());
		//添加所有定义过的Bean
		beanNames.addAll(Arrays.asList(this.beanFactory.getBeanDefinitionNames()));
	    // 
		if (this.beanFactory instanceof ConfigurableBeanFactory) {
			beanNames.addAll(Arrays.asList(((ConfigurableBeanFactory) this.beanFactory).getSingletonNames()));
		}
		// 遍历所有Bean
		for (String beanName : beanNames) {
			if (!isExcluded(beanName) && !isBeanDefinitionAbstract(this.beanFactory, beanName)) {
				try {
				// 获取bean的Class对象
					Class beanClass = this.beanFactory.getType(beanName);
					// 如果beanClass不为null且回调接口包含该bean
					if (beanClass != null && callback.include(beanClass, beanName)) {
						// 判断该Bean是否是懒加载的
						boolean lazyInit = isBeanDefinitionLazyInit(this.beanFactory, beanName);
						// 如果不是懒加载的就返回这个Bean的实例，否则返回null
						Object beanInstance = (!lazyInit ? this.beanFactory.getBean(beanName) : null);
							// 如果beans中不包含该bean且 bean的实例为null,或beans中已经包含该bean
						if (!this.beans.containsValue(beanName) && (beanInstance == null ||
								!CollectionUtils.containsInstance(this.beans.values(), beanInstance))) {
							//尚未注册为JMX
							this.beans.put(beanName, (beanInstance != null ? beanInstance : beanName));
							if (logger.isInfoEnabled()) {
								logger.info("Bean with name '" + beanName + "' has been autodetected for JMX exposure");
							}
						}
						else {
							if (logger.isDebugEnabled()) {
								logger.debug("Bean with name '" + beanName + "' is already registered for JMX exposure");
							}
						}
					}
				}
				catch (CannotLoadBeanClassException ex) {
					if (this.allowEagerInit) {
						throw ex;
					}
					// otherwise ignore beans where the class is not resolvable
				}
			}
		}
	}

	/**
	 * Indicates whether or not a particular bean name is present in the excluded beans list.
	 */
	private boolean isExcluded(String beanName) {
		return (this.excludedBeans != null &&
				(this.excludedBeans.contains(beanName) ||
						(beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX) &&
								this.excludedBeans.contains(beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length())))));
	}

	/**
	 * Return whether the specified bean definition should be considered as abstract.
	 */
	private boolean isBeanDefinitionAbstract(ListableBeanFactory beanFactory, String beanName) {
		return (beanFactory instanceof ConfigurableListableBeanFactory && beanFactory.containsBeanDefinition(beanName) &&
				((ConfigurableListableBeanFactory) beanFactory).getBeanDefinition(beanName).isAbstract());
	}


	//---------------------------------------------------------------------
	// Notification and listener management
	//---------------------------------------------------------------------

	/**
	 * If the supplied managed resource implements the {@link NotificationPublisherAware} an instance of
	 * {@link org.springframework.jmx.export.notification.NotificationPublisher} is injected.
	 */
	private void injectNotificationPublisherIfNecessary(
			Object managedResource, ModelMBean modelMBean, ObjectName objectName) {

		if (managedResource instanceof NotificationPublisherAware) {
			((NotificationPublisherAware) managedResource).setNotificationPublisher(
					new ModelMBeanNotificationPublisher(modelMBean, objectName, managedResource));
		}
	}

	/**
	 * 注册配置的监听器
	 * with the {@link MBeanServer}.
	 */
	private void registerNotificationListeners() throws MBeanExportException {
	      //如果通知监听器列表不为空
		if (this.notificationListeners != null) {
			// 遍历监听器
			for (NotificationListenerBean bean : this.notificationListeners) {
				try {
					//获取ObjectName数组
					ObjectName[] mappedObjectNames = bean.getResolvedObjectNames();
					if (mappedObjectNames == null) {
						// Mapped to all MBeans registered by the MBeanExporter.
						mappedObjectNames = getRegisteredObjectNames();
					}
					if (this.registeredNotificationListeners.put(bean, mappedObjectNames) == null) {
						for (ObjectName mappedObjectName : mappedObjectNames) {
						   // 向server中注册监听器
							this.server.addNotificationListener(mappedObjectName, bean.getNotificationListener(),
									bean.getNotificationFilter(), bean.getHandback());
						}
					}
				}
				catch (Exception ex) {
					throw new MBeanExportException("Unable to register NotificationListener", ex);
				}
			}
		}
	}

	/**
	 * 注销监听器
	 * from the {@link MBeanServer}.
	 */
	private void unregisterNotificationListeners() {
		for (Map.Entry<NotificationListenerBean, ObjectName[]> entry : this.registeredNotificationListeners.entrySet()) {
			NotificationListenerBean bean = entry.getKey();
			ObjectName[] mappedObjectNames = entry.getValue();
			for (ObjectName mappedObjectName : mappedObjectNames) {
				try {
					this.server.removeNotificationListener(mappedObjectName, bean.getNotificationListener(),
							bean.getNotificationFilter(), bean.getHandback());
				}
				catch (Exception ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Unable to unregister NotificationListener", ex);
					}
				}
			}
		}
		this.registeredNotificationListeners.clear();
	}

	/**
	 * Called when an MBean is registered. Notifies all registered
	 * {@link MBeanExporterListener MBeanExporterListeners} of the registration event.
	 * <p>Please note that if an {@link 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 {@link MBeanExporterListener#mbeanRegistered(javax.management.ObjectName)}
	 * callback.
	 * @param objectName the <code>ObjectName</code> of the registered MBean
	 */
	@Override
	protected void onRegister(ObjectName objectName) {
		notifyListenersOfRegistration(objectName);
	}

	/**
	 * Called when an MBean is unregistered. Notifies all registered
	 * {@link MBeanExporterListener MBeanExporterListeners} of the unregistration event.
	 * <p>Please note that if an {@link 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 {@link MBeanExporterListener#mbeanUnregistered(javax.management.ObjectName)}
	 * callback.
	 * @param objectName the <code>ObjectName</code> of the unregistered MBean
	 */
	@Override
	protected void onUnregister(ObjectName objectName) {
		notifyListenersOfUnregistration(objectName);
	}


    /**
	 * Notifies all registered {@link MBeanExporterListener MBeanExporterListeners} of the
	 * registration of the MBean identified by the supplied {@link ObjectName}.
	 */
	private void notifyListenersOfRegistration(ObjectName objectName) {
		if (this.listeners != null) {
			for (MBeanExporterListener listener : this.listeners) {
				listener.mbeanRegistered(objectName);
			}
		}
	}

	/**
	 * Notifies all registered {@link MBeanExporterListener MBeanExporterListeners} of the
	 * unregistration of the MBean identified by the supplied {@link ObjectName}.
	 */
	private void notifyListenersOfUnregistration(ObjectName objectName) {
		if (this.listeners != null) {
			for (MBeanExporterListener listener : this.listeners) {
				listener.mbeanUnregistered(objectName);
			}
		}
	}


	//---------------------------------------------------------------------
	// Inner classes for internal use
	//---------------------------------------------------------------------

	/**
	 * 内部回调接口，
	 */
	private static interface AutodetectCallback {

		/**
		 * Called during the autodetection process to decide whether
		 * or not a bean should be included.
		 * @param beanClass the class of the bean
		 * @param beanName the name of the bean
		 */
		boolean include(Class beanClass, String beanName);
	}


	/**
	 * Extension of {@link LazyInitTargetSource} that will inject a
	 * {@link org.springframework.jmx.export.notification.NotificationPublisher}
	 * into the lazy resource as it is created if required.
	 */
	private class NotificationPublisherAwareLazyTargetSource extends LazyInitTargetSource {

		private ModelMBean modelMBean;
		
		private ObjectName objectName;

		public void setModelMBean(ModelMBean modelMBean) {
			this.modelMBean = modelMBean;
		}

		public void setObjectName(ObjectName objectName) {
			this.objectName = objectName;
		}

		@Override
		protected void postProcessTargetObject(Object targetObject) {
			injectNotificationPublisherIfNecessary(targetObject, this.modelMBean, this.objectName);
		}
	}

}