Java tutorial
package org.jolokia.client; /* * Copyright 2009-2013 Roland Huss * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import java.io.IOException; import java.net.*; import java.util.*; import org.apache.http.*; import org.apache.http.client.HttpClient; import org.apache.http.conn.ConnectTimeoutException; import org.jolokia.client.exception.*; import org.jolokia.client.request.*; import org.json.simple.*; import org.json.simple.parser.ParseException; /** * Client class for accessing the j4p agent * * @author roland * @since Apr 24, 2010 */ public class J4pClient extends J4pClientBuilderFactory { // Http client used for connecting the j4p Agent private HttpClient httpClient; // Creating and parsing HTTP-Requests and Responses private J4pRequestHandler requestHandler; // Extractor used for creating J4pResponses private J4pResponseExtractor responseExtractor; /** * Construct a new client for a given server url * * @param pJ4pServerUrl the agent URL for how to contact the server. */ public J4pClient(String pJ4pServerUrl) { this(pJ4pServerUrl, null); } /** * Constructor for a given agent URl and a given HttpClient * * @param pJ4pServerUrl the agent URL for how to contact the server. * @param pHttpClient HTTP client to use for the connecting to the agent */ public J4pClient(String pJ4pServerUrl, HttpClient pHttpClient) { this(pJ4pServerUrl, pHttpClient, null); } /** * Constructor using a given Agent URL, HttpClient and a proxy target config. If the HttpClient is null, * a default client is used. If no target config is given, a plain request is performed * * @param pJ4pServerUrl the agent URL for how to contact the server. * @param pHttpClient HTTP client to use for the connecting to the agent * @param pTargetConfig optional target */ public J4pClient(String pJ4pServerUrl, HttpClient pHttpClient, J4pTargetConfig pTargetConfig) { this(pJ4pServerUrl, pHttpClient, pTargetConfig, ValidatingResponseExtractor.DEFAULT); } /** * Constructor using a given Agent URL, HttpClient and a proxy target config. If the HttpClient is null, * a default client is used. If no target config is given, a plain request is performed * * @param pJ4pServerUrl the agent URL for how to contact the server. * @param pHttpClient HTTP client to use for the connecting to the agent * @param pTargetConfig optional target * @param pExtractor response extractor to use */ public J4pClient(String pJ4pServerUrl, HttpClient pHttpClient, J4pTargetConfig pTargetConfig, J4pResponseExtractor pExtractor) { requestHandler = new J4pRequestHandler(pJ4pServerUrl, pTargetConfig); responseExtractor = pExtractor; // Using the default as defined in the client builder if (pHttpClient != null) { httpClient = pHttpClient; } else { J4pClientBuilder builder = new J4pClientBuilder(); httpClient = builder.createHttpClient(); } } // ============================================================================================= /** * Execute a single J4pRequest returning a single response. * The HTTP Method used is determined automatically. * * @param pRequest request to execute * @param <RESP> response type * @param <REQ> request type * @return the response as returned by the server */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> RESP execute(REQ pRequest) throws J4pException { // type spec is required to keep OpenJDK 1.6 happy (other JVM dont have a problem // with infering the type is missing here) return this.<RESP, REQ>execute(pRequest, null, null); } /** * Execute a single J4pRequest returning a single response. * The HTTP Method used is determined automatically. * * @param pRequest request to execute * @param pProcessingOptions optional map of processing options * @param <RESP> response type * @param <REQ> request type * @return the response as returned by the server * @throws java.io.IOException when the execution fails * @throws org.json.simple.parser.ParseException if parsing of the JSON answer fails */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> RESP execute(REQ pRequest, Map<J4pQueryParameter, String> pProcessingOptions) throws J4pException { return this.<RESP, REQ>execute(pRequest, null, pProcessingOptions); } /** * Execute a single J4pRequest which returns a single response. * * @param pRequest request to execute * @param pMethod method to use which should be either "GET" or "POST" * * @param <RESP> response type * @param <REQ> request type * @return response object * @throws J4pException if something's wrong (e.g. connection failed or read timeout) */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> RESP execute(REQ pRequest, String pMethod) throws J4pException { return this.<RESP, REQ>execute(pRequest, pMethod, null); } /** * Execute a single J4pRequest which returns a single response. * * @param pRequest request to execute * @param pMethod method to use which should be either "GET" or "POST" * @param pProcessingOptions optional map of processing options * * @param <RESP> response type * @param <REQ> request type * @return response object * @throws J4pException if something's wrong (e.g. connection failed or read timeout) */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> RESP execute(REQ pRequest, String pMethod, Map<J4pQueryParameter, String> pProcessingOptions) throws J4pException { return this.<RESP, REQ>execute(pRequest, pMethod, pProcessingOptions, responseExtractor); } /** * Execute a single J4pRequest which returns a single response. * * @param pRequest request to execute * @param pMethod method to use which should be either "GET" or "POST" * @param pProcessingOptions optional map of processing options * @param pExtractor extractor for actually creating the response * * @param <RESP> response type * @param <REQ> request type * @return response object * @throws J4pException if something's wrong (e.g. connection failed or read timeout) */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> RESP execute(REQ pRequest, String pMethod, Map<J4pQueryParameter, String> pProcessingOptions, J4pResponseExtractor pExtractor) throws J4pException { try { HttpResponse response = httpClient .execute(requestHandler.getHttpRequest(pRequest, pMethod, pProcessingOptions)); JSONAware jsonResponse = extractJsonResponse(pRequest, response); if (!(jsonResponse instanceof JSONObject)) { throw new J4pException("Invalid JSON answer for a single request (expected a map but got a " + jsonResponse.getClass() + ")"); } return pExtractor.extract(pRequest, (JSONObject) jsonResponse); } catch (IOException e) { throw mapException(e); } catch (URISyntaxException e) { throw mapException(e); } } /** * Execute multiple requests at once. All given request will result in a single HTTP request where it gets * dispatched on the agent side. The results are given back in the same order as the arguments provided. * * @param pRequests requests to execute * @param <RESP> response type * @param <REQ> request type * @return list of responses, one response for each request * @throws J4pException when an communication error occurs */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> List<RESP> execute(List<REQ> pRequests) throws J4pException { return this.<RESP, REQ>execute(pRequests, null); } /** * Execute multiple requests at once. All given request will result in a single HTTP request where it gets * dispatched on the agent side. The results are given back in the same order as the arguments provided. * * @param pRequests requests to execute * @param pProcessingOptions processing options to use * @param <RESP> response type * @param <REQ> request type * @return list of responses, one response for each request * @throws J4pException when an communication error occurs */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> List<RESP> execute(List<REQ> pRequests, Map<J4pQueryParameter, String> pProcessingOptions) throws J4pException { return execute(pRequests, pProcessingOptions, responseExtractor); } /** * Execute multiple requests at once. All given request will result in a single HTTP request where it gets * dispatched on the agent side. The results are given back in the same order as the arguments provided. * * @param pRequests requests to execute * @param pProcessingOptions processing options to use * @param pResponseExtractor use this for custom extraction handling * @param <RESP> response type * @param <REQ> request type * @return list of responses, one response for each request * @throws J4pException when an communication error occurs */ public <RESP extends J4pResponse<REQ>, REQ extends J4pRequest> List<RESP> execute(List<REQ> pRequests, Map<J4pQueryParameter, String> pProcessingOptions, J4pResponseExtractor pResponseExtractor) throws J4pException { try { HttpResponse response = httpClient .execute(requestHandler.getHttpRequest(pRequests, pProcessingOptions)); JSONAware jsonResponse = extractJsonResponse(null, response); verifyBulkJsonResponse(jsonResponse); return this.<RESP, REQ>extractResponses(jsonResponse, pRequests, pResponseExtractor); } catch (IOException e) { throw mapException(e); } catch (URISyntaxException e) { throw mapException(e); } } // ===================================================================================================== @SuppressWarnings("PMD.PreserveStackTrace") private <REQ extends J4pRequest> JSONAware extractJsonResponse(REQ pRequest, HttpResponse pResponse) throws J4pException { try { return requestHandler.extractJsonResponse(pResponse); } catch (IOException e) { throw new J4pException("IO-Error while reading the response: " + e, e); } catch (ParseException e) { // It's a parse exception. Now, check whether the HTTResponse is // an error and prepare the proper J4pException StatusLine statusLine = pResponse.getStatusLine(); if (HttpStatus.SC_OK != statusLine.getStatusCode()) { throw new J4pRemoteException(pRequest, statusLine.getReasonPhrase(), null, statusLine.getStatusCode(), null, null); } throw new J4pException("Could not parse answer: " + e, e); } } // Extract J4pResponses from a returned bulk JSON answer private <R extends J4pResponse<T>, T extends J4pRequest> List<R> extractResponses(JSONAware pJsonResponse, List<T> pRequests, J4pResponseExtractor pResponseExtractor) throws J4pException { JSONArray responseArray = (JSONArray) pJsonResponse; List<R> ret = new ArrayList<R>(responseArray.size()); J4pRemoteException remoteExceptions[] = new J4pRemoteException[responseArray.size()]; boolean exceptionFound = false; for (int i = 0; i < pRequests.size(); i++) { T request = pRequests.get(i); Object jsonResp = responseArray.get(i); if (!(jsonResp instanceof JSONObject)) { throw new J4pException("Response for request Nr. " + i + " is invalid (expected a map but got " + jsonResp.getClass() + ")"); } try { ret.add(i, pResponseExtractor.<R, T>extract(request, (JSONObject) jsonResp)); } catch (J4pRemoteException exp) { remoteExceptions[i] = exp; exceptionFound = true; ret.add(i, null); } } if (exceptionFound) { List partialResults = new ArrayList(); // Merge partial results and exceptions in a single list for (int i = 0; i < pRequests.size(); i++) { J4pRemoteException exp = remoteExceptions[i]; if (exp != null) { partialResults.add(exp); } else { partialResults.add(ret.get(i)); } } throw new J4pBulkRemoteException(partialResults); } return ret; } // Map IO-Exceptions accordingly private J4pException mapException(Exception pException) throws J4pException { if (pException instanceof ConnectException) { return new J4pConnectException( "Cannot connect to " + requestHandler.getJ4pServerUrl() + ": " + pException.getMessage(), (ConnectException) pException); } else if (pException instanceof ConnectTimeoutException) { return new J4pTimeoutException("Read timeout while request " + requestHandler.getJ4pServerUrl() + ": " + pException.getMessage(), (ConnectTimeoutException) pException); } else if (pException instanceof IOException) { return new J4pException("IO-Error while contacting the server: " + pException, pException); } else if (pException instanceof URISyntaxException) { URISyntaxException sExp = (URISyntaxException) pException; return new J4pException("Invalid URI " + sExp.getInput() + ": " + sExp.getReason(), pException); } else { return new J4pException("Exception " + pException, pException); } } // Verify the returned JSON answer. private void verifyBulkJsonResponse(JSONAware pJsonResponse) throws J4pException { if (!(pJsonResponse instanceof JSONArray)) { if (pJsonResponse instanceof JSONObject) { JSONObject errorObject = (JSONObject) pJsonResponse; if (!errorObject.containsKey("status") || (Long) errorObject.get("status") != 200) { throw new J4pRemoteException(null, errorObject); } } throw new J4pException("Invalid JSON answer for a bulk request (expected an array but got a " + pJsonResponse.getClass() + ")"); } } /** * Execute multiple requests at once. All given request will result in a single HTTP request where it gets * dispatched on the agent side. The results are given back in the same order as the arguments provided. * * @param pRequests requests to execute * @param <R> response typex * @param <T> request type * @return list of responses, one response for each request * @throws J4pException when an communication error occurs */ public <R extends J4pResponse<T>, T extends J4pRequest> List<R> execute(T... pRequests) throws J4pException { return this.<R, T>execute(Arrays.asList(pRequests)); } /** * Expose the embedded {@link org.apache.http.client.HttpClient} for tuning connection parameters. * * @return the http client used for HTTP communications */ public HttpClient getHttpClient() { return httpClient; } /** * Get base URL for Jolokia requests * * @return the Jolokia URL */ public URI getUri() { return requestHandler.getJ4pServerUrl(); } }