public HttpClient() 
{
     
        if (LOG.isDebugEnabled()) {
            try {
                LOG.debug("Java version: " + System.getProperty("java.version"));
                LOG.debug("Java vendor: " + System.getProperty("java.vendor"));
                LOG.debug("Java class path: " + System.getProperty("java.class.path"));
                LOG.debug("Operating system name: " + System.getProperty("os.name"));
                LOG.debug("Operating system architecture: " + System.getProperty("os.arch"));
                LOG.debug("Operating system version: " + System.getProperty("os.version"));
                Provider[] providers = Security.getProviders();
                for (int i = 0; i <  providers.length; i++) {
                    Provider provider = providers[i];
                    LOG.debug(provider.getName() + " " + provider.getVersion()
                       + ": " + provider.getInfo());   
                }
            } catch (SecurityException ignore) {
            }
        }
        this(new HttpClientParams());
}

Creates an instance of HttpClient using default parameter set .

Also see:

HttpClientParams

 public HttpClient(HttpClientParams params) 
{
        super();
        if (params == null) {
            throw new IllegalArgumentException("Params may not be null");  
        }
        this.params = params;
        this.httpConnectionManager = null;
        Class clazz = params.getConnectionManagerClass();
        if (clazz != null) {
            try {
                this.httpConnectionManager = (HttpConnectionManager) clazz.newInstance();
            } catch (Exception e) {
                LOG.warn("Error instantiating connection manager class, defaulting to"
                    + " SimpleHttpConnectionManager", 
                    e);
            }
        }
        if (this.httpConnectionManager == null) {
            this.httpConnectionManager = new SimpleHttpConnectionManager();
        }
        if (this.httpConnectionManager != null) {
            this.httpConnectionManager.getParams().setDefaults(this.params);
        }
}

Creates an instance of HttpClient using the given parameter set .

Parameters:

params - The parameters to use.

Also see:

HttpClientParams
since: 3.0 -

 public HttpClient(HttpConnectionManager httpConnectionManager) 
{
        this(new HttpClientParams(), httpConnectionManager);
}

Creates an instance of HttpClient with a user specified HTTP connection manager .

Parameters:

httpConnectionManager - The connection manager to use.

since: 2.0 -

 public HttpClient(HttpClientParams params,
    HttpConnectionManager httpConnectionManager) 
{
        super();
        if (httpConnectionManager == null) {
            throw new IllegalArgumentException("httpConnectionManager cannot be null");  
        }
        if (params == null) {
            throw new IllegalArgumentException("Params may not be null");  
        }
        this.params = params; 
        this.httpConnectionManager = httpConnectionManager;
        this.httpConnectionManager.getParams().setDefaults(this.params);
}

Creates an instance of HttpClient with a user specified parameter set and HTTP connection manager .

Parameters:

params - The parameters to use.

httpConnectionManager - The connection manager to use.

since: 3.0 -

 public int executeMethod(HttpMethod method) throws IOException, HttpException 
{
            
        LOG.trace("enter HttpClient.executeMethod(HttpMethod)");
        // execute this method and use its host configuration, if it has one
        return executeMethod(null, method, null);
}

Executes the given HTTP method .

 public int executeMethod(HostConfiguration hostConfiguration,
    HttpMethod method) throws IOException, HttpException 
{
    
        LOG.trace("enter HttpClient.executeMethod(HostConfiguration,HttpMethod)");
        return executeMethod(hostConfiguration, method, null);
}

Executes the given HTTP method using custom host configuration .

 public int executeMethod(HostConfiguration hostconfig,
    HttpMethod method,
    HttpState state) throws IOException, HttpException 
{
            
        LOG.trace("enter HttpClient.executeMethod(HostConfiguration,HttpMethod,HttpState)");
        if (method == null) {
            throw new IllegalArgumentException("HttpMethod parameter may not be null");
        }
        HostConfiguration defaulthostconfig = getHostConfiguration();
        if (hostconfig == null) {
            hostconfig = defaulthostconfig;
        }
        URI uri = method.getURI(); 
        if (hostconfig == defaulthostconfig || uri.isAbsoluteURI()) {
            // make a deep copy of the host defaults
            hostconfig = (HostConfiguration) hostconfig.clone();
            if (uri.isAbsoluteURI()) {
                hostconfig.setHost(uri);
            }
        }
        HttpMethodDirector methodDirector = new HttpMethodDirector(
                getHttpConnectionManager(),
                hostconfig,
                this.params,
                (state == null ? getState() : state));
        methodDirector.executeMethod(method);
        return method.getStatusCode();
}

Executes the given HTTP method using the given custom host configuration with the given custom HTTP state .

 public String getHost() 
{
         return hostConfiguration.getHost();
}

Returns the default host.

 public synchronized HostConfiguration getHostConfiguration() 
{
        return hostConfiguration;
}

Returns the host configuration associated with the HttpClient.

 public synchronized HttpConnectionManager getHttpConnectionManager() 
{
        return httpConnectionManager;
}

Returns the HTTP connection manager associated with the HttpClient.

 public HttpClientParams getParams() 
{
        return this.params;
}

Returns HTTP protocol parameters associated with this HttpClient.

 public int getPort() 
{
         return hostConfiguration.getPort();
}

Returns the default port.

 public synchronized HttpState getState() 
{
    
    // ------------------------------------------------------------- Properties
        return state;
}

Returns HTTP state associated with the HttpClient.

 public synchronized boolean isStrictMode() 
{
        return false;
}

Returns the value of the strict mode flag.

 public synchronized  void setConnectionTimeout(int newTimeoutInMilliseconds) 
{
       this.httpConnectionManager.getParams().setConnectionTimeout(newTimeoutInMilliseconds);
}

Sets the timeout until a connection is etablished. A value of zero means the timeout is not used. The default value is zero.

 public synchronized  void setHostConfiguration(HostConfiguration hostConfiguration) 
{
        this.hostConfiguration = hostConfiguration;
}

Assigns the host configuration to use with the HttpClient.

 public synchronized  void setHttpConnectionFactoryTimeout(long timeout) 
{
        this.params.setConnectionManagerTimeout(timeout);
}

Sets the timeout in milliseconds used when retrieving an HTTP connection from the HTTP connection manager .

 public synchronized  void setHttpConnectionManager(HttpConnectionManager httpConnectionManager) 
{
        this.httpConnectionManager = httpConnectionManager;
        if (this.httpConnectionManager != null) {
            this.httpConnectionManager.getParams().setDefaults(this.params);
        }
}

Assigns the HTTP connection manager to use with the HttpClient.

 public  void setParams(HttpClientParams params) 
{
        if (params == null) {
            throw new IllegalArgumentException("Parameters may not be null");
        }
        this.params = params;
}

Assigns HTTP protocol parameters for this HttpClient.

 public synchronized  void setState(HttpState state) 
{
        this.state = state;
}

Assigns HTTP state for the HttpClient.

 public synchronized  void setStrictMode(boolean strictMode) 
{
        if (strictMode) {
            this.params.makeStrict();
        } else {
            this.params.makeLenient();
        }
}

Defines how strictly the method follows the HTTP protocol specification (see RFC 2616 and other relevant RFCs). In the strict mode the method precisely implements the requirements of the specification, whereas in non-strict mode it attempts to mimic the exact behaviour of commonly used HTTP agents, which many HTTP servers expect.

 public synchronized  void setTimeout(int newTimeoutInMilliseconds) 
{
        this.params.setSoTimeout(newTimeoutInMilliseconds);
}

Sets the socket timeout (SO_TIMEOUT) in milliseconds which is the timeout for waiting for data. A timeout value of zero is interpreted as an infinite timeout.