Java Code Examples for com.sun.jmx.mbeanserver.JmxMBeanServer#newMBeanServer()

The following examples show how to use com.sun.jmx.mbeanserver.JmxMBeanServer#newMBeanServer() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: TCKMBeanServerBuilder.java    From ignite with Apache License 2.0 4 votes vote down vote up 
/** {@inheritDoc} */
@Override public MBeanServer newMBeanServer(String dfltDomain, MBeanServer outer, MBeanServerDelegate delegate) {
    MBeanServerDelegate decoratingDelegate = new ServerDelegate(delegate);
    return JmxMBeanServer.newMBeanServer(dfltDomain, outer,
        decoratingDelegate, false);
}
Example 2
Source File: MBeanServerBuilder.java    From jdk8u-jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 3
Source File: MBeanServerBuilder.java    From jdk8u-dev-jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 4
Source File: MBeanServerBuilder.java    From jdk8u-jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 5
Source File: MBeanServerBuilder.java    From jdk8u_jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 6
Source File: MBeanServerBuilder.java    From openjdk-8 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 7
Source File: MBeanServerBuilder.java    From openjdk-8-source with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 8
Source File: MBeanServerBuilder.java    From hottub with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 9
Source File: MBeanServerBuilder.java    From Java8CN with Apache License 2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 10
Source File: MBeanServerBuilder.java    From jdk1.8-source-analysis with Apache License 2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 11
Source File: MBeanServerBuilder.java    From openjdk-jdk9 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 12
Source File: MBeanServerBuilder.java    From openjdk-jdk8u-backup with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 13
Source File: MBeanServerBuilder.java    From openjdk-jdk8u with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 14
Source File: MBeanServerBuilder.java    From JDKSourceCode1.8 with MIT License 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 15
Source File: MBeanServerBuilder.java    From jdk8u60 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 16
Source File: MBeanServerBuilder.java    From TencentKona-8 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}
Example 17
Source File: MBeanServerBuilder.java    From dragonwell8_jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * This method creates a new MBeanServer implementation object.
 * When creating a new MBeanServer the
 * {@link javax.management.MBeanServerFactory} first calls
 * <code>newMBeanServerDelegate()</code> in order to obtain a new
 * {@link javax.management.MBeanServerDelegate} for the new
 * MBeanServer. Then it calls
 * <code>newMBeanServer(defaultDomain,outer,delegate)</code>
 * passing the <var>delegate</var> that should be used by the MBeanServer
 * implementation.
 * <p>Note that the passed <var>delegate</var> might not be directly the
 * MBeanServerDelegate that was returned by this implementation. It could
 * be, for instance, a new object wrapping the previously
 * returned delegate.
 * <p>The <var>outer</var> parameter is a pointer to the MBeanServer that
 * should be passed to the {@link javax.management.MBeanRegistration}
 * interface when registering MBeans inside the MBeanServer.
 * If <var>outer</var> is <code>null</code>, then the MBeanServer
 * implementation must use its own <code>this</code> reference when
 * invoking the {@link javax.management.MBeanRegistration} interface.
 * <p>This makes it possible for a MBeanServer implementation to wrap
 * another MBeanServer implementation, in order to implement, e.g,
 * security checks, or to prevent access to the actual MBeanServer
 * implementation by returning a pointer to a wrapping object.
 *
 * @param defaultDomain Default domain of the new MBeanServer.
 * @param outer A pointer to the MBeanServer object that must be
 *        passed to the MBeans when invoking their
 *        {@link javax.management.MBeanRegistration} interface.
 * @param delegate A pointer to the MBeanServerDelegate associated
 *        with the new MBeanServer. The new MBeanServer must register
 *        this MBean in its MBean repository.
 *
 * @return A new private implementation of an MBeanServer.
 **/
public MBeanServer newMBeanServer(String              defaultDomain,
                                  MBeanServer         outer,
                                  MBeanServerDelegate delegate) {
    // By default, MBeanServerInterceptors are disabled.
    // Use com.sun.jmx.mbeanserver.MBeanServerBuilder to obtain
    // MBeanServers on which MBeanServerInterceptors are enabled.
    return JmxMBeanServer.newMBeanServer(defaultDomain,outer,delegate,
                                         false);
}