Java JMXConnectorFactory.newJMXConnector方法代码示例

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
private static void dotest(JMXServiceURL url, MBeanServer mbs)
    throws Exception {
    JMXConnectorServer server = null;
    JMXConnector client = null;

    server = JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);
    server.start();
    JMXServiceURL outputAddr = server.getAddress();
    System.out.println("Server started ["+ outputAddr+ "]");

    client = JMXConnectorFactory.newJMXConnector(outputAddr, null);

    client.connect();
    System.out.println("Client connected");

    MBeanServerConnection connection
        = client.getMBeanServerConnection();

    System.out.println(connection.getDefaultDomain());
}
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
MBeanWrapper( int jvmPort ) throws MonitorConfigurationException {

        this.jvmPort = jvmPort;
        try {
            JMXConnector connector = JMXConnectorFactory.newJMXConnector(new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:"
                                                                                           + this.jvmPort
                                                                                           + "/jmxrmi"),
                                                                         null);
            connector.connect();

            this.connection = connector.getMBeanServerConnection();
        } catch (Exception e) {
            final String msg = "Error initializing the JMV monitor. Unable to connect to JVM at port "
                               + this.jvmPort;
            log.error(msg, e);
            throw new MonitorConfigurationException(msg, e);
        }
    }
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
/**
    * {@inheritDoc}
    * @see javax.management.remote.JMXConnectorProvider#newJMXConnector(javax.management.remote.JMXServiceURL, java.util.Map)
    */
   @Override
public JMXConnector newJMXConnector(final JMXServiceURL serviceURL, final Map<String, ?> env) throws IOException {
	if (!serviceURL.getProtocol().equals(PROTOCOL_NAME)) {
		throw new MalformedURLException("Protocol not [" + PROTOCOL_NAME + "]: " +
					    serviceURL.getProtocol());
	}
	final Map<String, ?> environment = env==null ? new HashMap<String, Object>() : env;
	final String remoteHost = serviceURL.getHost();
	final int remotePort = serviceURL.getPort();
	
	final int localPort = SSHTunnelManager.getInstance().getPortForward(remoteHost, remotePort);
	final String format = environment.containsKey(DELEGATE_PROTOCOL_FORMAT_KEY) ? environment.get(DELEGATE_PROTOCOL_FORMAT_KEY).toString() : DEFAULT_DELEGATE_PROTOCOL_FORMAT;
	
	final JMXServiceURL tunneledURL = JMXHelper.serviceUrl(format, "localhost", localPort);
	final JMXConnector connector = JMXConnectorFactory.newJMXConnector(tunneledURL, environment);
	
	final UpdateableJMXConnector ujmx = new UpdateableJMXConnector(connector, serviceURL, environment);
	connector.addConnectionNotificationListener(this, this, ujmx);
	return ujmx;
   }
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
@Test
public void testStop() throws Exception {
  MiniHBaseCluster cluster = UTIL.getHBaseCluster();
  LOG.info("shutdown hbase cluster...");
  cluster.shutdown();
  LOG.info("wait for the hbase cluster shutdown...");
  cluster.waitUntilShutDown();

  JMXConnector connector = JMXConnectorFactory.newJMXConnector(
    JMXListener.buildJMXServiceURL(connectorPort,connectorPort), null);
  expectedEx.expect(IOException.class);
  connector.connect();

}
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
/**
 * Creates a new JMXClient
 * @param jmxUrl The JMX URL
 * @param connectTimeoutSecs The timeout on connecting and acquiring a connection
 * @param credentials The optional credentials
 */
public JMXClient(final String jmxUrl, final long connectTimeoutSecs, final String...credentials) {
	super();
	this.jmxUrl = jmxUrl;
	this.connectTimeoutSecs = connectTimeoutSecs;
	env.put(ClientProvider.RECONNECT_TIMEOUT_KEY, this.connectTimeoutSecs);
	JMXServiceURL jurl = JMXHelper.serviceUrl(jmxUrl);
	final String rhost = jurl.getHost();
	final int rport = jurl.getPort();
	if("tunnel".equals(jurl.getProtocol())) {
		final int localPort = SSHTunnelManager.getInstance().getPortForward(rhost, rport);
		jurl = JMXHelper.serviceUrl("service:jmx:jmxmp://localhost:" + localPort);
	}
	jmxServiceUrl = jurl;
	log = LogManager.getLogger(getClass().getName() + "-" + rhost.replace('.', '_') + "-" + rport);
	if(credentials!=null && credentials.length > 1) {
		final String[] creds = new String[2];
		System.arraycopy(credentials, 0, creds, 0, 2);
		env.put(JMXConnector.CREDENTIALS, creds);
	}
	final Map<String, String> qArgs = queryArgsToMap(jmxServiceUrl);
	remoteApp = qArgs.get(APP_QUERY_ARG);
	remoteHost = qArgs.get(HOST_QUERY_ARG);
	hystrixEnabled.set(ConfigurationHelper.getBooleanSystemThenEnvProperty(CONFIG_HYSTRIX_ENABLED, DEFAULT_HYSTRIX_ENABLED));
	if(hystrixEnabled.get()) {
		commandBuilder = HystrixCommandFactory.getInstance().builder(CONFIG_HYSTRIX, "jmx-remote-" + jmxServiceUrl.getProtocol())
				.andCommandKey(jmxServiceUrl.getHost().replace('.', '-') + "." + jmxServiceUrl.getPort())
				.andThreadPoolKey("jmxremoting")
				.build();
	} else {
		commandBuilder = null;
	}
	
	
	try {
		jmxConnector = JMXConnectorFactory.newJMXConnector(jmxServiceUrl, env);
	} catch (IOException iex) {
		throw new RuntimeException("Failed to create JMXConnector", iex);
	}
}
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
@PostConstruct
public void initializeJMXConnector() {
    try {
        String managementPort = System.getProperty("com.sun.management.jmxremote.port");
        JMXServiceURL jmxServiceURL = new JMXServiceURL("rmi", "", 0, "/jndi/rmi://" + JMX_HOST + ":" + managementPort + "/jmxrmi");
        jmxConnector = JMXConnectorFactory.newJMXConnector(jmxServiceURL, new HashMap<>());
        jmxConnector.connect();
        remoteConnection = jmxConnector.getMBeanServerConnection();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
private static void test() {
    try {
        JMXServiceURL u = new JMXServiceURL("rmi", null, 0);
        JMXConnectorServer server;
        JMXServiceURL addr;
        JMXConnector client;
        MBeanServerConnection mserver;

        final ObjectName delegateName =
            new ObjectName("JMImplementation:type=MBeanServerDelegate");
        final NotificationListener dummyListener =
            new NotificationListener() {
                    public void handleNotification(Notification n,
                                                   Object o) {
                        // do nothing
                        return;
                    }
                };

        server = JMXConnectorServerFactory.newJMXConnectorServer(u,
                                                                 null,
                                                                 mbs);
        server.start();

        addr = server.getAddress();
        client = JMXConnectorFactory.newJMXConnector(addr, null);
        client.connect(null);

        mserver = client.getMBeanServerConnection();
        String s1 = "1";
        String s2 = "2";
        String s3 = "3";

        mserver.addNotificationListener(delegateName,
                                        dummyListener, null, s1);
        mserver.addNotificationListener(delegateName,
                                        dummyListener, null, s2);
        mserver.addNotificationListener(delegateName,
                                        dummyListener, null, s3);

        mserver.removeNotificationListener(delegateName,
                                           dummyListener, null, s3);
        mserver.removeNotificationListener(delegateName,
                                           dummyListener, null, s2);
        mserver.removeNotificationListener(delegateName,
                                           dummyListener, null, s1);
        client.close();

        server.stop();
    } catch (Exception e) {
        System.out.println(e);
        e.printStackTrace();
        System.exit(1);
    }
}
 

import javax.management.remote.JMXConnectorFactory; //导入方法依赖的package包/类
private static void dotest(String protocol,
                           NotificationSender s,
                           ObjectName notifierName) throws Exception {
    JMXConnector client = null;
    JMXConnectorServer server = null;
    JMXServiceURL u = null;
    try {
        u = new JMXServiceURL(protocol, null, 0);
        server =
            JMXConnectorServerFactory.newJMXConnectorServer(u,
                                                            null,
                                                            mbs);
        checkNotifier(s, 0, "new ConnectorServer");

        server.start();

        checkNotifier(s, 0, "ConnectorServer start");

        JMXServiceURL addr = server.getAddress();
        client = JMXConnectorFactory.newJMXConnector(addr, null);

        checkNotifier(s, 0, "new Connector");

        client.connect(null);

        checkNotifier(s, 0, "Connector connect");

        MBeanServerConnection mbsc = client.getMBeanServerConnection();

        final NotificationListener dummyListener =
            new NotificationListener() {
                    public void handleNotification(Notification n,
                                                   Object o) {
                        // do nothing
                        return;
                    }
                };

        mbsc.addNotificationListener(notifierName,
                                     dummyListener,
                                     null,
                                     null);

        // 1 Listener is expected to be added by the ServerNotifForwader
        checkNotifier(s, 1, "addNotificationListener");

        mbsc.removeNotificationListener(notifierName,
                                        dummyListener);
        System.out.println("Test OK for " + protocol);
    }catch(MalformedURLException e) {
        System.out.println("Skipping URL " + u);
    }
    finally {
        if(client != null)
            client.close();
        if(server != null)
            server.stop();
    }
}