Back to index...

	/*
	* Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.management;

	import static com.sun.jmx.defaults.JmxProperties.MISC_LOGGER;
	import com.sun.jmx.mbeanserver.DescriptorCache;
	import com.sun.jmx.mbeanserver.Introspector;
	import com.sun.jmx.mbeanserver.MBeanSupport;
	import com.sun.jmx.mbeanserver.MXBeanSupport;
	import com.sun.jmx.mbeanserver.StandardMBeanSupport;
	import com.sun.jmx.mbeanserver.Util;

	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.WeakHashMap;
	import java.util.logging.Level;
	import javax.management.openmbean.OpenMBeanAttributeInfo;
	import javax.management.openmbean.OpenMBeanAttributeInfoSupport;
	import javax.management.openmbean.OpenMBeanConstructorInfo;
	import javax.management.openmbean.OpenMBeanConstructorInfoSupport;
	import javax.management.openmbean.OpenMBeanOperationInfo;
	import javax.management.openmbean.OpenMBeanOperationInfoSupport;
	import javax.management.openmbean.OpenMBeanParameterInfo;
	import javax.management.openmbean.OpenMBeanParameterInfoSupport;

	/**
	* <p>An MBean whose management interface is determined by reflection
	* on a Java interface.</p>
	*
	* <p>This class brings more flexibility to the notion of Management
	* Interface in the use of Standard MBeans. Straightforward use of
	* the patterns for Standard MBeans described in the JMX Specification
	* means that there is a fixed relationship between the implementation
	* class of an MBean and its management interface (i.e., if the
	* implementation class is Thing, the management interface must be
	* ThingMBean). This class makes it possible to keep the convenience
	* of specifying the management interface with a Java interface,
	* without requiring that there be any naming relationship between the
	* implementation and interface classes.</p>
	*
	* <p>By making a DynamicMBean out of an MBean, this class makes
	* it possible to select any interface implemented by the MBean as its
	* management interface, provided that it complies with JMX patterns
	* (i.e., attributes defined by getter/setter etc...).</p>
	*
	* <p> This class also provides hooks that make it possible to supply
	* custom descriptions and names for the {@link MBeanInfo} returned by
	* the DynamicMBean interface.</p>
	*
	* <p>Using this class, an MBean can be created with any
	* implementation class name <i>Impl</i> and with a management
	* interface defined (as for current Standard MBeans) by any interface
	* <i>Intf</i>, in one of two general ways:</p>
	*
	* <ul>
	*
	* <li>Using the public constructor
	* {@link #StandardMBean(java.lang.Object, java.lang.Class, boolean)
	* StandardMBean(impl,interface)}:
	* <pre>
	* MBeanServer mbs;
	* ...
	* Impl impl = new Impl(...);
	* StandardMBean mbean = new StandardMBean(impl, Intf.class, false);
	* mbs.registerMBean(mbean, objectName);
	* </pre></li>
	*
	* <li>Subclassing StandardMBean:
	* <pre>
	* public class Impl extends StandardMBean implements Intf {
	* public Impl() {
	* super(Intf.class, false);
	* }
	* // implement methods of Intf
	* }
	*
	* [...]
	*
	* MBeanServer mbs;
	* ....
	* Impl impl = new Impl();
	* mbs.registerMBean(impl, objectName);
	* </pre></li>
	*
	* </ul>
	*
	* <p>In either case, the class <i>Impl</i> must implement the
	* interface <i>Intf</i>.</p>
	*
	* <p>Standard MBeans based on the naming relationship between
	* implementation and interface classes are of course still
	* available.</p>
	*
	* <p>This class may also be used to construct MXBeans. The usage
	* is exactly the same as for Standard MBeans except that in the
	* examples above, the {@code false} parameter to the constructor or
	* {@code super(...)} invocation is instead {@code true}.</p>
	*
	* @since 1.5
	*/
	public class StandardMBean implements DynamicMBean, MBeanRegistration {

	private final static DescriptorCache descriptors =
	DescriptorCache.getInstance(JMX.proof);

	/**
	* The DynamicMBean that wraps the MXBean or Standard MBean implementation.
	**/
	private volatile MBeanSupport<?> mbean;

	/**
	* The cached MBeanInfo.
	**/
	private volatile MBeanInfo cachedMBeanInfo;

	/**
	* Make a DynamicMBean out of <var>implementation</var>, using the
	* specified <var>mbeanInterface</var> class.
	* @param implementation The implementation of this MBean.
	* If <code>null</code>, and null implementation is allowed,
	* then the implementation is assumed to be <var>this</var>.
	* @param mbeanInterface The Management Interface exported by this
	* MBean's implementation. If <code>null</code>, then this
	* object will use standard JMX design pattern to determine
	* the management interface associated with the given
	* implementation.
	* @param nullImplementationAllowed <code>true</code> if a null
	* implementation is allowed. If null implementation is allowed,
	* and a null implementation is passed, then the implementation
	* is assumed to be <var>this</var>.
	* @exception IllegalArgumentException if the given
	* <var>implementation</var> is null, and null is not allowed.
	**/
	private <T> void construct(T implementation, Class<T> mbeanInterface,
	boolean nullImplementationAllowed,
	boolean isMXBean)
	throws NotCompliantMBeanException {
	if (implementation == null) {
	// Have to use (T)this rather than mbeanInterface.cast(this)
	// because mbeanInterface might be null.
	if (nullImplementationAllowed)
	implementation = Util.<T>cast(this);
	else throw new IllegalArgumentException("implementation is null");
	}
	if (isMXBean) {
	if (mbeanInterface == null) {
	mbeanInterface = Util.cast(Introspector.getMXBeanInterface(
	implementation.getClass()));
	}
	this.mbean = new MXBeanSupport(implementation, mbeanInterface);
	} else {
	if (mbeanInterface == null) {
	mbeanInterface = Util.cast(Introspector.getStandardMBeanInterface(
	implementation.getClass()));
	}
	this.mbean =
	new StandardMBeanSupport(implementation, mbeanInterface);
	}
	}

	/**
	* <p>Make a DynamicMBean out of the object
	* <var>implementation</var>, using the specified
	* <var>mbeanInterface</var> class.</p>
	*
	* @param implementation The implementation of this MBean.
	* @param mbeanInterface The Management Interface exported by this
	* MBean's implementation. If <code>null</code>, then this
	* object will use standard JMX design pattern to determine
	* the management interface associated with the given
	* implementation.
	* @param <T> Allows the compiler to check
	* that {@code implementation} does indeed implement the class
	* described by {@code mbeanInterface}. The compiler can only
	* check this if {@code mbeanInterface} is a class literal such
	* as {@code MyMBean.class}.
	*
	* @exception IllegalArgumentException if the given
	* <var>implementation</var> is null.
	* @exception NotCompliantMBeanException if the <var>mbeanInterface</var>
	* does not follow JMX design patterns for Management Interfaces, or
	* if the given <var>implementation</var> does not implement the
	* specified interface.
	**/
	public <T> StandardMBean(T implementation, Class<T> mbeanInterface)
	throws NotCompliantMBeanException {
	construct(implementation, mbeanInterface, false, false);
	}

	/**
	* <p>Make a DynamicMBean out of <var>this</var>, using the specified
	* <var>mbeanInterface</var> class.</p>
	*
	* <p>Calls {@link #StandardMBean(java.lang.Object, java.lang.Class)
	* this(this,mbeanInterface)}.
	* This constructor is reserved to subclasses.</p>
	*
	* @param mbeanInterface The Management Interface exported by this
	* MBean.
	*
	* @exception NotCompliantMBeanException if the <var>mbeanInterface</var>
	* does not follow JMX design patterns for Management Interfaces, or
	* if <var>this</var> does not implement the specified interface.
	**/
	protected StandardMBean(Class<?> mbeanInterface)
	throws NotCompliantMBeanException {
	construct(null, mbeanInterface, true, false);
	}

	/**
	* <p>Make a DynamicMBean out of the object
	* <var>implementation</var>, using the specified
	* <var>mbeanInterface</var> class, and choosing whether the
	* resultant MBean is an MXBean. This constructor can be used
	* to make either Standard MBeans or MXBeans. Unlike the
	* constructor {@link #StandardMBean(Object, Class)}, it
	* does not throw NotCompliantMBeanException.</p>
	*
	* @param implementation The implementation of this MBean.
	* @param mbeanInterface The Management Interface exported by this
	* MBean's implementation. If <code>null</code>, then this
	* object will use standard JMX design pattern to determine
	* the management interface associated with the given
	* implementation.
	* @param isMXBean If true, the {@code mbeanInterface} parameter
	* names an MXBean interface and the resultant MBean is an MXBean.
	* @param <T> Allows the compiler to check
	* that {@code implementation} does indeed implement the class
	* described by {@code mbeanInterface}. The compiler can only
	* check this if {@code mbeanInterface} is a class literal such
	* as {@code MyMBean.class}.
	*
	* @exception IllegalArgumentException if the given
	* <var>implementation</var> is null, or if the <var>mbeanInterface</var>
	* does not follow JMX design patterns for Management Interfaces, or
	* if the given <var>implementation</var> does not implement the
	* specified interface.
	*
	* @since 1.6
	**/
	public <T> StandardMBean(T implementation, Class<T> mbeanInterface,
	boolean isMXBean) {
	try {
	construct(implementation, mbeanInterface, false, isMXBean);
	} catch (NotCompliantMBeanException e) {
	throw new IllegalArgumentException(e);
	}
	}

	/**
	* <p>Make a DynamicMBean out of <var>this</var>, using the specified
	* <var>mbeanInterface</var> class, and choosing whether the resulting
	* MBean is an MXBean. This constructor can be used
	* to make either Standard MBeans or MXBeans. Unlike the
	* constructor {@link #StandardMBean(Object, Class)}, it
	* does not throw NotCompliantMBeanException.</p>
	*
	* <p>Calls {@link #StandardMBean(java.lang.Object, java.lang.Class, boolean)
	* this(this, mbeanInterface, isMXBean)}.
	* This constructor is reserved to subclasses.</p>
	*
	* @param mbeanInterface The Management Interface exported by this
	* MBean.
	* @param isMXBean If true, the {@code mbeanInterface} parameter
	* names an MXBean interface and the resultant MBean is an MXBean.
	*
	* @exception IllegalArgumentException if the <var>mbeanInterface</var>
	* does not follow JMX design patterns for Management Interfaces, or
	* if <var>this</var> does not implement the specified interface.
	*
	* @since 1.6
	**/
	protected StandardMBean(Class<?> mbeanInterface, boolean isMXBean) {
	try {
	construct(null, mbeanInterface, true, isMXBean);
	} catch (NotCompliantMBeanException e) {
	throw new IllegalArgumentException(e);
	}
	}

	/**
	* <p>Replace the implementation object wrapped in this object.</p>
	*
	* @param implementation The new implementation of this Standard MBean
	* (or MXBean). The <code>implementation</code> object must implement
	* the Standard MBean (or MXBean) interface that was supplied when this
	* <code>StandardMBean</code> was constructed.
	*
	* @exception IllegalArgumentException if the given
	* <var>implementation</var> is null.
	*
	* @exception NotCompliantMBeanException if the given
	* <var>implementation</var> does not implement the
	* Standard MBean (or MXBean) interface that was
	* supplied at construction.
	*
	* @see #getImplementation
	**/
	public void setImplementation(Object implementation)
	throws NotCompliantMBeanException {

	if (implementation == null)
	throw new IllegalArgumentException("implementation is null");

	if (isMXBean()) {
	this.mbean = new MXBeanSupport(implementation,
	Util.<Class<Object>>cast(getMBeanInterface()));
	} else {
	this.mbean = new StandardMBeanSupport(implementation,
	Util.<Class<Object>>cast(getMBeanInterface()));
	}
	}

	/**
	* Get the implementation of this Standard MBean (or MXBean).
	* @return The implementation of this Standard MBean (or MXBean).
	*
	* @see #setImplementation
	**/
	public Object getImplementation() {
	return mbean.getResource();
	}

	/**
	* Get the Management Interface of this Standard MBean (or MXBean).
	* @return The management interface of this Standard MBean (or MXBean).
	**/
	public final Class<?> getMBeanInterface() {
	return mbean.getMBeanInterface();
	}

	/**
	* Get the class of the implementation of this Standard MBean (or MXBean).
	* @return The class of the implementation of this Standard MBean (or MXBean).
	**/
	public Class<?> getImplementationClass() {
	return mbean.getResource().getClass();
	}

	// ------------------------------------------------------------------
	// From the DynamicMBean interface.
	// ------------------------------------------------------------------
	public Object getAttribute(String attribute)
	throws AttributeNotFoundException,
	MBeanException,
	ReflectionException {
	return mbean.getAttribute(attribute);
	}

	// ------------------------------------------------------------------
	// From the DynamicMBean interface.
	// ------------------------------------------------------------------
	public void setAttribute(Attribute attribute)
	throws AttributeNotFoundException,
	InvalidAttributeValueException,
	MBeanException,
	ReflectionException {
	mbean.setAttribute(attribute);
	}

	// ------------------------------------------------------------------
	// From the DynamicMBean interface.
	// ------------------------------------------------------------------
	public AttributeList getAttributes(String[] attributes) {
	return mbean.getAttributes(attributes);
	}

	// ------------------------------------------------------------------
	// From the DynamicMBean interface.
	// ------------------------------------------------------------------
	public AttributeList setAttributes(AttributeList attributes) {
	return mbean.setAttributes(attributes);
	}

	// ------------------------------------------------------------------
	// From the DynamicMBean interface.
	// ------------------------------------------------------------------
	public Object invoke(String actionName, Object params[], String signature[])
	throws MBeanException, ReflectionException {
	return mbean.invoke(actionName, params, signature);
	}

	/**
	* Get the {@link MBeanInfo} for this MBean.
	* <p>
	* This method implements
	* {@link javax.management.DynamicMBean#getMBeanInfo()
	* DynamicMBean.getMBeanInfo()}.
	* <p>
	* This method first calls {@link #getCachedMBeanInfo()} in order to
	* retrieve the cached MBeanInfo for this MBean, if any. If the
	* MBeanInfo returned by {@link #getCachedMBeanInfo()} is not null,
	* then it is returned.<br>
	* Otherwise, this method builds a default MBeanInfo for this MBean,
	* using the Management Interface specified for this MBean.
	* <p>
	* While building the MBeanInfo, this method calls the customization
	* hooks that make it possible for subclasses to supply their custom
	* descriptions, parameter names, etc...<br>
	* Finally, it calls {@link #cacheMBeanInfo(javax.management.MBeanInfo)
	* cacheMBeanInfo()} in order to cache the new MBeanInfo.
	* @return The cached MBeanInfo for that MBean, if not null, or a
	* newly built MBeanInfo if none was cached.
	**/
	public MBeanInfo getMBeanInfo() {
	try {
	final MBeanInfo cached = getCachedMBeanInfo();
	if (cached != null) return cached;
	} catch (RuntimeException x) {
	if (MISC_LOGGER.isLoggable(Level.FINEST)) {
	MISC_LOGGER.logp(Level.FINEST,
	MBeanServerFactory.class.getName(), "getMBeanInfo",
	"Failed to get cached MBeanInfo", x);
	}
	}

	if (MISC_LOGGER.isLoggable(Level.FINER)) {
	MISC_LOGGER.logp(Level.FINER,
	MBeanServerFactory.class.getName(), "getMBeanInfo",
	"Building MBeanInfo for " +
	getImplementationClass().getName());
	}

	MBeanSupport<?> msupport = mbean;
	final MBeanInfo bi = msupport.getMBeanInfo();
	final Object impl = msupport.getResource();

	final boolean immutableInfo = immutableInfo(this.getClass());

	final String cname = getClassName(bi);
	final String text = getDescription(bi);
	final MBeanConstructorInfo[] ctors = getConstructors(bi,impl);
	final MBeanAttributeInfo[] attrs = getAttributes(bi);
	final MBeanOperationInfo[] ops = getOperations(bi);
	final MBeanNotificationInfo[] ntfs = getNotifications(bi);
	final Descriptor desc = getDescriptor(bi, immutableInfo);

	final MBeanInfo nmbi = new MBeanInfo(
	cname, text, attrs, ctors, ops, ntfs, desc);
	try {
	cacheMBeanInfo(nmbi);
	} catch (RuntimeException x) {
	if (MISC_LOGGER.isLoggable(Level.FINEST)) {
	MISC_LOGGER.logp(Level.FINEST,
	MBeanServerFactory.class.getName(), "getMBeanInfo",
	"Failed to cache MBeanInfo", x);
	}
	}

	return nmbi;
	}

	/**
	* Customization hook:
	* Get the className that will be used in the MBeanInfo returned by
	* this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom class name. The default implementation returns
	* {@link MBeanInfo#getClassName() info.getClassName()}.
	* @param info The default MBeanInfo derived by reflection.
	* @return the class name for the new MBeanInfo.
	**/
	protected String getClassName(MBeanInfo info) {
	if (info == null) return getImplementationClass().getName();
	return info.getClassName();
	}

	/**
	* Customization hook:
	* Get the description that will be used in the MBeanInfo returned by
	* this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom MBean description. The default implementation returns
	* {@link MBeanInfo#getDescription() info.getDescription()}.
	* @param info The default MBeanInfo derived by reflection.
	* @return the description for the new MBeanInfo.
	**/
	protected String getDescription(MBeanInfo info) {
	if (info == null) return null;
	return info.getDescription();
	}

	/**
	* <p>Customization hook:
	* Get the description that will be used in the MBeanFeatureInfo
	* returned by this MBean.</p>
	*
	* <p>Subclasses may redefine this method in order to supply
	* their custom description. The default implementation returns
	* {@link MBeanFeatureInfo#getDescription()
	* info.getDescription()}.</p>
	*
	* <p>This method is called by
	* {@link #getDescription(MBeanAttributeInfo)},
	* {@link #getDescription(MBeanOperationInfo)},
	* {@link #getDescription(MBeanConstructorInfo)}.</p>
	*
	* @param info The default MBeanFeatureInfo derived by reflection.
	* @return the description for the given MBeanFeatureInfo.
	**/
	protected String getDescription(MBeanFeatureInfo info) {
	if (info == null) return null;
	return info.getDescription();
	}

	/**
	* Customization hook:
	* Get the description that will be used in the MBeanAttributeInfo
	* returned by this MBean.
	*
	* <p>Subclasses may redefine this method in order to supply their
	* custom description. The default implementation returns {@link
	* #getDescription(MBeanFeatureInfo)
	* getDescription((MBeanFeatureInfo) info)}.
	* @param info The default MBeanAttributeInfo derived by reflection.
	* @return the description for the given MBeanAttributeInfo.
	**/
	protected String getDescription(MBeanAttributeInfo info) {
	return getDescription((MBeanFeatureInfo)info);
	}

	/**
	* Customization hook:
	* Get the description that will be used in the MBeanConstructorInfo
	* returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom description.
	* The default implementation returns {@link
	* #getDescription(MBeanFeatureInfo)
	* getDescription((MBeanFeatureInfo) info)}.
	* @param info The default MBeanConstructorInfo derived by reflection.
	* @return the description for the given MBeanConstructorInfo.
	**/
	protected String getDescription(MBeanConstructorInfo info) {
	return getDescription((MBeanFeatureInfo)info);
	}

	/**
	* Customization hook:
	* Get the description that will be used for the <var>sequence</var>
	* MBeanParameterInfo of the MBeanConstructorInfo returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom description. The default implementation returns
	* {@link MBeanParameterInfo#getDescription() param.getDescription()}.
	*
	* @param ctor The default MBeanConstructorInfo derived by reflection.
	* @param param The default MBeanParameterInfo derived by reflection.
	* @param sequence The sequence number of the parameter considered
	* ("0" for the first parameter, "1" for the second parameter,
	* etc...).
	* @return the description for the given MBeanParameterInfo.
	**/
	protected String getDescription(MBeanConstructorInfo ctor,
	MBeanParameterInfo param,
	int sequence) {
	if (param == null) return null;
	return param.getDescription();
	}

	/**
	* Customization hook:
	* Get the name that will be used for the <var>sequence</var>
	* MBeanParameterInfo of the MBeanConstructorInfo returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom parameter name. The default implementation returns
	* {@link MBeanParameterInfo#getName() param.getName()}.
	*
	* @param ctor The default MBeanConstructorInfo derived by reflection.
	* @param param The default MBeanParameterInfo derived by reflection.
	* @param sequence The sequence number of the parameter considered
	* ("0" for the first parameter, "1" for the second parameter,
	* etc...).
	* @return the name for the given MBeanParameterInfo.
	**/
	protected String getParameterName(MBeanConstructorInfo ctor,
	MBeanParameterInfo param,
	int sequence) {
	if (param == null) return null;
	return param.getName();
	}

	/**
	* Customization hook:
	* Get the description that will be used in the MBeanOperationInfo
	* returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom description. The default implementation returns
	* {@link #getDescription(MBeanFeatureInfo)
	* getDescription((MBeanFeatureInfo) info)}.
	* @param info The default MBeanOperationInfo derived by reflection.
	* @return the description for the given MBeanOperationInfo.
	**/
	protected String getDescription(MBeanOperationInfo info) {
	return getDescription((MBeanFeatureInfo)info);
	}

	/**
	* Customization hook:
	* Get the <var>impact</var> flag of the operation that will be used in
	* the MBeanOperationInfo returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom impact flag. The default implementation returns
	* {@link MBeanOperationInfo#getImpact() info.getImpact()}.
	* @param info The default MBeanOperationInfo derived by reflection.
	* @return the impact flag for the given MBeanOperationInfo.
	**/
	protected int getImpact(MBeanOperationInfo info) {
	if (info == null) return MBeanOperationInfo.UNKNOWN;
	return info.getImpact();
	}

	/**
	* Customization hook:
	* Get the name that will be used for the <var>sequence</var>
	* MBeanParameterInfo of the MBeanOperationInfo returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom parameter name. The default implementation returns
	* {@link MBeanParameterInfo#getName() param.getName()}.
	*
	* @param op The default MBeanOperationInfo derived by reflection.
	* @param param The default MBeanParameterInfo derived by reflection.
	* @param sequence The sequence number of the parameter considered
	* ("0" for the first parameter, "1" for the second parameter,
	* etc...).
	* @return the name to use for the given MBeanParameterInfo.
	**/
	protected String getParameterName(MBeanOperationInfo op,
	MBeanParameterInfo param,
	int sequence) {
	if (param == null) return null;
	return param.getName();
	}

	/**
	* Customization hook:
	* Get the description that will be used for the <var>sequence</var>
	* MBeanParameterInfo of the MBeanOperationInfo returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom description. The default implementation returns
	* {@link MBeanParameterInfo#getDescription() param.getDescription()}.
	*
	* @param op The default MBeanOperationInfo derived by reflection.
	* @param param The default MBeanParameterInfo derived by reflection.
	* @param sequence The sequence number of the parameter considered
	* ("0" for the first parameter, "1" for the second parameter,
	* etc...).
	* @return the description for the given MBeanParameterInfo.
	**/
	protected String getDescription(MBeanOperationInfo op,
	MBeanParameterInfo param,
	int sequence) {
	if (param == null) return null;
	return param.getDescription();
	}

	/**
	* Customization hook:
	* Get the MBeanConstructorInfo[] that will be used in the MBeanInfo
	* returned by this MBean.
	* <br>
	* By default, this method returns <code>null</code> if the wrapped
	* implementation is not <var>this</var>. Indeed, if the wrapped
	* implementation is not this object itself, it will not be possible
	* to recreate a wrapped implementation by calling the implementation
	* constructors through <code>MBeanServer.createMBean(...)</code>.<br>
	* Otherwise, if the wrapped implementation is <var>this</var>,
	* <var>ctors</var> is returned.
	* <br>
	* Subclasses may redefine this method in order to modify this
	* behavior, if needed.
	* @param ctors The default MBeanConstructorInfo[] derived by reflection.
	* @param impl The wrapped implementation. If <code>null</code> is
	* passed, the wrapped implementation is ignored and
	* <var>ctors</var> is returned.
	* @return the MBeanConstructorInfo[] for the new MBeanInfo.
	**/
	protected MBeanConstructorInfo[]
	getConstructors(MBeanConstructorInfo[] ctors, Object impl) {
	if (ctors == null) return null;
	if (impl != null && impl != this) return null;
	return ctors;
	}

	/**
	* Customization hook:
	* Get the MBeanNotificationInfo[] that will be used in the MBeanInfo
	* returned by this MBean.
	* <br>
	* Subclasses may redefine this method in order to supply their
	* custom notifications.
	* @param info The default MBeanInfo derived by reflection.
	* @return the MBeanNotificationInfo[] for the new MBeanInfo.
	**/
	MBeanNotificationInfo[] getNotifications(MBeanInfo info) {
	return null;
	}

	/**
	* <p>Get the Descriptor that will be used in the MBeanInfo
	* returned by this MBean.</p>
	*
	* <p>Subclasses may redefine this method in order to supply
	* their custom descriptor.</p>
	*
	* <p>The default implementation of this method returns a Descriptor
	* that contains at least the field {@code interfaceClassName}, with
	* value {@link #getMBeanInterface()}.getName(). It may also contain
	* the field {@code immutableInfo}, with a value that is the string
	* {@code "true"} if the implementation can determine that the
	* {@code MBeanInfo} returned by {@link #getMBeanInfo()} will always
	* be the same. It may contain other fields: fields defined by the
	* JMX specification must have appropriate values, and other fields
	* must follow the conventions for non-standard field names.</p>
	*
	* @param info The default MBeanInfo derived by reflection.
	* @return the Descriptor for the new MBeanInfo.
	*/
	Descriptor getDescriptor(MBeanInfo info, boolean immutableInfo) {
	ImmutableDescriptor desc;
	if (info == null \|\|
	info.getDescriptor() == null \|\|
	info.getDescriptor().getFieldNames().length == 0) {
	final String interfaceClassNameS =
	"interfaceClassName=" + getMBeanInterface().getName();
	final String immutableInfoS =
	"immutableInfo=" + immutableInfo;
	desc = new ImmutableDescriptor(interfaceClassNameS, immutableInfoS);
	desc = descriptors.get(desc);
	} else {
	Descriptor d = info.getDescriptor();
	Map<String,Object> fields = new HashMap<String,Object>();
	for (String fieldName : d.getFieldNames()) {
	if (fieldName.equals("immutableInfo")) {
	// Replace immutableInfo as the underlying MBean/MXBean
	// could already implement NotificationBroadcaster and
	// return immutableInfo=true in its MBeanInfo.
	fields.put(fieldName, Boolean.toString(immutableInfo));
	} else {
	fields.put(fieldName, d.getFieldValue(fieldName));
	}
	}
	desc = new ImmutableDescriptor(fields);
	}
	return desc;
	}

	/**
	* Customization hook:
	* Return the MBeanInfo cached for this object.
	*
	* <p>Subclasses may redefine this method in order to implement their
	* own caching policy. The default implementation stores one
	* {@link MBeanInfo} object per instance.
	*
	* @return The cached MBeanInfo, or null if no MBeanInfo is cached.
	*
	* @see #cacheMBeanInfo(MBeanInfo)
	**/
	protected MBeanInfo getCachedMBeanInfo() {
	return cachedMBeanInfo;
	}

	/**
	* Customization hook:
	* cache the MBeanInfo built for this object.
	*
	* <p>Subclasses may redefine this method in order to implement
	* their own caching policy. The default implementation stores
	* <code>info</code> in this instance. A subclass can define
	* other policies, such as not saving <code>info</code> (so it is
	* reconstructed every time {@link #getMBeanInfo()} is called) or
	* sharing a unique {@link MBeanInfo} object when several
	* <code>StandardMBean</code> instances have equal {@link
	* MBeanInfo} values.
	*
	* @param info the new <code>MBeanInfo</code> to cache. Any
	* previously cached value is discarded. This parameter may be
	* null, in which case there is no new cached value.
	**/
	protected void cacheMBeanInfo(MBeanInfo info) {
	cachedMBeanInfo = info;
	}

	private boolean isMXBean() {
	return mbean.isMXBean();
	}

	private static <T> boolean identicalArrays(T[] a, T[] b) {
	if (a == b)
	return true;
	if (a == null \|\| b == null \|\| a.length != b.length)
	return false;
	for (int i = 0; i < a.length; i++) {
	if (a[i] != b[i])
	return false;
	}
	return true;
	}

	private static <T> boolean equal(T a, T b) {
	if (a == b)
	return true;
	if (a == null \|\| b == null)
	return false;
	return a.equals(b);
	}

	private static MBeanParameterInfo
	customize(MBeanParameterInfo pi,
	String name,
	String description) {
	if (equal(name, pi.getName()) &&
	equal(description, pi.getDescription()))
	return pi;
	else if (pi instanceof OpenMBeanParameterInfo) {
	OpenMBeanParameterInfo opi = (OpenMBeanParameterInfo) pi;
	return new OpenMBeanParameterInfoSupport(name,
	description,
	opi.getOpenType(),
	pi.getDescriptor());
	} else {
	return new MBeanParameterInfo(name,
	pi.getType(),
	description,
	pi.getDescriptor());
	}
	}

	private static MBeanConstructorInfo
	customize(MBeanConstructorInfo ci,
	String description,
	MBeanParameterInfo[] signature) {
	if (equal(description, ci.getDescription()) &&
	identicalArrays(signature, ci.getSignature()))
	return ci;
	if (ci instanceof OpenMBeanConstructorInfo) {
	OpenMBeanParameterInfo[] oparams =
	paramsToOpenParams(signature);
	return new OpenMBeanConstructorInfoSupport(ci.getName(),
	description,
	oparams,
	ci.getDescriptor());
	} else {
	return new MBeanConstructorInfo(ci.getName(),
	description,
	signature,
	ci.getDescriptor());
	}
	}

	private static MBeanOperationInfo
	customize(MBeanOperationInfo oi,
	String description,
	MBeanParameterInfo[] signature,
	int impact) {
	if (equal(description, oi.getDescription()) &&
	identicalArrays(signature, oi.getSignature()) &&
	impact == oi.getImpact())
	return oi;
	if (oi instanceof OpenMBeanOperationInfo) {
	OpenMBeanOperationInfo ooi = (OpenMBeanOperationInfo) oi;
	OpenMBeanParameterInfo[] oparams =
	paramsToOpenParams(signature);
	return new OpenMBeanOperationInfoSupport(oi.getName(),
	description,
	oparams,
	ooi.getReturnOpenType(),
	impact,
	oi.getDescriptor());
	} else {
	return new MBeanOperationInfo(oi.getName(),
	description,
	signature,
	oi.getReturnType(),
	impact,
	oi.getDescriptor());
	}
	}

	private static MBeanAttributeInfo
	customize(MBeanAttributeInfo ai,
	String description) {
	if (equal(description, ai.getDescription()))
	return ai;
	if (ai instanceof OpenMBeanAttributeInfo) {
	OpenMBeanAttributeInfo oai = (OpenMBeanAttributeInfo) ai;
	return new OpenMBeanAttributeInfoSupport(ai.getName(),
	description,
	oai.getOpenType(),
	ai.isReadable(),
	ai.isWritable(),
	ai.isIs(),
	ai.getDescriptor());
	} else {
	return new MBeanAttributeInfo(ai.getName(),
	ai.getType(),
	description,
	ai.isReadable(),
	ai.isWritable(),
	ai.isIs(),
	ai.getDescriptor());
	}
	}

	private static OpenMBeanParameterInfo[]
	paramsToOpenParams(MBeanParameterInfo[] params) {
	if (params instanceof OpenMBeanParameterInfo[])
	return (OpenMBeanParameterInfo[]) params;
	OpenMBeanParameterInfo[] oparams =
	new OpenMBeanParameterInfoSupport[params.length];
	System.arraycopy(params, 0, oparams, 0, params.length);
	return oparams;
	}

	// ------------------------------------------------------------------
	// Build the custom MBeanConstructorInfo[]
	// ------------------------------------------------------------------
	private MBeanConstructorInfo[]
	getConstructors(MBeanInfo info, Object impl) {
	final MBeanConstructorInfo[] ctors =
	getConstructors(info.getConstructors(), impl);
	if (ctors == null)
	return null;
	final int ctorlen = ctors.length;
	final MBeanConstructorInfo[] nctors = new MBeanConstructorInfo[ctorlen];
	for (int i=0; i<ctorlen; i++) {
	final MBeanConstructorInfo c = ctors[i];
	final MBeanParameterInfo[] params = c.getSignature();
	final MBeanParameterInfo[] nps;
	if (params != null) {
	final int plen = params.length;
	nps = new MBeanParameterInfo[plen];
	for (int ii=0;ii<plen;ii++) {
	MBeanParameterInfo p = params[ii];
	nps[ii] = customize(p,
	getParameterName(c,p,ii),
	getDescription(c,p,ii));
	}
	} else {
	nps = null;
	}
	nctors[i] =
	customize(c, getDescription(c), nps);
	}
	return nctors;
	}

	// ------------------------------------------------------------------
	// Build the custom MBeanOperationInfo[]
	// ------------------------------------------------------------------
	private MBeanOperationInfo[] getOperations(MBeanInfo info) {
	final MBeanOperationInfo[] ops = info.getOperations();
	if (ops == null)
	return null;
	final int oplen = ops.length;
	final MBeanOperationInfo[] nops = new MBeanOperationInfo[oplen];
	for (int i=0; i<oplen; i++) {
	final MBeanOperationInfo o = ops[i];
	final MBeanParameterInfo[] params = o.getSignature();
	final MBeanParameterInfo[] nps;
	if (params != null) {
	final int plen = params.length;
	nps = new MBeanParameterInfo[plen];
	for (int ii=0;ii<plen;ii++) {
	MBeanParameterInfo p = params[ii];
	nps[ii] = customize(p,
	getParameterName(o,p,ii),
	getDescription(o,p,ii));
	}
	} else {
	nps = null;
	}
	nops[i] = customize(o, getDescription(o), nps, getImpact(o));
	}
	return nops;
	}

	// ------------------------------------------------------------------
	// Build the custom MBeanAttributeInfo[]
	// ------------------------------------------------------------------
	private MBeanAttributeInfo[] getAttributes(MBeanInfo info) {
	final MBeanAttributeInfo[] atts = info.getAttributes();
	if (atts == null)
	return null; // should not happen
	final MBeanAttributeInfo[] natts;
	final int attlen = atts.length;
	natts = new MBeanAttributeInfo[attlen];
	for (int i=0; i<attlen; i++) {
	final MBeanAttributeInfo a = atts[i];
	natts[i] = customize(a, getDescription(a));
	}
	return natts;
	}

	/**
	* <p>Allows the MBean to perform any operations it needs before
	* being registered in the MBean server. If the name of the MBean
	* is not specified, the MBean can provide a name for its
	* registration. If any exception is raised, the MBean will not be
	* registered in the MBean server.</p>
	*
	* <p>The default implementation of this method returns the {@code name}
	* parameter. It does nothing else for
	* Standard MBeans. For MXBeans, it records the {@code MBeanServer}
	* and {@code ObjectName} parameters so they can be used to translate
	* inter-MXBean references.</p>
	*
	* <p>It is good practice for a subclass that overrides this method
	* to call the overridden method via {@code super.preRegister(...)}.
	* This is necessary if this object is an MXBean that is referenced
	* by attributes or operations in other MXBeans.</p>
	*
	* @param server The MBean server in which the MBean will be registered.
	*
	* @param name The object name of the MBean. This name is null if
	* the name parameter to one of the <code>createMBean</code> or
	* <code>registerMBean</code> methods in the {@link MBeanServer}
	* interface is null. In that case, this method must return a
	* non-null ObjectName for the new MBean.
	*
	* @return The name under which the MBean is to be registered.
	* This value must not be null. If the <code>name</code>
	* parameter is not null, it will usually but not necessarily be
	* the returned value.
	*
	* @throws IllegalArgumentException if this is an MXBean and
	* {@code name} is null.
	*
	* @throws InstanceAlreadyExistsException if this is an MXBean and
	* it has already been registered under another name (in this
	* MBean Server or another).
	*
	* @throws Exception no other checked exceptions are thrown by
	* this method but {@code Exception} is declared so that subclasses
	* can override the method and throw their own exceptions.
	*
	* @since 1.6
	*/
	public ObjectName preRegister(MBeanServer server, ObjectName name)
	throws Exception {
	mbean.register(server, name);
	return name;
	}

	/**
	* <p>Allows the MBean to perform any operations needed after having been
	* registered in the MBean server or after the registration has failed.</p>
	*
	* <p>The default implementation of this method does nothing for
	* Standard MBeans. For MXBeans, it undoes any work done by
	* {@link #preRegister preRegister} if registration fails.</p>
	*
	* <p>It is good practice for a subclass that overrides this method
	* to call the overridden method via {@code super.postRegister(...)}.
	* This is necessary if this object is an MXBean that is referenced
	* by attributes or operations in other MXBeans.</p>
	*
	* @param registrationDone Indicates whether or not the MBean has
	* been successfully registered in the MBean server. The value
	* false means that the registration phase has failed.
	*
	* @since 1.6
	*/
	public void postRegister(Boolean registrationDone) {
	if (!registrationDone)
	mbean.unregister();
	}

	/**
	* <p>Allows the MBean to perform any operations it needs before
	* being unregistered by the MBean server.</p>
	*
	* <p>The default implementation of this method does nothing.</p>
	*
	* <p>It is good practice for a subclass that overrides this method
	* to call the overridden method via {@code super.preDeregister(...)}.</p>
	*
	* @throws Exception no checked exceptions are throw by this method
	* but {@code Exception} is declared so that subclasses can override
	* this method and throw their own exceptions.
	*
	* @since 1.6
	*/
	public void preDeregister() throws Exception {
	}

	/**
	* <p>Allows the MBean to perform any operations needed after having been
	* unregistered in the MBean server.</p>
	*
	* <p>The default implementation of this method does nothing for
	* Standard MBeans. For MXBeans, it removes any information that
	* was recorded by the {@link #preRegister preRegister} method.</p>
	*
	* <p>It is good practice for a subclass that overrides this method
	* to call the overridden method via {@code super.postRegister(...)}.
	* This is necessary if this object is an MXBean that is referenced
	* by attributes or operations in other MXBeans.</p>
	*
	* @since 1.6
	*/
	public void postDeregister() {
	mbean.unregister();
	}

	//
	// MBeanInfo immutability
	//

	/**
	* Cached results of previous calls to immutableInfo. This is
	* a WeakHashMap so that we don't prevent a class from being
	* garbage collected just because we know whether its MBeanInfo
	* is immutable.
	*/
	private static final Map<Class<?>, Boolean> mbeanInfoSafeMap =
	new WeakHashMap<Class<?>, Boolean>();

	/**
	* Return true if {@code subclass} is known to preserve the immutability
	* of the {@code MBeanInfo}. The {@code subclass} is considered to have
	* an immutable {@code MBeanInfo} if it does not override any of the
	* getMBeanInfo, getCachedMBeanInfo, cacheMBeanInfo and getNotificationInfo
	* methods.
	*/
	static boolean immutableInfo(Class<? extends StandardMBean> subclass) {
	if (subclass == StandardMBean.class \|\|
	subclass == StandardEmitterMBean.class)
	return true;
	synchronized (mbeanInfoSafeMap) {
	Boolean safe = mbeanInfoSafeMap.get(subclass);
	if (safe == null) {
	try {
	MBeanInfoSafeAction action =
	new MBeanInfoSafeAction(subclass);
	safe = AccessController.doPrivileged(action);
	} catch (Exception e) { // e.g. SecurityException
	/* We don't know, so we assume it isn't. */
	safe = false;
	}
	mbeanInfoSafeMap.put(subclass, safe);
	}
	return safe;
	}
	}

	static boolean overrides(Class<?> subclass, Class<?> superclass,
	String name, Class<?>... params) {
	for (Class<?> c = subclass; c != superclass; c = c.getSuperclass()) {
	try {
	c.getDeclaredMethod(name, params);
	return true;
	} catch (NoSuchMethodException e) {
	// OK: this class doesn't override it
	}
	}
	return false;
	}

	private static class MBeanInfoSafeAction
	implements PrivilegedAction<Boolean> {

	private final Class<?> subclass;

	MBeanInfoSafeAction(Class<?> subclass) {
	this.subclass = subclass;
	}

	public Boolean run() {
	// Check for "void cacheMBeanInfo(MBeanInfo)" method.
	//
	if (overrides(subclass, StandardMBean.class,
	"cacheMBeanInfo", MBeanInfo.class))
	return false;

	// Check for "MBeanInfo getCachedMBeanInfo()" method.
	//
	if (overrides(subclass, StandardMBean.class,
	"getCachedMBeanInfo", (Class<?>[]) null))
	return false;

	// Check for "MBeanInfo getMBeanInfo()" method.
	//
	if (overrides(subclass, StandardMBean.class,
	"getMBeanInfo", (Class<?>[]) null))
	return false;

	// Check for "MBeanNotificationInfo[] getNotificationInfo()"
	// method.
	//
	// This method is taken into account for the MBeanInfo
	// immutability checks if and only if the given subclass is
	// StandardEmitterMBean itself or can be assigned to
	// StandardEmitterMBean.
	//
	if (StandardEmitterMBean.class.isAssignableFrom(subclass))
	if (overrides(subclass, StandardEmitterMBean.class,
	"getNotificationInfo", (Class<?>[]) null))
	return false;
	return true;
	}
	}
	}

Back to index...