Java HttpMethod.releaseConnection方法代码示例

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
@Override
public HttpResponse get(URL urlObj, String userName, String password, int timeout) {
  HttpClient client = new HttpClient();
  HttpMethod method = new GetMethod(urlObj.toString());

  client.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
      new DefaultHttpMethodRetryHandler());
  client.getParams().setSoTimeout(1000 * timeout);
  client.getParams().setConnectionManagerTimeout(1000 * timeout);
  if (userName != null && password != null) {
    setBasicAuthorization(method, userName, password);
  }
  try {
    int response = client.executeMethod(method);
    return new HttpResponse(response, method.getResponseBody());
  } catch (IOException e) {
    throw new RuntimeException("Failed to get " + urlObj.toString(), e);
  } finally {
    method.releaseConnection();
  }
}
 

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
public List<DataPoint> getData ( final String item, final String type, final Date from, final Date to, final Integer number ) throws Exception
{
    final HttpClient client = new HttpClient ();
    final HttpMethod method = new GetMethod ( this.baseUrl + "/" + URLEncoder.encode ( item, "UTF-8" ) + "/" + URLEncoder.encode ( type, "UTF-8" ) + "?from=" + URLEncoder.encode ( Utils.isoDateFormat.format ( from ), "UTF-8" ) + "&to=" + URLEncoder.encode ( Utils.isoDateFormat.format ( to ), "UTF-8" ) + "&no=" + number );
    client.getParams ().setSoTimeout ( (int)this.timeout );
    try
    {
        final int status = client.executeMethod ( method );
        if ( status != HttpStatus.SC_OK )
        {
            throw new RuntimeException ( "Method failed with error " + status + " " + method.getStatusLine () );
        }
        return Utils.fromJson ( method.getResponseBodyAsString () );
    }
    finally
    {
        method.releaseConnection ();
    }
}
 

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
/**
 * Method uses given method parameter to connect to the server and tries to download.<br />
 * Method updates download state of HttpFile automatically - sets <code>DownloadState.GETTING</code> and then <code>DownloadState.DOWNLOADING</code>
 *
 * @param method HttpMethod - its URL should be a link to the file
 * @return true if file was successfully downloaded, false otherwise - file was not found, only string content is available
 * @throws Exception when connection/writing to file failed
 */
protected boolean tryDownloadAndSaveFile(HttpMethod method) throws Exception {
    if (httpFile.getState() == DownloadState.PAUSED || httpFile.getState() == DownloadState.CANCELLED)
        return false;
    else
        httpFile.setState(DownloadState.GETTING);
    if (logger.isLoggable(Level.INFO)) {
        logger.info("Download link URI: " + method.getURI().toString());
        logger.info("Making final request for file");
    }

    try {
        final InputStream inputStream = client.makeFinalRequestForFile(method, httpFile, true);
        if (inputStream != null) {
            logger.info("Saving to file");
            downloadTask.saveToFile(inputStream);
            return true;
        } else {
            logger.info("Saving file failed");
            return false;
        }
    } finally {
        method.abort();
        method.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
public <T extends Object> T executeHttpMethodUnauthenticated(HttpMethod method, HttpRequestCallback<T> callback)
{
    try
    {
        // Try executing the method
        httpProvider.getHttpClient().executeMethod(null, method);
        if (callback != null)
        {
            return callback.onCallSuccess(method);
        }
        return null;
    }
    catch (Throwable t)
    {
        boolean handled = false;
        // Delegate to callback to handle error. If not available, throw exception
        if (callback != null)
        {
            handled = callback.onError(method, t);
        }

        if (!handled)
        {
            throw new RuntimeException("Error while executing an un-authenticated HTTP-call (" + method.getPath() + ")", t);
        }
        return null;

    }
    finally
    {
        method.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
void sendThankYouRequest(CoalesceThankYouNotesKey key)
{
    boolean success = false;
    List requestList = this.removeRequestList(key);
    if (done || requestList == null)
    {
        return;
    }
    HttpMethod streamedPostMethod = null;
    try
    {
        if (LOGGER.isDebugEnabled())
        {
            LOGGER.debug("Sending thank you for {}", requestList.size());
        }
        AuthenticatedUrl url = key.getAuthenticatedUrl();
        HttpClient httpClient = FastServletProxyFactory.getHttpClient(url);
        httpClient.getState().addCookies(key.getCookies());
        OutputStreamWriter writer = new ThankYouStreamWriter(requestList);
        streamedPostMethod = FastServletProxyFactory.serverSupportsChunking(url) ? new StreamedPostMethod(url.getPath() + "?thanks", writer) : new BufferedPostMethod(url.getPath() + "?thanks", writer);
        httpClient.executeMethod(streamedPostMethod);

        int code = streamedPostMethod.getStatusCode();

        streamedPostMethod.getResponseBodyAsStream().close();
        streamedPostMethod.releaseConnection();
        streamedPostMethod = null;
        success = code == 200;
    }
    catch (Exception e)
    {
        LOGGER.warn("Exception in JRPIP thank you note for URL: {} Retrying.", key.toString(), e);
    }
    finally
    {
        if (streamedPostMethod != null)
        {
            streamedPostMethod.releaseConnection();
        }
    }
    if (!success)
    {
        this.readList(key, requestList);
    }
}
 

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
/**
 * Execute the given method, authenticated as the given user using Basic Authentication.
 * @param method method to execute
 * @param userName name of user to authenticate (note: if null then attempts to run with no authentication - eq. Quick/Shared Link test)
 * @param callback called after http-call is executed. When callback returns, the 
 *  response stream is closed, so all respose-related operations should be done in the callback. Can be null.
 * @return result returned by the callback or null if no callback is given.
 */
private <T extends Object> T executeWithBasicAuthentication(HttpMethod method, String userName, String password, HttpRequestCallback<T> callback)
{
    try
    {
        HttpState state = new HttpState();

        if (userName != null)
        {
            state.setCredentials(
                    new AuthScope(null, AuthScope.ANY_PORT),
                    new UsernamePasswordCredentials(userName, password));
        }
        
        httpProvider.getHttpClient().executeMethod(null, method, state);
        
        if(callback != null)
        {
            return callback.onCallSuccess(method);
        }
        
        // No callback used, return null
        return null;
    }
    catch(Throwable t)
    {
        boolean handled = false;
        
        // Delegate to callback to handle error. If not available, throw exception
        if(callback != null)
        {
            handled = callback.onError(method, t);
        }
        
        if(!handled)
        {
            throw new RuntimeException("Error while executing HTTP-call (" + method.getPath() +")", t);
        }
        
        return null;
    }
    finally
    {
        method.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.HttpMethod; //导入方法依赖的package包/类
/**
 * Execute the given method, authenticated as the given user using ticket-based authentication.
 * @param method method to execute
 * @param userName name of user to authenticate
 * @return status-code resulting from the request
 */
private <T extends Object> T executeWithTicketAuthentication(HttpMethod method, String userName, String password, HttpRequestCallback<T> callback)
{
    String ticket = authDetailProvider.getTicketForUser(userName);
    if(ticket == null)
    {
       ticket = fetchLoginTicket(userName, password);
       authDetailProvider.updateTicketForUser(userName, ticket);
    }
    
    
    
    try
    {
        HttpState state = applyTicketToMethod(method, ticket);
        
       // Try executing the method
        int result = httpProvider.getHttpClient().executeMethod(null, method, state);
        
        if(result == HttpStatus.SC_UNAUTHORIZED || result == HttpStatus.SC_FORBIDDEN)
        {
            method.releaseConnection();
            if(!method.validate())
            {
                throw new RuntimeException("Ticket re-authentication failed for user " + userName + " (HTTPMethod not reusable)");
            }
            // Fetch new ticket, store and apply to HttpMethod
            ticket = fetchLoginTicket(userName, userName);
            authDetailProvider.updateTicketForUser(userName, ticket);
            
            state = applyTicketToMethod(method, ticket);
            
            // Run method agian with new ticket
            result = httpProvider.getHttpClient().executeMethod(null, method, state);
        }
       
        if(callback != null)
        {
            return callback.onCallSuccess(method);
        }
        
        return null;
    }
    catch(Throwable t)
    {
        boolean handled = false;
        // Delegate to callback to handle error. If not available, throw exception
        if(callback != null)
        {
            handled = callback.onError(method, t);
        }
        
        if(!handled)
        {
            throw new RuntimeException("Error while executing HTTP-call (" + method.getPath() +")", t);
        }
        return null;
        
    }
    finally
    {
        method.releaseConnection();
    }
    
}