sun.management.ExtendedPlatformComponent Java Examples

The following examples show how to use sun.management.ExtendedPlatformComponent. 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: ManagementFactory.java    From hottub with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #2
Source File: ManagementFactory.java    From openjdk-jdk8u with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #3
Source File: ManagementFactory.java    From openjdk-jdk8u-backup with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #4
Source File: ManagementFactory.java    From jdk1.8-source-analysis with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #5
Source File: ManagementFactory.java    From openjdk-jdk8u-backup with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #6
Source File: ManagementFactory.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #7
Source File: ManagementFactory.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #8
Source File: ManagementFactory.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #9
Source File: ManagementFactory.java    From Java8CN with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #10
Source File: ManagementFactory.java    From Java8CN with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #11
Source File: ManagementFactory.java    From Java8CN with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #12
Source File: ManagementFactory.java    From hottub with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #13
Source File: ManagementFactory.java    From openjdk-jdk8u-backup with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #14
Source File: ManagementFactory.java    From hottub with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #15
Source File: ManagementFactory.java    From jdk8u_jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #16
Source File: ManagementFactory.java    From jdk8u_jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #17
Source File: ManagementFactory.java    From jdk8u_jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #18
Source File: ManagementFactory.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #19
Source File: ManagementFactory.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #20
Source File: ManagementFactory.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #21
Source File: ManagementFactory.java    From jdk8u-dev-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #22
Source File: ManagementFactory.java    From jdk8u-dev-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #23
Source File: ManagementFactory.java    From jdk8u-dev-jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #24
Source File: ManagementFactory.java    From dragonwell8_jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #25
Source File: ManagementFactory.java    From dragonwell8_jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #26
Source File: ManagementFactory.java    From TencentKona-8 with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean implementing
 * the given {@code mxbeanInterface} which is specified
 * to have one single instance in the Java virtual machine.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine (for example,
 * a Java virtual machine with no compilation system does not
 * implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *    {@link #getPlatformMXBeans(Class)
 *      getPlatformMXBeans(mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean that implements
 * {@code mxbeanInterface}, or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 *
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(Class<T> mxbeanInterface) {
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            return mbean;
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");

    return pc.getSingletonMXBean(mxbeanInterface);
}
Example #27
Source File: ManagementFactory.java    From dragonwell8_jdk with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #28
Source File: ManagementFactory.java    From TencentKona-8 with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}
Example #29
Source File: ManagementFactory.java    From TencentKona-8 with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the list of the platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 * The returned list may contain zero, one, or more instances.
 * The number of instances in the returned list is defined
 * in the specification of the given management interface.
 * The order is undefined and there is no guarantee that
 * the list returned is in the same order as previous invocations.
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *                        MXBean
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the list of platform MXBean proxies for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection}.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface.
 *
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        List<T> getPlatformMXBeans(MBeanServerConnection connection,
                                   Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            T proxy = ManagementFactory.newPlatformMXBeanProxy(connection,
                        on.getCanonicalName(), mxbeanInterface);
            return Collections.singletonList(proxy);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
Example #30
Source File: ManagementFactory.java    From openjdk-jdk8u with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * Returns the platform MXBean proxy for
 * {@code mxbeanInterface} which is specified to have one single
 * instance in a Java virtual machine and the proxy will
 * forward the method calls through the given {@code MBeanServerConnection}.
 * This method may return {@code null} if the management interface
 * is not implemented in the Java virtual machine being monitored
 * (for example, a Java virtual machine with no compilation system
 * does not implement {@link CompilationMXBean});
 * otherwise, this method is equivalent to calling:
 * <pre>
 *     {@link #getPlatformMXBeans(MBeanServerConnection, Class)
 *        getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
 * </pre>
 *
 * @param connection the {@code MBeanServerConnection} to forward to.
 * @param mxbeanInterface a management interface for a platform
 *     MXBean with one single instance in the Java virtual machine
 *     being monitored, if implemented.
 * @param <T> an {@code mxbeanInterface} type parameter
 *
 * @return the platform MXBean proxy for
 * forwarding the method calls of the {@code mxbeanInterface}
 * through the given {@code MBeanServerConnection},
 * or {@code null} if not exist.
 *
 * @throws IllegalArgumentException if {@code mxbeanInterface}
 * is not a platform management interface or
 * not a singleton platform MXBean.
 * @throws java.io.IOException if a communication problem
 * occurred when accessing the {@code MBeanServerConnection}.
 *
 * @see #newPlatformMXBeanProxy
 * @since 1.7
 */
public static <T extends PlatformManagedObject>
        T getPlatformMXBean(MBeanServerConnection connection,
                            Class<T> mxbeanInterface)
    throws java.io.IOException
{
    PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
    if (pc == null) {
        T mbean = ExtendedPlatformComponent.getMXBean(mxbeanInterface);
        if (mbean != null) {
            ObjectName on = mbean.getObjectName();
            return ManagementFactory.newPlatformMXBeanProxy(connection,
                                                            on.getCanonicalName(),
                                                            mxbeanInterface);
        }
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " is not a platform management interface");
    }
    if (!pc.isSingleton())
        throw new IllegalArgumentException(mxbeanInterface.getName() +
            " can have zero or more than one instances");
    return pc.getSingletonMXBean(connection, mxbeanInterface);
}