public DefaultHttpClient() 
{
        super(null, null);
}

 public DefaultHttpClient(HttpParams params) 
{
        super(null, params);
}

 public DefaultHttpClient(ClientConnectionManager conman,
    HttpParams params) 
{
        super(conman, params);
}

Creates a new HTTP client from parameters and a connection manager.

Parameters:

params - the parameters

conman - the connection manager

 protected AuthSchemeRegistry createAuthSchemeRegistry() 
{
        AuthSchemeRegistry registry = new AuthSchemeRegistry(); 
        registry.register(
                AuthPolicy.BASIC, 
                new BasicSchemeFactory());
        registry.register(
                AuthPolicy.DIGEST, 
                new DigestSchemeFactory());
        return registry;
}

 protected ClientConnectionManager createClientConnectionManager() 
{
        SchemeRegistry registry = new SchemeRegistry();
        registry.register(
                new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        registry.register(
                new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
        ClientConnectionManager connManager = null;     
        HttpParams params = getParams();
        ClientConnectionManagerFactory factory = null;
        String className = (String) params.getParameter(
                ClientPNames.CONNECTION_MANAGER_FACTORY_CLASS_NAME);
        if (className != null) {
            try {
                Class< ? > clazz = Class.forName(className);
                factory = (ClientConnectionManagerFactory) clazz.newInstance();
            } catch (ClassNotFoundException ex) {
                throw new IllegalStateException("Invalid class name: " + className);
            } catch (IllegalAccessException ex) {
                throw new IllegalAccessError(ex.getMessage());
            } catch (InstantiationException ex) {
                throw new InstantiationError(ex.getMessage());
            }
        }
        if (factory != null) {
            connManager = factory.newInstance(params, registry);
        } else {
            connManager = new SingleClientConnManager(getParams(), registry); 
        }
        return connManager;
}

 protected ConnectionKeepAliveStrategy createConnectionKeepAliveStrategy() 
{
        return new DefaultConnectionKeepAliveStrategy();
}

 protected ConnectionReuseStrategy createConnectionReuseStrategy() 
{
        return new DefaultConnectionReuseStrategy();
}

 protected CookieSpecRegistry createCookieSpecRegistry() 
{
        CookieSpecRegistry registry = new CookieSpecRegistry();
        registry.register(
                CookiePolicy.BEST_MATCH, 
                new BestMatchSpecFactory());
        registry.register(
                CookiePolicy.BROWSER_COMPATIBILITY, 
                new BrowserCompatSpecFactory());
        registry.register(
                CookiePolicy.NETSCAPE, 
                new NetscapeDraftSpecFactory());
        registry.register(
                CookiePolicy.RFC_2109, 
                new RFC2109SpecFactory());
        registry.register(
                CookiePolicy.RFC_2965, 
                new RFC2965SpecFactory());
        return registry;
}

 protected CookieStore createCookieStore() 
{
        return new BasicCookieStore();
}

 protected CredentialsProvider createCredentialsProvider() 
{
        return new BasicCredentialsProvider();
}

 protected HttpContext createHttpContext() 
{
        HttpContext context = new BasicHttpContext();
        context.setAttribute(
                ClientContext.SCHEME_REGISTRY, 
                getConnectionManager().getSchemeRegistry());
        context.setAttribute(
                ClientContext.AUTHSCHEME_REGISTRY, 
                getAuthSchemes());
        context.setAttribute(
                ClientContext.COOKIESPEC_REGISTRY, 
                getCookieSpecs());
        context.setAttribute(
                ClientContext.COOKIE_STORE, 
                getCookieStore());
        context.setAttribute(
                ClientContext.CREDS_PROVIDER, 
                getCredentialsProvider());
        return context;
}

 protected HttpParams createHttpParams() 
{
        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, 
                HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, 
                HTTP.DEFAULT_CONTENT_CHARSET);
        HttpProtocolParams.setUseExpectContinue(params, 
                true);
        HttpConnectionParams.setTcpNoDelay(params, 
                true);
        HttpConnectionParams.setSocketBufferSize(params, 
                8192);
        // determine the release version from packaged version info
        final VersionInfo vi = VersionInfo.loadVersionInfo
            ("org.apache.http.client", getClass().getClassLoader());
        final String release = (vi != null) ?
            vi.getRelease() : VersionInfo.UNAVAILABLE;
        HttpProtocolParams.setUserAgent(params, 
                "Apache-HttpClient/" + release + " (java 1.5)");
        return params;
}

 protected BasicHttpProcessor createHttpProcessor() 
{
        BasicHttpProcessor httpproc = new BasicHttpProcessor();
        httpproc.addInterceptor(new RequestDefaultHeaders());
        // Required protocol interceptors
        httpproc.addInterceptor(new RequestContent());
        httpproc.addInterceptor(new RequestTargetHost());
        // Recommended protocol interceptors
        httpproc.addInterceptor(new RequestClientConnControl());
        httpproc.addInterceptor(new RequestUserAgent());
        httpproc.addInterceptor(new RequestExpectContinue());
        // HTTP state management interceptors
        httpproc.addInterceptor(new RequestAddCookies());
        httpproc.addInterceptor(new ResponseProcessCookies());
        // HTTP authentication interceptors
        httpproc.addInterceptor(new RequestTargetAuthentication());
        httpproc.addInterceptor(new RequestProxyAuthentication());
        return httpproc;
}

 protected HttpRequestRetryHandler createHttpRequestRetryHandler() 
{
        return new DefaultHttpRequestRetryHandler();
}

 protected HttpRoutePlanner createHttpRoutePlanner() 
{
        return new DefaultHttpRoutePlanner
            (getConnectionManager().getSchemeRegistry());
}

 protected AuthenticationHandler createProxyAuthenticationHandler() 
{
        return new DefaultProxyAuthenticationHandler();
}

 protected RedirectHandler createRedirectHandler() 
{
        return new DefaultRedirectHandler();
}

 protected HttpRequestExecutor createRequestExecutor() 
{
        return new HttpRequestExecutor();
}

 protected AuthenticationHandler createTargetAuthenticationHandler() 
{
        return new DefaultTargetAuthenticationHandler();
}

 protected UserTokenHandler createUserTokenHandler() 
{
        return new DefaultUserTokenHandler();
}