Java tutorial
/* * Copyright 2007-2012 the original author or authors. * * 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. */ package org.springbyexample.httpclient; import java.util.ArrayList; import java.util.List; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.HttpConnectionManager; import org.apache.commons.httpclient.HttpMethod; import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager; import org.apache.commons.httpclient.NameValuePair; import org.apache.commons.httpclient.UsernamePasswordCredentials; import org.apache.commons.httpclient.auth.AuthScope; import org.apache.commons.httpclient.methods.GetMethod; import org.apache.commons.httpclient.methods.PostMethod; import org.springbyexample.httpclient.auth.Credentials; import org.springbyexample.httpclient.auth.NTCredentials; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.util.Assert; /** * Base <code>HttpClient</code> template class. * * @author David Winterfeldt */ public abstract class AbstractHttpClientTemplate<T> implements InitializingBean, DisposableBean { protected HttpClient client = null; protected HttpConnectionManager connectionManager = null; protected String defaultUri = null; protected boolean authenticationPreemptive = false; protected List<Credentials> lCredentials = new ArrayList<Credentials>(); /** * Constructor. */ public AbstractHttpClientTemplate() { } /** * Constructor. * * @param defaultUri Default uri. */ public AbstractHttpClientTemplate(String defaultUri) { this(defaultUri, false); } /** * Constructor. * * @param defaultUri Default uri. * @param init Whether or not to initialize the bean * (typically for programatic use). */ public AbstractHttpClientTemplate(String defaultUri, boolean init) { this.defaultUri = defaultUri; if (init) { try { afterPropertiesSet(); } catch (Exception e) { throw new HttpAccessException(e.getMessage(), e); } } } /** * Gets http client. */ public HttpClient getClient() { return client; } /** * Sets http client. */ public void setClient(HttpClient client) { this.client = client; } /** * Gets connection manager. */ public HttpConnectionManager getConnectionManager() { return connectionManager; } /** * Sets connection manager. */ public void setConnectionManager(HttpConnectionManager connectionManager) { this.connectionManager = connectionManager; } /** * Gets default uri. */ public String getDefaultUri() { return defaultUri; } /** * Sets default uri. */ public void setDefaultUri(String defaultUri) { this.defaultUri = defaultUri; } /** * Whether or not authentication is preemptive. * If <code>true</code>, authentication credentials * will be sent before a challenge is issued * for an authentication scope with credentials. * Defaults to <code>false</code>. */ public boolean isAuthenticationPreemptive() { return authenticationPreemptive; } /** * Sets whether or not authentication is preemptive. * If <code>true</code>, authentication credentials * will be sent before a challenge is issued * for an authentication scope with credentials. * Defaults to <code>false</code>. */ public void setAuthenticationPreemptive(boolean authenticationPreemptive) { this.authenticationPreemptive = authenticationPreemptive; } /** * Gets HTTP authorization credentials. */ public List<Credentials> getCredentials() { return lCredentials; } /** * Sets HTTP authorization credentials. */ public void setCredentials(List<Credentials> credentials) { this.lCredentials = credentials; } /** * Implementation of <code>InitializingBean</code> * that initializes the <code>HttpClient</code> if it is <code>null</code> * and also sets the connection manager to <code>MultiThreadedHttpConnectionManager</code> * if it is <code>null</code> while initializing the <code>HttpClient</code>. */ public void afterPropertiesSet() throws Exception { // make sure credentials are properly set for (Credentials credentials : lCredentials) { Assert.notNull(credentials.getAuthScopeHost()); Assert.isTrue(credentials.getAuthScopePort() > 0); Assert.notNull(credentials.getUserName()); Assert.notNull(credentials.getPassword()); if (credentials instanceof NTCredentials) { Assert.notNull(((NTCredentials) credentials).getHost()); Assert.notNull(((NTCredentials) credentials).getDomain()); } } if (client == null) { if (connectionManager == null) { connectionManager = new MultiThreadedHttpConnectionManager(); } client = new HttpClient(connectionManager); } client.getParams().setAuthenticationPreemptive(authenticationPreemptive); for (Credentials credentials : lCredentials) { AuthScope authScope = new AuthScope(credentials.getAuthScopeHost(), credentials.getAuthScopePort(), AuthScope.ANY_REALM); org.apache.commons.httpclient.Credentials httpCredentials = null; if (credentials instanceof NTCredentials) { httpCredentials = new org.apache.commons.httpclient.NTCredentials(credentials.getUserName(), credentials.getPassword(), ((NTCredentials) credentials).getHost(), ((NTCredentials) credentials).getDomain()); } else { httpCredentials = new UsernamePasswordCredentials(credentials.getUserName(), credentials.getPassword()); } client.getState().setCredentials(authScope, httpCredentials); } } /** * Implementation of <code>DisposableBean</code> that * shuts down the connection manager if it is an instance of * <code>MultiThreadedHttpConnectionManager</code>. */ public void destroy() throws Exception { if (client.getHttpConnectionManager() instanceof MultiThreadedHttpConnectionManager) { ((MultiThreadedHttpConnectionManager) client.getHttpConnectionManager()).shutdown(); } } /** * Execute get method. */ public void executeGetMethod() { executeGetMethod(defaultUri, null, null); } /** * Execute get method. * * @param callback Callback with HTTP method's response. */ public void executeGetMethod(ResponseCallback<?> callback) { executeGetMethod(defaultUri, null, callback); } /** * Execute get method. * * @param hParams Parameters for the HTTP get. */ public void executeGetMethod(Map<String, String> hParams) { executeGetMethod(defaultUri, hParams, null); } /** * Execute get method. * * @param hParams Parameters for the HTTP get. * @param callback Callback with HTTP method's response. */ public void executeGetMethod(Map<String, String> hParams, ResponseCallback<?> callback) { executeGetMethod(defaultUri, hParams, callback); } /** * Execute get method. * * @param uri URI to use when processing this HTTP request instead * of using the default URI. * @param hParams Parameters for the HTTP get. */ public void executeGetMethod(String uri, Map<String, String> hParams) { executeGetMethod(uri, hParams, null); } /** * Execute get method. * * @param uri URI to use when processing this HTTP request instead * of using the default URI. * @param hParams Parameters for the HTTP get. * @param callback Callback with HTTP method's response. */ public void executeGetMethod(String uri, Map<String, String> hParams, ResponseCallback<?> callback) { GetMethod get = new GetMethod(uri); processHttpMethodParams(get, hParams); processHttpMethod(get, callback); } /** * Execute post method. */ public void executePostMethod() { executePostMethod(defaultUri, null, null, null); } /** * Execute post method. * * @param callback Callback with HTTP method's response. */ public void executePostMethod(ResponseCallback<?> callback) { executePostMethod(defaultUri, null, null, callback); } /** * Execute post method. * * @param hParams Parameters for the HTTP post. */ public void executePostMethod(Map<String, String> hParams) { executePostMethod(defaultUri, null, hParams, null); } /** * Execute post method. * * @param hParams Parameters for the HTTP post. * @param callback Callback with HTTP method's response. */ public void executePostMethod(Map<String, String> hParams, ResponseCallback<?> callback) { executePostMethod(defaultUri, null, hParams, callback); } /** * Execute post method. * * @param uri URI to use when processing this HTTP request instead * of using the default URI. * @param requestPayload Request data to post. * @param hParams Parameters for the HTTP post. */ public void executePostMethod(String uri, T requestPayload, Map<String, String> hParams) { executePostMethod(uri, requestPayload, hParams, null); } /** * Execute post method. * * @param uri URI to use when processing this HTTP request instead * of using the default URI. * @param requestPayload Request data to post. * @param hParams Parameters for the HTTP post. * @param callback Callback with HTTP method's response. */ public abstract void executePostMethod(String uri, T requestPayload, Map<String, String> hParams, ResponseCallback<?> callback); /** * Processes <code>HttpMethod</code> by executing the method, * validating the response, and calling the callback. * * @param httpMethod <code>HttpMethod</code> to process. * @param callback Callback with HTTP method's response. */ protected abstract void processHttpMethod(HttpMethod httpMethod, ResponseCallback<?> callback); /** * Processes <code>HttpMethod</code> parameters. * * @param httpMethod <code>HttpMethod</code> to process. * @param hParams Parameters for the HTTP get. */ protected void processHttpMethodParams(HttpMethod httpMethod, Map<String, String> hParams) { if (hParams != null) { List<NameValuePair> lParams = new ArrayList<NameValuePair>(); for (Object key : hParams.keySet()) { Object value = hParams.get(key); lParams.add(new NameValuePair(key.toString(), value.toString())); } if (httpMethod instanceof GetMethod) { ((GetMethod) httpMethod).setQueryString(lParams.toArray(new NameValuePair[] {})); } else if (httpMethod instanceof PostMethod) { ((PostMethod) httpMethod).setRequestBody(lParams.toArray(new NameValuePair[] {})); } } } /** * Validate response. * * @param httpMethod <code>HttpMethod</code> to validate. */ protected void validateResponse(HttpMethod httpMethod) { if (httpMethod.getStatusCode() >= 300) { throw new HttpAccessException( "Did not receive successful HTTP response: status code = " + httpMethod.getStatusCode() + ", status message = [" + httpMethod.getStatusText() + "]", httpMethod.getStatusCode()); } } }