import org.jolokia.client.J4pClient; //导入依赖的package包/类
public static J4pClient createJolokiaClient(String jolokiaUrl, String username, String password) {
    J4pClientBuilder builder = J4pClientBuilderFactory.url(jolokiaUrl);
    boolean auth = false;
    if (isNotEmpty(username)) {
        builder = builder.user(username);
        auth = true;
    }
    if (isNotEmpty(password)) {
        builder = builder.password(password);
        auth = true;
    }
    if (auth) {
        builder = builder.authenticator(new BasicAuthenticator(true));
    }
    return builder.build();
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
/** @see org.hawkular.agent.monitor.protocol.EndpointService#openSession() */
@Override
public JMXSession openSession() {
    Driver<JMXNodeLocation> driver;

    if (this.clientFactory != null) {
        // remote JMX access via Jolokia
        J4pClient client = clientFactory.createClient();
        driver = new JolokiaJMXDriver(getDiagnostics(), client);
    } else {
        // local JMX access via JMX API
        MBeanServerConnection mbs = getMBeanServerConnection();
        driver = new MBeanServerConnectionJMXDriver(getDiagnostics(), mbs);
    }

    return new JMXSession(getFeedId(), getMonitoredEndpoint(), getResourceTypeManager(), driver,
            getLocationResolver());
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
@Test
public void testExecData() throws Exception {
	J4pClient j4pClient = new J4pClient("http://localhost:8080/jolokia-war-1.1.3");
	// J4pReadRequest req = new
	// J4pReadRequest("jboss.system:type=ServerInfo","ActiveThreadCount",
	// "ActiveThreadGroupCount", "MaxMemory", "HostName",
	// "TotalMemory","FreeMemory");
	List<String> attributes = Arrays.asList(new String[] { "DetailedStatus" });
	//
	// J4pReadRequest req = new
	// J4pReadRequest("jboss.ws:context=*,endpoint=*",
	// attributes.toArray(new String[]{}));

	J4pExecRequest req = new J4pExecRequest("se.arbetsformedlingen.utils.probe:service=TestWebService2", "checkStatus");

	J4pExecResponse resp = j4pClient.execute(req);
	Map<String, Object> v = (Map<String, Object>) resp.getValue();
	System.out.println(v);
	for (String attrib : attributes) {
		try {
			System.out.println(attrib + "=" + v.get(attrib));
		} catch (Exception ignore) {
		}
	}

}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
private void fetchMbeanMetadata(final J4pClient client) {
    try {
        J4pListRequest request = new J4pListRequest(new ObjectName(MBEAN_JAVA_LANG_MEMORY));
        logger().trace("Listing: {}", MBEAN_JAVA_LANG_MEMORY);
        client.execute(request); // Ignore response
    } catch (J4pException | MalformedObjectNameException e) {
        logger().error("Failed to execute list request: {}", MBEAN_JAVA_LANG_MEMORY, e);
    }
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
private void createJolokiaClient() {
    client = J4pClient
            .url(url)
            .user(user)
            .password(password)
            .pooledConnections()
            .build();
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
@PostConstruct
public void init() {
    client = J4pClient.url(jolokiaUrl)
            // a dummy value for user is needed, because otherwise, J4pClient will not attempt to use Authenticator
            .user(jolokiaAuthUser)
            //.password(properties.getProperty(Config.JOLOKIA_AUTH_PASSWORD))
            .authenticator(authenticator)
            .useProxyFromEnvironment()
            .build();
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
/**
 * Wraps the connection to Jolokia.
 *
 * @param URL the URL to connect to the Jolokia agent on.
 */
@SuppressWarnings("SameParameterValue")
public MetricsClient(String URL) {
    client = J4pClient.url(URL)
            .socketTimeout(5000)
            .build();

    this.URL = URL;
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
@Override
protected void doStop(MutableManagedProcess process) throws Exception {
    // [TODO] #55 Topology should manage ProcessRegistration instead of just ProcessIdentity
    // Every managed process also creates an agent with the same id as the process
    // Obtain the jolokia endpoint URL from the ProcessRegistration
    AgentIdentity agentId = AgentIdentity.create(process.getIdentity().getName());
    AgentTopology topology = ManagementUtils.getMXBeanProxy(getMBeanServer(), AgentTopology.OBJECT_NAME, AgentTopology.class);
    AgentRegistration remoteAgent = topology.getAgentRegistration(agentId);
    String serviceURL = remoteAgent.getJolokiaEndpoint();
    J4pClient client = new J4pClient(serviceURL);
    ObjectName oname = getFrameworkMBeanName(client);
    J4pExecRequest execReq = new J4pExecRequest(oname, "shutdownFramework");
    client.execute(execReq);
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
public static LogbackContext getSingleLogbackContext(J4pClient client) throws J4pException {
	Objects.requireNonNull(client, "client should not be null");
	
	Map<String, Object> logbacks = client.execute(new J4pListRequest(LOGBACK_PATH)).getValue();
	
	if(logbacks.size() != 1) {
		throw new IllegalStateException("expected: a single logback context");
	}
	
	return new LogbackContext(client, LOGBACK_PATH + ":" + logbacks.keySet().iterator().next());
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
@Test
public void testReadData() throws Exception {
	J4pClient j4pClient = new J4pClient("http://localhost:8080/jolokia-war-1.1.3");
	// J4pReadRequest req = new
	// J4pReadRequest("jboss.system:type=ServerInfo","ActiveThreadCount",
	// "ActiveThreadGroupCount", "MaxMemory", "HostName",
	// "TotalMemory","FreeMemory");
	List<String> attributes = Arrays.asList(new String[] { "Status" });
	//
	// J4pReadRequest req = new
	// J4pReadRequest("jboss.ws:context=*,endpoint=*",
	// attributes.toArray(new String[]{}));

	try {
		J4pReadRequest req = new J4pReadRequest("af-probe:probe=*", attributes.toArray(new String[] {}));
		
		J4pReadResponse resp = j4pClient.execute(req);
		System.out.println(resp.getValue());

		for (ObjectName o : resp.getObjectNames()) {
			for (String attrib : attributes) {
				try {
					Object v = resp.getValue(o, attrib);
					System.out.println(o.getDomain() + " " + o.getCanonicalName() + " " + attrib + "=" + v);
				} catch (Exception ignore) {
				}
			}
		}
	} catch (Exception e) {
		System.out.println(e);
	}

}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
@Override
public void using(J4pClient client) {
    this.jolokia = client;
    this.url = null;
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
@Override
protected void startFilter() {
    //
    // Non-rules based modifiers
    //
    m_actions.clear();
    Modifier defModifier = Modifier.create(DEFAULT_MODIFIER, variables(), config());
    if (!defModifier.isEmpty()) {
        m_actions.put(DEFAULT_MODIFIER, defModifier);
    }
    //
    // Jolokia URL(s)
    //
    JsonArray urls = config().getArray(CONF_KEY_JOLOKIA_URLS, new JsonArray());
    for (int i = 0; i < urls.size(); i++) {
        String url = urls.get(i).toString();
        logger().info("Connecting to: {}", url);
        m_clients.add(J4pClient.url(url)
                .user(config().getString(CONF_KEY_USER_NAME))
                .password(config().getString(CONF_KEY_USER_PASSWORD))
                .authenticator(new BasicAuthenticator(config().getBoolean(CONF_KEY_AUTH_PREEMPTIVE, DEF_AUTH_PREEMPTIVE)))
                .build());
    }
    //
    // Build requests
    //
    m_config = new RequestConfig();
    JsonArray requests = config().getArray(CONF_KEY_REQUESTS, new JsonArray());
    for (int i = 0; i < requests.size(); i++) {

        JsonObject request = requests.get(i);
        String mbean = request.getString(CONF_KEY_MBEAN);
        List<String> attributes
                = (List<String>) request.getArray(CONF_KEY_ATTRIBUTES, new JsonArray()).toList();

        // Dstypes
        Map<String, Object> types = request.getObject(CONF_KEY_DSTYPES, new JsonObject()).toMap();
        m_config.setDstypes(mbean, types);

        String path = request.getString(CONF_KEY_PATH, "");
        int len = attributes.size();
        if (!Strings.isNullOrEmpty(mbean)
                && len > 0) {

            try {
                String[] attrs = attributes.toArray(new String[len]);
                logger().debug("Request mbean: {} attributes: {}", mbean, attrs);
                J4pReadRequest readRequest = new J4pReadRequest(mbean, attrs);

                if (!Strings.isNullOrEmpty(path)) {
                    logger().debug("Request path: {}", path);
                    readRequest.setPath(path);
                }

                m_config.addRequest(readRequest);

            } catch (MalformedObjectNameException e) {
                logger().error("Failed to build Jolokia request: {}:{}:{}",
                        mbean, attributes, path, e);
            }
        }
    }

    m_fetchJavaLangMbeanMetadata = config().getBoolean(
            CONF_KEY_FETCH_JAVA_LANG_MBEAN_METADATA,
            DEF_FETCH_JAVA_LANG_MBEAN_METADATA);

    if (m_fetchJavaLangMbeanMetadata) {
        logger().debug("Fetching metadata of {} (JBoss 4.x/5.x bug circumvention)",
                MBEAN_JAVA_LANG_MEMORY);
    }
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
public J4pClient createClient() {
    J4pAuthenticator authenticator;

    ConnectionData cnData = endpoint.getConnectionData();
    SSLContext sslContext = endpoint.getSSLContext();

    SSLConnectionSocketFactory sslFactory;

    boolean useBearerAuth = false;
    if (cnData.getUsername() != null) {
        if (cnData.getUsername().equalsIgnoreCase(BEARER_TOKEN_USER_ID)) {
            if (cnData.getPassword() == null) {
                throw new IllegalStateException("Bearer token is missing. Must be specified as the password");
            }
            useBearerAuth = true;
        }
    }

    if (sslContext != null && cnData.getUri().getScheme().equalsIgnoreCase("https")) {
        sslFactory = new SSLConnectionSocketFactory(sslContext);
        if (useBearerAuth) {
            authenticator = new SecureBearerAuthenticator(sslContext);
        } else {
            authenticator = new SecureBasicAuthenticator(sslContext).preemptive();
        }
    } else {
        sslFactory = null;
        if (useBearerAuth) {
            authenticator = new BearerAuthenticator();
        } else {
            authenticator = new BasicAuthenticator().preemptive();
        }
    }

    J4pClient client = J4pClient
            .url(cnData.getUri().toString())
            .user(cnData.getUsername())
            .password(cnData.getPassword())
            .authenticator(authenticator)
            .connectionTimeout(60000)
            .sslConnectionSocketFactory(sslFactory)
            .build();
    return client;
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
public J4pClient getClient() {
    return client;
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
private MXBeanInvocationHandler(String serviceURL, ObjectName objectName) {
    this.client = new J4pClient(serviceURL);
    this.objectName = objectName;
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
protected ObjectName getFrameworkMBeanName(J4pClient client) throws Exception {
    J4pSearchRequest searchReq = new J4pSearchRequest(FrameworkMBean.OBJECTNAME + ",*");
    J4pResponse<J4pSearchRequest> searchRes = client.execute(searchReq);
    Object firstItem = ((JSONArray) searchRes.getValue()).get(0);
    return ObjectNameFactory.create((String) firstItem);
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
public LogbackContext(J4pClient client, String objectName) {
	this.client = Objects.requireNonNull(client, "client should not be null");
	this.objectName = Objects.requireNonNull(objectName, "objectName should not be null"); 
}
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
/**
 * To use the existing {@link org.jolokia.client.J4pClient} with this controller.
 *
 * @param client the client to use
 */
void using(J4pClient client);
 

import org.jolokia.client.J4pClient; //导入依赖的package包/类
/**
 * Creates the JMX driver.
 *
 * @param diagnostics
 * @param client the client used to connect to the JMX MBeanServer
 */
public JolokiaJMXDriver(ProtocolDiagnostics diagnostics, J4pClient client) {
    super(diagnostics);
    this.client = client;
}