Java J4pReadRequest类代码示例

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
@Override
public List<Map<String, String>> getCamelContexts() throws Exception {
    if (jolokia == null) {
        throw new IllegalStateException("Need to connect to remote jolokia first");
    }

    List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

    J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest("*:type=context,*"));

    List<J4pReadRequest> list = new ArrayList<J4pReadRequest>();
    for (ObjectName on : sr.getObjectNames()) {
        list.add(new J4pReadRequest(on, "CamelId", "State", "Uptime", "ExchangesTotal", "ExchangesInflight", "ExchangesFailed"));
    }

    List<J4pReadResponse> lrr = jolokia.execute(list);
    for (J4pReadResponse rr : lrr) {
        Map<String, String> row = new LinkedHashMap<String, String>();
        row.put("name", rr.getValue("CamelId").toString());
        row.put("state", rr.getValue("State").toString());
        row.put("uptime", rr.getValue("Uptime").toString());
        row.put("exchangesTotal", rr.getValue("ExchangesTotal").toString());
        row.put("exchangesInflight", rr.getValue("ExchangesInflight").toString());
        row.put("exchangesFailed", rr.getValue("ExchangesFailed").toString());
        answer.add(row);
    }

    return answer;
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
@Override
public List<Map<String, String>> getEndpoints(String camelContextName) throws Exception {
    if (jolokia == null) {
        throw new IllegalStateException("Need to connect to remote jolokia first");
    }

    List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

    ObjectName found = lookupCamelContext(camelContextName);
    if (found != null) {
        String pattern = String.format("%s:context=%s,type=endpoints,*", found.getDomain(), found.getKeyProperty("context"));
        J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest(pattern));

        List<J4pReadRequest> list = new ArrayList<J4pReadRequest>();
        for (ObjectName on : sr.getObjectNames()) {
            list.add(new J4pReadRequest(on, "CamelId", "EndpointUri", "State"));
        }

        List<J4pReadResponse> lrr = jolokia.execute(list);
        for (J4pReadResponse rr : lrr) {
            Map<String, String> row = new LinkedHashMap<String, String>();
            row.put("camelContextName", rr.getValue("CamelId").toString());
            row.put("uri", rr.getValue("EndpointUri").toString());
            row.put("state", rr.getValue("State").toString());
            answer.add(row);
        }
    }

    return answer;
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
@Override
public Object fetchAttribute(AttributeLocation<JMXNodeLocation> location) throws ProtocolException {

    try {
        String[] attribute = location.getAttribute().split("#", 2);
        J4pReadRequest request = new J4pReadRequest(location.getLocation().getObjectName(), attribute[0]);
        if (attribute.length > 1) {
            request.setPath(attribute[1]); // this is the sub-reference
        }

        J4pReadResponse response;
        try (Context timerContext = getDiagnostics().getRequestTimer().time()) {
            response = client.execute(request);
        }
        Collection<ObjectName> responseObjectNames = response.getObjectNames();
        switch (responseObjectNames.size()) {
            case 0:
                return null;
            case 1:
                return response.getValue();
            default:
                List<Object> results = new ArrayList<>(responseObjectNames.size());
                for (ObjectName responseObjectName : responseObjectNames) {
                    Object value = response.getValue(responseObjectName, location.getAttribute());
                    results.add(value);
                }
                return Collections.unmodifiableList(results);
        }
    } catch (Exception e) {
        getDiagnostics().getErrorRate().mark(1);
        throw new ProtocolException(e);
    }
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
@Override
public Object extractValue(Iterator<J4pResponse<J4pReadRequest>> iterator) {
    if (!iterator.hasNext())
        throw new IllegalStateException();
    final JSONObject o = (JSONObject) iterator.next().getValue();
    return o.get(getPropertyName());
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
private List<J4pReadRequest> getRequests() throws MalformedObjectNameException {
    final List<J4pReadRequest> answer = new ArrayList<>(attributes.size());
    for (JmxAttribute a : attributes) {
        answer.add(a.createRequest());
    }
    return answer;
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
private Iterable<?> toValues(List<J4pResponse<J4pReadRequest>> responses) {
    final ArrayList<Object> answer = new ArrayList<>(responses.size());
    final Iterator<J4pResponse<J4pReadRequest>> iterator = responses.iterator();
    for (JmxAttribute a : attributes) {
        answer.add(a.extractValue(iterator));
    }
    return answer;
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
public List<String> getLoggerList() {
	try {
		return client.execute(new J4pReadRequest(objectName, "LoggerList")).getValue();
	} catch(Exception e) {
		throw new RuntimeException(e);
	}
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的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.request.J4pReadRequest; //导入依赖的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.request.J4pReadRequest; //导入依赖的package包/类
private List<J4pReadRequest> getRequests() {
    return m_requests;
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
private void addRequest(final J4pReadRequest request) {
    m_requests.add(request);
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
public J4pReadRequest createRequest() throws MalformedObjectNameException {
    return new J4pReadRequest(getBeanPath(), getAttributeName());
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
public Object extractValue(Iterator<J4pResponse<J4pReadRequest>> iterator) {
    if (!iterator.hasNext())
        throw new IllegalStateException();
    return iterator.next().getValue();
}
 

import org.jolokia.client.request.J4pReadRequest; //导入依赖的package包/类
private Iterable<?> fetchData() throws MalformedObjectNameException, J4pException {
    final List<J4pReadRequest> requests = getRequests();
    final List<J4pResponse<J4pReadRequest>> response = client.execute(requests);
    return toValues(response);
}